Discussion :

[Tuxico]

Bonjour à tous,

voilà j'ai une appli. client/serveur qui fonctionne via TCP.

J'aimerai permettre l'échange de fichiers. Celui-ci marche mais uniquement pour des fichiers de certaines tailles (+/- 4ko...) après quoi, si je transfère, par exemple, un .rar de 10mo, j'obtiens 0 octets à l'arrivée...
J'ai fait pas mal de recherches, mais je ne comprends toujours pas pourquoi cette limite.

Voici mon code:

(le serveur envoie au client)

Code de l'envoi du fichier (coté serveur):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
            File toSend = new File(userPrefModel_.getPref()[1]+"\\"+askedFile);     
            DataInputStream dataInput = null;
            try{
                dataInput=new DataInputStream((new FileInputStream(toSend)));
            }catch(FileNotFoundException e){
                e.printStackTrace();
            }
            try{
                byte i=dataInput.readByte();
                DataOutputStream dataOutput = new DataOutputStream(clientOutput_);
                while(i!=-1){
                    dataOutput.writeByte(i);
                    i=dataInput.readByte();
                }
            }catch(IOException e){
                e.printStackTrace();
            }
        }

code de la réception du fichier (côté client):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
        DataOutputStream out = null;       
        try{
            out = new DataOutputStream(new FileOutputStream(f));
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }
        DataInputStream dataInput = new DataInputStream(inputStream_);
        try{
            byte b = dataInput.readByte();
            while(b!=-1){
                out.write(b);
                b = dataInput.readByte();
            }
        }catch(Exception e){
            e.printStackTrace();
        }

Une idée? :s


merci

[dinobogan]

Tu dois avoir un peu de lag sur ta connexion. Ta méthode pour savoir si le flux est terminé côté client n'est pas bonne. Il faut faire plusieurs essais avant de fermer le flux. De plus, il faut lire un tableau au lieu de byte par byte.
Essai avec cette algo côté client :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
DataOutputStream out = null;       
        try{
            out = new DataOutputStream(new FileOutputStream(f));
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }
        DataInputStream dataInput = new DataInputStream(inputStream_);
        try{
            byte[] lire = new byte[ 1024 ];
            int taille = 0;
            int essai = 0;
            while( essai < 10 || ( taille = dataInput.read( lire ) ) > 0 )
            {
                if( taille > 0 )
                {
                        out.write( lire, 0, taille );
                        essai = 0;
                }
                else
                {
                        ++essai;
                        try { Thread.sleep( 100 ); }
                        catch( InterruptedException exc ) {}
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }

Tu peux affiner le temps de pause.
Il faut également écrire les données par bloc dans le serveur. Inspire-toi du client ci-dessus.

[Tuxico]

Merci pour ta réponse,

je viens de faire plusieurs tests et voici le problème:

Si je transfère par exemple un fichier de 3,2 ko, je me retrouve avec un de 4ko à l'arrivée.

Je suppose donc une lecture trop longue par rapport à la taille du fichier, mais comment savoir quand s'arrêter? merci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
        DataOutputStream out = null;       
        try{
            out = new DataOutputStream(new FileOutputStream(f));
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }
        DataInputStream dataInput = new DataInputStream(inputStream_);
        try{
            byte[] lire = new byte[ 1024 ];
            int taille = 0;
            int essai = 0;
            taille = dataInput.read(lire);
            while (essai<50 || (taille > 0))
            {
               if( taille > 0 )
                {
                        out.write( lire, 0, taille );
                        essai = 0;
                }
                else
                {
                        ++essai;
                        try { Thread.sleep( 1000 ); }
                        catch( InterruptedException exc ) {}
                }
                taille = dataInput.read(lire);
            } 
            out.close();
        }catch(Exception e){
            e.printStackTrace();
        }

Serveur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 File toSend = new File(userPrefModel_.getPref()[1]+"\\"+askedFile);     
            DataInputStream dataInput = null;
            int size = 0;
            try{
                dataInput=new DataInputStream((new FileInputStream(toSend)));
            }catch(FileNotFoundException e){
                e.printStackTrace();
            }
            try{
                byte[] bb = new byte[1024];
                int i=dataInput.read(bb);
                DataOutputStream dataOutput = new DataOutputStream(clientOutput_);
                while(i!=-1){
                    dataOutput.write(bb);
                    i=dataInput.read(bb);
                } 
                dataOutput.close();                
            }catch(IOException e){
                e.printStackTrace();
            }

merci encore

[dinobogan]

Le code du serveur n'est pas bon. Il ne gère pas la taille réellement lue du tableau. Donc le dernier tableau lu est envoyer intégralement, même s'il n'est rempli qu'à moitié.
Il suffisait pourtant d'adapter le serveur en fonction du code du client que j'ai donné

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
byte[] bb = new byte[1024];
int taille = 0;
DataOutputStream dataOutput = new DataOutputStream(clientOutput_);
 
while( ( taille = dataInput.read( bb ) ) > 0 )
{
  dataOutput.write( bb, 0, taille );
}

De plus, un temps de pause d'une seconde est un peu long dans un réseau "normal". Car on arrive à 50 secondes après 50 essais !
Le nombre d'essais est également trop élevé.
"essais * pause" ne devrait pas dépasser 2 à 5 secondes environ.

[Tuxico]

En effet, comment ai-je pu passer à côté du fait que le dernier byte[] evnoyé n'était pas rempli...



bref,

pour le Thread.sleep et les essais, c'était un test en rapport avec le programme en lui-même


merci

[Tuxico]

Par contre je vais devoir adapter "essai" en fonction de la taille du fichier.

Si je transfère un fichier de 150mo, essai devra e^tre très élevé...

je vais plancher là-dessus

[dinobogan]

Par contre je vais devoir adapter "essai" en fonction de la taille du fichier.

Si je transfère un fichier de 150mo, essai devra e^tre très élevé...

je vais plancher là-dessus

Non justement ! La taille du fichier n'a rien à voir avec le nombre d'essais.
Lorsqu'une lecture du client est un succès, le nombre d'essais est remit à zéro. Le nombre d'essais est sur un tableau de bytes, par sur la totalité d'un fichier.

[Tuxico]

ok je comprends mieux


merci pour ton temps