Discussion :

[gilles06]

Bonjour a tous,

Voila j'ai un probleme sur un de mes scripts Python 25 faisant du FTP Data binary transfer sur un server.
De temps en temps en FTP Download je perds la connection avec le server, et je recois une exception "timeout".
J'ai recu une partie du fichier avant l'exception de timeout.
J'ai essaye de faire du retry (de relancer la commande "data = conn.recv(blocksize)"), mais sans succes.

Question: Comment reprendre une connection, la ou elle s'est arretée sans tout relancer ?

Merci de votre aide.

Mon code:

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
 
    def retrBinary(self, remote_file, blocksize=8192, rest=None):
        try:
            self.ftptransfer.ftp.voidcmd('TYPE I')
            conn = self.ftp.transfercmd("RETR %s" % remote_file, rest)
            while 1:
                data = conn.recv(blocksize)
                if (not data) and (self.SrcRemoteFileSize != self.totalBytes):
                    # Start Retry to FTP server
                    retry=1
                    print(">>> Received Data buffer empty and file not ended, Start Retry to FTP server")
                    while ((not data) and (retry<=3)):
                        print(">>> Retry data %s" % (retry))
                        data = conn.recv(blocksize)
                        if not data: retry +=1
                        else: 
                            break
                        time.sleep(2)
                    break
 
            print "Close Download file transfer\n"
            conn.close()            
            print "DL: Return voidresp"
            return self.ftp.voidresp() 
 
        except Exception, err:
            print traceback.format_exc()
            print("Received Exception during Transfer"

[wiztricks]

Salut,

Votre code n'est pas complet, il devrait suffire de renseigner "rest" et de croiser les doigts pour le serveur FTP (de son côté) supporte.

Je trouve qu'il est un peu "compliqué", jetez un œil au post que j'avais commis sur le sujet, il y quelques temps.

Cordialement,
- W

[tyrtamos]

Bonjour,

D'abord, on peut essayer d'empêcher les déconnexions intempestives, ou au moins de les rendre plus rares, avec une astuce: http://python.developpez.com/faq/?pa...AllTimeConnect.

On devrait aussi pouvoir reprendre un téléchargement fait incomplètement en utilisant l'option 'rest' de la commande retrbinary. Il s'agit d'un offset qui définira à partir de quel endroit le téléchargement reprendra. Si le serveur ne le supporte pas, cela générera une erreur ftplib.error_reply et il suffira alors de reprendre le téléchargement à 0 sans le 'rest'.

J'ai déjà utilisé ce genre de technique en téléchargement http, mais jamais en ftp. Voir le message de wiztricks.

[gilles06]

Merci pour la reponse.
Je crois avoir compris, en fait il faut rejouer la connection avec le reste du fichier a transferer, en esperant que le serveur support la fonction RESTART.
Effectivement, je vais alleger mon code et re-essayer.

Merci

Bien Cordialement

[gilles06]

Bonjour a tous,
J'ai encore une question, car apres avoir modifier mon code, lorsque je relance la commande de reconnection apres une tres longue attente sans reponse du serveur "ftp.transfercmd("RETR %s" % remote_file, rest=self.RestBytes)" et je recois systematiquement un
"10053, 'Software caused connection abort'" venant du server.

Question: Est-ce que le serveur arrete la connection parcqu'il est tombe en Timeout ou qu'il ne support pas la commande restart ? ou bien est-ce que ma commande de restart n'est pas conforme ?

......
{'t':565.917, DL 'bytes_transferred':3011676, 'throughput':43.235}
[ftpDL t=600s]
{'t':603.212, DL 'bytes_transferred':3212364, 'throughput':43.051}
{'t':641.129, DL 'bytes_transferred':3413052, 'throughput':42.346}
[ftpDL t=660s]
{'t':679.671, DL 'bytes_transferred':3613740, 'throughput':41.658}
{'t':718.107, DL 'bytes_transferred':3814428, 'throughput':41.774}
[ftpDL t=720s]
{'t':757.166, DL 'bytes_transferred':4015116, 'throughput':41.107}
[ftpDL t=780s]
[ftpDL t=840s]
[ftpDL t=900s]
[ftpDL t=960s]
[ftpDL t=1020s]
[ftpDL t=1080s]
>>> Type_3: Received Exception during DL Transfer, TypeError: timed out
>>> Re-start Data Transfer from: 4145124
*cmd* 'PASV'
*put* 'PASV\\r\\n'
Traceback (most recent call last):
conn = self.ftptransfer.ftp.transfercmd("RETR %s" % remote_file, rest=self.totalBytes)
File "C:\\Python25\\lib\\ftplib.py", line 360, in transfercmd
return self.ntransfercmd(cmd, rest)[0]
File "C:\\Python25\\lib\\ftplib.py", line 325, in ntransfercmd
host, port = self.makepasv()
File "C:\\Python25\\lib\\ftplib.py", line 303, in makepasv
host, port = parse227(self.sendcmd('PASV'))
File "C:\\Python25\\lib\\ftplib.py", line 244, in sendcmd
self.putcmd(cmd)
File "C:\\Python25\\lib\\ftplib.py", line 175, in putcmd
self.putline(line)
File "C:\\Python25\\lib\\ftplib.py", line 170, in putline
self.sock.sendall(line)
File "<string>", line 1, in sendall
error: (10053, 'Software caused connection abort')

>>> Received Exception during DL Transfer, TypeError: (10053, 'Software caused connection abort')
DL: Close Local file

[fred1599]

J'ai encore une question, car apres avoir modifier mon code

Ah donc...

[gilles06]

Pas compris la reponse ...
Ma question est plus sur la commande, je ne suis pas sur que la commande de RESTART fonctionne bien avecce serveur.
Merci de votre aide.

[fred1599]

Si vous modifiez le code, mieux vaut remettre le code modifié, vous ne croyez pas?

Sinon que dois faire Restart exactement ? Détecter l'arrêt du server et redémarrer le download, c'est ça?

[gilles06]

OK, voila le code modifié:
En fait, le transfert est OK tant que le buffer "data" n'est pas vide. Des que je recois un buffer vide (correspondant au EOF) et si le cumul de Data "self.totalBytes" n'est pas egal au fichier Source, alors j'attends 10s et je recheck mon buffer (delais du serveur), si mon buffer est tj vide apres 10s, alors je lance la commande
"conn = self.ftptransfer.ftp.transfercmd("RETR %s" % remote_file, rest=self.totalBytes)" en recuperant les Data "data = conn.recv(blocksize)"
et je recheck le buffer.
Et si tj vide, alors j'abort la connection.

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
 
    def retrBinary(self, remote_file, blocksize=8192, rest=None):        
        try:
            self.ftptransfer.ftp.voidcmd('TYPE I')
            conn = self.ftptransfer.ftp.transfercmd("RETR %s" % remote_file, rest=None)
            while 1:
                try:
                    data = conn.recv(blocksize)
                except Exception, err:
                    print("Received Exception during %s Transfer, TypeError: %s" % (self.mode_ul_dl,str(err)))
                    print(">>> Re-start Data Transfer from: %s" % (self.totalBytes))
                    conn = self.ftptransfer.ftp.transfercmd("RETR %s" % remote_file, rest=self.totalBytes)
                    data = conn.recv(blocksize)
 
                if (not data) and (self.SrcRemoteFileSize != self.totalBytes):                    
                    print(">>> Received Data buffer empty and file not ended, Restart FTP server at %s" % (self.totalBytes))                    
                    try:
                        print(">>> Wait 10 seconds")
                        time.sleep(10)
                        data = conn.recv(blocksize)
                        if not data: 
                            print(">>> Data buffer still empty after 10s, Restart connection to FTP server at %s" % (self.totalBytes))                    
                            conn = self.ftptransfer.ftp.transfercmd("RETR %s" % remote_file, rest=self.totalBytes)
                            data = conn.recv(blocksize)                                   
                    except Exception, err:
                        print traceback.format_exc()
                        print("Received Exception during Retreiving %s Data Transfer, TypeError: %s" % (self.mode_ul_dl,str(err)))                  
                if not data: 
                    print("\n>>> EOF Detected or DL RCV Buffer Empty")
                    if self.SrcRemoteFileSize != self.totalBytes: 
                        print(">>>> Problem: Received EOF or Buffer Empty before the End of the Complete File")
                    break             
                self.transferCallback(data) 
 
            print "Close Download file transfer\n"
            conn.close()            
            print "DL: Return voidresp"
            return self.ftptransfer.ftp.voidresp() 
 
        except Exception, err:
            print traceback.format_exc()
            print("Received Exception during %s Transfer, TypeError: %s" % (self.mode_ul_dl,str(err)))

[fred1599]

tentez-vous de faire une reprise de téléchargement au cas où le server est out?

[gilles06]

Oui, c'est ce que j'essaye de faire. Mais sans succes.

[fred1599]

Apparemment il est difficile de trouver quelquechose de concret avec ftplib et réinventer la roue me paraît un peu dommage avec python.

Si je peux vous conseiller Chilkat, avec un exemple permettant de faire le téléchargement avec contrôle d'arrêt momentané.

Son lien pour le téléchargement est ici.

Désolé de ne pas plus pouvoir vous aider avec ftplib.

Edit : Attention c'est un module commercial, payant au bout de 30 jours (dommage)

[tyrtamos]

Bonjour,

J'ai fait fonctionner la reprise du téléchargement, et je peux donc proposer du code: est-ce que le problème existe toujours?

[fred1599]

J'ai fait fonctionner la reprise du téléchargement, et je peux donc proposer du code: est-ce que le problème existe toujours?

Je pense que oui Tyrtamos, en tout cas, ça sera utile pour d'autres se posant la même question.

En tout cas, je veux savoir si tu as travaillé sur le paramètre rest

[tyrtamos]

Bonjour,

Voilà le code qui m'a permis de tester le téléchargement avec reprise. J'ai, bien entendu, utilisé l'option 'rest' de la méthode 'retrbinary'.

Le code est complet et très auto-commenté. Il est écrit en Python 2.7.

Il devrait fonctionner après un simple copier-coller, en ayant ajouté ce qui manque: les infos concernant le serveur ftp et le fichier à télécharger.

Il y a 3 objets importants:
-> la fonction connectftp qui assure la connexion au serveur et l'ouverture de la session
-> la fonction downloadfichierftp qui lance le téléchargement avec, si nécessaire, la reprise d'un téléchargement antérieur interrompu
-> la classe Callback qui permet non seulement de "remplir" le fichier sur disque au fur et à mesure du téléchargement des blocs, mais aussi d'afficher une progression.

Pour la reprise, on calcule la taille du fichier à télécharger et celle du fichier sur disque s'il existe. Si la 1ère est supérieure ou égale à la seconde, on utilise la reprise (offset=taille du fichier sur disque). D'ailleurs, dans ce cas, si les 2 tailles sont égales, il n'y a aucun transfert.

Il faut avoir conscience du danger potentiel si on utilise la reprise sans discernement: le fichier sur disque de taille plus petite que celui du ftp existe peut-être déjà parce qu'il était d'une version antérieure: la reprise serait alors une erreur!

Pour tester, j'ai ajouté 2 lignes de code à dé-commenter dans le callback pour obtenir un téléchargement incomplet.

NB: mes 1ères tentatives de calcul de la taille du fichier ftp par ftp.size se sont soldées par des erreurs du genre 'interdit en mode ASCII'. J'ai donc cherché comment on mettait en mode binaire, et il a fallu que j'épluche le code de ftplib.py pour le trouver: c'est 'ftp.sendcmd('TYPE I')'.

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
126
127
128
129
130
131
#!/usr/bin/python
# -*- coding: utf-8 -*-
from __future__ import division
# Python 2.7
 
import sys, os
import ftplib
 
#############################################################################
def msgerr():
    """pour afficher l'erreur en clair: type d'erreur, message d'erreur"""
    return u"Erreur (%s): %s" % (sys.exc_info()[0].__name__, sys.exc_info()[1])
 
#############################################################################
class Callback(object):
 
    def __init__(self, ficdsk, offset=0, tailleftp=0):
        if offset==0:
            self.f = open(ficdsk, 'wb') # on crée le fichier ou on le remet à 0
        else:
            self.f = open(ficdsk, 'ab') # on ajoute au fichier existant
        self.nblocs = 0 # numéro de bloc téléchargé
        self.noctets = offset # nb d'octets chargés depuis le début du chargement
        self.tailleftp = tailleftp # taille du fichier à télécharger
 
    def __call__(self, bloc):
        """appelé à chaque bloc téléchargé """
        self.f.write(bloc)
        self.nblocs += 1 # incrémenter le nb de blocs téléchargés
        self.noctets += len(bloc) # incrémenter le nb d'octets téléchargés
 
        # affichage de la progression
        prog = u""
        if self.tailleftp > 0:
            prog = u"%.2f" % (self.noctets/self.tailleftp*100,)
        print self.nblocs, self.noctets, prog
 
        # à décommenter pour fabriquer un fichier disque incomplet
        #if self.nblocs == 10:
        #    self.fin()
 
    def fermer(self):
        self.f.close()
 
#############################################################################
def downloadfichierftp(ftp, ficftp, repdsk):
    """charge le fichier ftp ficftp (sans chemin) dans le rép. disque repdsk
       le fichier ficftp est censé être dans le répertoire courant ftp
    """
 
    # calcul du chemin du fichier à créer sur disque
    ficdsk = os.path.join(repdsk, ficftp)
 
    # calcul de la taille du fichier sur ftp
    ftp.sendcmd('TYPE I') # passer en mode binaire (sinon, erreur avec size)
    tailleftp = ftp.size(ficftp)
    if tailleftp == None:
        tailleftp = 0 # au cas où size ne serait pas supporté   
 
    # calcul de la taille du fichier sur disque s'il existe déjà
    tailledsk = 0
    if os.path.exists(ficdsk):
        tailledsk = os.path.getsize(ficdsk)
 
    # comparaison des tailles des fichiers et calcul de l'offset
    offset = 0        
    if tailleftp >= tailledsk:
        offset = tailledsk
 
    # téléchargement
    callback = Callback(ficdsk, offset, tailleftp)
    try:
        # télécharger avec reprise si offset>0
        ftp.retrbinary('RETR ' + ficftp, callback, rest=offset)
    except ftplib.error_reply:
        # l'option 'rest' n'est pas supportée
        callback.fermer() # fermer le fichier sur disque
        callback = Callback(ficdsk, 0, tailleftp) # réouvrir avec offset=0
        ftp.retrbinary('RETR ' + ficftp, callback) # télécharger sans le 'rest'   
    callback.fermer() # fermer le fichier sur disque
 
#############################################################################
def connectftp(serveur, nom, mdp):
 
    ftp = ftplib.FTP()    
 
    # tentative de connexion au serveur
    try:
        welcome = ftp.connect(serveur)
    except:
        raise ValueError ("serveur ftp inconnu ou non joignable")
 
    # tentative d'ouverture de session par l'utilisateur
    try:
        ftp.login(nom, mdp)
    except:
        ftp.quit()
        raise ValueError ("nom ou mot-de-passe inconnu du serveur ftp")                
 
    return ftp, welcome
 
#############################################################################
if __name__ == "__main__":
 
    serveur = "xxxxxxx" # <== l'adresse du serveur ftp
    nom = "xxxxxx" # <== nom de l'utilisateur
    mdp = "xxxxxxx" # <== mot de passe
 
    # répertoire dans lequel se trouve le fichier à télécharger
    repftp = "/xxxxx/xxxxx/xxxxx"
    # fichier à télécharger
    ficftp = "xxxxxxxxx.xxx"
 
    # répertoire du disque dans lequel on veut placer le fichier téléchargé
    repdsk = r"C:\xxxxxx\xxxxx\xxxx"
 
    try:
        ftp, welcome = connectftp(serveur, nom, mdp)
        print u"connexion serveur: " + welcome
        print
 
        # mettre le répertoire ftp comme répertoire courant
        ftp.cwd(repftp)
        # télécharger le fichier
        downloadfichierftp(ftp, ficftp, repdsk)
 
        ftp.quit()
        print
        print u"Fin du téléchargement"    
    except Exception:
        print msgerr()

[edit] s'il fallait télécharger avec une interface graphique (tkinter, PyQt4, etc.), il faudrait le faire dans un thread afin d'éviter le gel de cette interface. Et dans ce cas, la progression serait transmise uniquement sous forme de message, puisque les threads ne doivent pas toucher directement aux objets graphiques. Au titre de 'source d'inspiration', voir ici: http://python.jpvweb.com/mesrecettes..._fichier_pyqt4.

[fred1599]

Bravo!