Discussion :

[HunTR]

Bonjour,
Mon projet en ce moment est de faire un programme qui envoie des fichiers sur un serveur ftp. Donc il fonctionne avec la librairie commons net d'apache, mais j'aimerai le faire un peu plus évoluer. C'est à dire faire une fonction pour voir la progression de l'envoi et pourquoi pas la vitesse également.
J'envoie fichier par fichier, donc une connexion = 1 upload.



J'ai pas mal fouiller sur le net, et je vois la fonction dans la doc de commons :

public OutputStream storeUniqueFileStream(String remote) throws IOException

Est ce que cette méthode peut me servir pour faire une progressbar ?
Vu qu'il retourne, ce qui a été envoyé ?
il faut faire une comparaison de taille sur le fichier en envois et et le flux envoyé ??


Voilà mon code qui permet d'envoyer un fichier

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
package Moteur;
import java.io.*;
import java.net.SocketException;
 
//import org.apache.commons.net.PrintCommandListener;
import org.apache.commons.net.ftp.*;
 
public class Ftp extends FTPClient
{
 
	public Ftp()
	{
 
	}
 
   	public boolean Upload(String server, String username, String password, String remote, String local) throws IOException
    {
 
		boolean error = false;
 
 
        //this.addProtocolCommandListener(new PrintCommandListener( new PrintWriter(System.out))); //Active les écoutes des commandes FTP
 
        try
        {
 
            this.connect(server);
            //System.out.println("Connected to " + server + ".");
 
            int reply = this.getReplyCode();
 
            if (!FTPReply.isPositiveCompletion(reply))
            {
                this.disconnect();
                System.err.println("Connexion refusée.");             
            }
        }
        catch (IOException e)
        {
            if (this.isConnected())
            {
                try
                {
                    this.disconnect();
                }
                catch (IOException f)
                {
                    // do nothing
                }
            }
            System.err.println("Impossible de joindre le serveur.");
            //e.printStackTrace();
        }
 
        try
        {
 
 
            if (!this.login(username, password))
            {
                this.logout();
                error = true;
                System.out.println("Login ou mot de passe non valide");
            }
 
            //System.out.println("Remote system is " + this.getSystemName());
 
            this.setFileType(FTP.BINARY_FILE_TYPE);
 
            this.enterLocalPassiveMode();
 
 
            InputStream input;
 
            input = new FileInputStream(local);
 
            this.storeFile(remote, input);
 
            input.close();
 
            this.logout();
        }
        catch (FTPConnectionClosedException e)
        {
            error = true;
            System.err.println("Server closed connection.");
            //e.printStackTrace();
        }
        catch (IOException e)
        {
            error = true;
            //e.printStackTrace();
        }
        finally
        {
            if (this.isConnected())
            {
                try
                {
                    this.disconnect();
                }
                catch (IOException f){}
            }
        }
 
     return error;
    }
 
   	public boolean TestConnexion(String server) throws SocketException, IOException			//Test si le serveur est joignable
   	{
   		boolean error = false;
 
        this.connect(server);
        int reply = this.getReplyCode();  
        if (FTPReply.isPositiveCompletion(reply))
            {
                this.disconnect();
                System.err.println("Connexion refusée.");             
            }
 
        return error;
   	}
 
 
}

Dites moi rapidement si je suis aux fraises et comment je peux arriver à faire ce que je veux.
Merci

[dinobogan]

Une possibilité : tu créés ton propre FileInputStream en surchargeant les méthodes de lecture. Tu y ajoutes un listener qui sera renseigné à chaque appel des méthode de lecture avec le nombre d'octets lu. Dans le listener, tu peux par exemple additionner les tailles et mettre à jour ta GUI toutes les secondes par exemple. Du coup, tu as la taille totale, la taille lue en un temps donnée, tu peux donc obtenir le taux de transfert et le pourcentage d'avancement.

[HunTR]

Je doit être nœud-nœud car j'ai pas compris en fait. Au début je pensais avoir compris.
J'ai testé plein de truc depuis hier mais j'arrive à rien.
Ce que je voudrais c'est juste avoir en retour le nombre d'octet envoyé.
je pensais qu'avec cette méthode : public OutputStream storeUniqueFileStream(String remote) throws IOException

je pouvais avoir ça et puis à partir de là calculer vitesse etc...

Bref j'ai pas compris grand chose aux streams..

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
 
             InputStream is = new FileInputStream(local);  
             is = new ProgressMonitorInputStream(null, "Uploading", is);  
             OutputStream os = this.storeFileStream(remote);  
             byte[] buffer = new byte[1024];  
             int len, len1=0;  
             while ((len = is.read(buffer)) != -1)  
             { 
            	if (len!=len1)System.out.println("len : " + len);
            	len1 = len;
               os.write(buffer, 0, len);  
               os.flush();  
           }  
           is.close();  
           os.close();

[dinobogan]

Le flush doit être fait en dehors de la boucle. Ceci permettra d'accroitre les performances si le flux est bufferisé.
Ensuite, pour calculer la taille totale émise il suffit d'incrémenter une variable, et pour avoir la vitesse, il suffit d'ajouter la notion de temps.
Avec le code suivant, tu calcules la vitesse moyenne depuis le début de traitement. Tu peux aussi t'amuser à calculer la vitesse instantanée.
Exemple de code (non compilé) :

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
 
  InputStream is = new FileInputStream(local);  
  OutputStream os = this.storeFileStream( remote );
  byte[] buffer = new byte[1024];  
  int total = 0;
  int taille_lue = 0;
  int temps_debut = System.currentTimeMillis();
  int temps_fin = temps_debut;
  int vitesse = 0;
 
  while( ( taille_lue = is.read( buffer ) ) > 0 )  
  {
    total += taille_lue;
    os.write( buffer, 0, taille_lue );  
    temps_fin = System.currentTimeMillis();
    vitesse = total / ( ( temps_fin - temps_debut ) / 1000 );
  }
 
  os.flush();
  is.close();
  os.close();

[HunTR]

J'ai testé ça et j'ai des erreurs,

Taille 1024
Exception in thread "AWT-EventQueue-0" java.lang.NullPointerException
at test.Ftp.Upload(Ftp.java:94)
at test.Ftp$1.run(Ftp.java:158)
at java.awt.event.InvocationEvent.dispatch(Unknown Source)
at java.awt.EventQueue.dispatchEvent(Unknown Source)
at java.awt.EventDispatchThread.pumpOneEventForFilters(Unknown Source)
at java.awt.EventDispatchThread.pumpEventsForFilter(Unknown Source)
at java.awt.EventDispatchThread.pumpEventsForHierarchy(Unknown Source)
at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
at java.awt.EventDispatchThread.run(Unknown Source)


Si tu peux m'aider à décoder ce message d'erreur ça serait cool.

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
InputStream is = new FileInputStream(local);  
            OutputStream os = this.storeFileStream( remote );
            byte[] buffer = new byte[1024];  
            long total = 0;
            int taille_lue = 0;
            long temps_debut = System.currentTimeMillis();
            long temps_fin = temps_debut;
            long speed = 0;
 
            while( ( taille_lue = is.read( buffer ) ) > 0 )  
            {
              System.out.println("Taille " + taille_lue);
              total += taille_lue;
              os.write( buffer, 0, taille_lue );
              temps_fin = System.currentTimeMillis();
              speed = total / ( ( temps_fin - temps_debut ) / 1000 );
            }
 
            os.flush();
            is.close();
            os.close();

[dinobogan]

Donne le code complet ainsi que la ligne d'où provient l'erreur.
Et regarde dans la documentation, il faut certainement vérifier la non nullité de l'output stream, car si la connection n'est pas possible, alors tu écris dans un flux qui n'existe pas.