Daemon upload automatique sur serveur ftp

**Slaan** · 14/03/2014, 13h15

Bonjour à tous.

Je vous expose mon projet :
Je souhaite créer une tache récurrente sous Debian qui upload automatiquement n'importe quel fichier sur plusieurs serveurs FTP des qu'il se trouve dans un dossier et, une fois l'upload terminé, efface le dit fichier.
Un Daemon python me semble une bonne idée, avec la class EventHandler et son process = subprocess.call.

Je coince sur un os, rien ne se passe

Voici mon code. Qu'en pensez vous ? :

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
 
# Example: daemonize pyinotify's notifier.
# Requires Python >= 2.5
import functools
import sys
import pyinotify
import subprocess
 
class Counter(object):
    """
    Simple counter.
    """
    def __init__(self):
        self.count = 0
    def plusone(self):
        self.count += 1
 
class EventHandler(pyinotify.ProcessEvent):
    def process_IN_CLOSE_WRITE(self, event):
        print "Close_write:", event.pathname
        fichier = event.pathname
        if '.mp4' in fichier or '.mkv' in fichier or '.avi' in fichier:
            process = subprocess.call(['ncftpput', '-m', '-u LOGIN', '-p PASS', 'FTP.SERVEUR1.COM' '/', fichier])
            process = subprocess.call(['ncftpput', '-m', '-u LOGIN', '-p PASS', 'FTP.SERVEUR2.COM' '/', fichier])
            process = subprocess.call(['ncftpput', '-m', '-u LOGIN', '-p PASS', 'FTP.SERVEUR3.COM' '/', fichier])
            process = subprocess.call(['rm', fichier, 'home/jo/testftp2/'])
def on_loop(notifier, counter):
    """
    Dummy function called after each event loop, this method only
    ensures the child process eventually exits (after 5 iterations).
    """
    sys.stdout.write("Loop %d\n" % counter.count)
    counter.plusone()
 
handler = EventHandler()
wm = pyinotify.WatchManager()
notifier = pyinotify.Notifier(wm, handler)
wm.add_watch('/home/jo/testftp/', pyinotify.IN_CLOSE_WRITE)
on_loop_func = functools.partial(on_loop, counter=Counter())
try:
    notifier.loop(daemonize=True, callback=on_loop_func,
                 pid_file='/tmp/pyinotify.pid', stdout='/tmp/stdout.txt')
except pyinotify.NotifierError, err:
    print >> sys.stderr, err

Je me suis inspiré de cette aide ici :
http://forum.ubuntu-fr.org/viewtopic.php?pid=9218931

Merci !

**VinsS** · 14/03/2014, 16h26

Salut,

Tu veux vraiment le faire en Python ou dans ce charabia de PythonBashibouzouk ?

Je considère que tu as répondu oui à la première option.

Pure Python

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
 
# -*- coding: utf-8 -*-
 
import sys
import os
from ftplib import FTP
 
SERVER = 'http://www.example.com'
LOGIN = 'monNom'
PSWD = 'secret'
DATAFILE = '/chemin/de/fichier.ext'
FILENAME = os.path.basename(DATAFILE)
 
def upload():
    print 'Connection to %s' % SERVER
    try:
        ftp = FTP(SERVER)
        ftp.login(LOGIN, PSWD)
    except Exception as why:
        print 'login error: {0}'.format(why)
        sys.exit()
 
    # Si tu dois te positionner dans un dossier
    ftp.cwd(DIRPATH)
 
    # Si tu dois préalablement supprimer le fichier du même nom
    try:
        reply = ftp.delete(FILENAME)
        print 'Removed: {0}'.format(reply)
    except Exception as why:
        print 'removed fail: {0}'.format(why)
 
    print 'Read file %s' % DATAFILE
    with open(DATAFILE, "rb") as objf:
        print 'Upload file %s to server' % FILENAME
        try:
            ftp.storbinary('STOR ' + FILENAME, objf)
        except Exception as why:
            print 'upload failed: {0}'.format(why)
        else:
            print 'File uploaded, close ftp.'
            os.remove(DATAFILE)
        ftp.quit()
 
if __name__ == '__main__':
    upload()

Faudra adapter à ton cas bien sur.

**Slaan** · 14/03/2014, 21h14

Ahahaha, oui, effectivement, merci pour ce code beaucoup plus propre

Je suis un peu bourrin désolé ...
J'etudie ça et teste des ce soir !

**Slaan** · 14/03/2014, 22h23

Alors, okay. Si j'ai bien pigé, la ligne

Code :

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

os.remove(DATAFILE)

supprime le fichier en local lorsque l'upload est terminé.

Je ne comprend pas par contre la ligne

Code :

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

1
2
3
 
if __name__ == '__main__':
    upload()

En fait, j'ai du mal a comprendre ce qui remplace le "Watchdir" afin qu'un fichier soit uploadé des qu'il entre dans le dossier surveillé.
Et si je veux mettre plusieurs serveurs ou il faut uploader, ceci fonctionne ?

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
 
# -*- coding: utf-8 -*-
 
import sys
import os
from ftplib import FTP
import pyinotify
 
SERVER1 = 'http://www.example.com'
SERVER2 = 'http://www.example2.com'
LOGIN1 = 'monNom'
LOGIN2 = 'monNom2'
PSWD1 = 'secret'
PSWD2 = 'secret2'
DATAFILE = '/chemin/de/fichier.ext'
FILENAME = os.path.basename(DATAFILE)
 
 
def upload(1):
    print 'Connection to %s' % SERVER1
    try:
        ftp = FTP(SERVER1)
        ftp.login(LOGIN1, PSWD1)
    except Exception as why:
        print 'login error: {0}'.format(why)
        sys.exit()
 
 
    print 'Read file %s' % DATAFILE
    with open(DATAFILE, "rb") as objf:
        print 'Upload file %s to server' % FILENAME
        try:
            ftp.storbinary('STOR ' + FILENAME, objf)
        except Exception as why:
            print 'upload failed: {0}'.format(why)
        else:
            print 'File uploaded, close ftp.'
            os.remove(DATAFILE)
        ftp.quit()
 
if __name__ == '__main__':
    upload(1)
 
 
def upload(2):
    print 'Connection to %s' % SERVER2
    try:
        ftp = FTP(SERVER2)
        ftp.login(LOGIN2, PSWD2)
    except Exception as why:
        print 'login error: {0}'.format(why)
        sys.exit()
 
    print 'Read file %s' % DATAFILE
    with open(DATAFILE, "rb") as objf:
        print 'Upload file %s to server' % FILENAME
        try:
            ftp.storbinary('STOR ' + FILENAME, objf)
        except Exception as why:
            print 'upload failed: {0}'.format(why)
        else:
            print 'File uploaded, close ftp.'
            os.remove(DATAFILE)
        ftp.quit()
 
if __name__ == '__main__':
    upload(2)

je suis tout nouveau en python, mais ce langage m’excite, j'ai bien envie de le bosser beaucoup plus

Merci pour ton aide.

**VinsS** · 15/03/2014, 00h11

Non, il ne faut pas écrire deux fois le même code, si tu as plusieurs serveurs avec des logins différent, tu rèpètes l'opération dans une boucle en mettant les noms dans une liste.

DATAFILE est bien le chemin/nom complet du fichier sur ta machine
et FILENAME est le nom sans chemin qui devra être utilisé sur le serveur

Tu fais tes listes comme ceci:

Code :

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

1
2
3
4
5
 
# ! l'ordre DOIT etre le meme pour les trois listes
SERVERS = ['http://www.example.com', 'http://www.example1.com', 'http://www.example2.com']
LOGINS = ['monNom', 'monNom1', 'monNom1']
PSWDS = ['secret', 'secret1', 'secret1']

Et puis à la fin du script:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
if __name__ == '__main__':
    import sys
    # sys.argv[1] est le chemin/nom du fichier a uploader
    path = sys.argv[1]
    # le nom seul
    file = os.path.basename(file)
    # on boucle sur les noms de serveur
    for index, nom in SERVERS:
        upload(file, nom, LOGINS[index], PSWDS[index])
    os.remove(path)

Ensuite, tu changes la définition de la fonction pour qu'elle reçoive les arguments

Code :

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

1
2
 
def upload(FILENAME, SERVER, LOGIN, PSWD):

Normalement, on réserve les noms tout en majuscules pour les constantes, donc si tu veux peaufiner, tu les remplaces par des minuscules dans le corps de la fonction.

Et tu enlèves de la fonction "os.remove(DATAFILE)" puisqu'on l'a mit à la fin du code.

Pour automatiser la tâche, tu peux te faire un bash avec ta fonction "Watchdir" et, si il trouve un fichier, il lance "python /home/jo/upload.py /chemin/nom/du/fichier"

Tu rends ce bash exécutable, tu le mets dans /usr/bin et tu te crées un crontab avec la commande

Code :

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

1
2
 
crontab -e

**Slaan** · 16/03/2014, 12h10

Yop !

Okay, alors, si j'ai bien pigé, "if __name__ == '__main__':" sert a ce que le code soit bien exécuté lorsqu'il est appellé par un autre script (http://sametmax.com/pourquoi-if-__na...n__-en-python/)

Bref, j'ai donc fait comme ceci :

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
 
import sys
import os
from ftplib import FTP
 
SERVERS = ['server1', 'server2']
LOGINS = ['log1', 'log2']
PSWDS = ['secret1', 'secret2']
DATAFILE = sys.argv[1] #le chemin/nom du fichier lorsqu'il est appellé par un autre process 
FILENAME = os.path.basename(DATAFILE) #le nom seul
 
def upload():
    print 'Connection to %s' % nom
    try:
        ftp = FTP(nom)
        ftp.login(LOGINS[index], PSWDS[index])
    except Exception as why:
        print 'login error: {0}'.format(why)
        sys.exit()
 
 
    print 'Read file %s' % DATAFILE
    with open(DATAFILE, "rb") as objf:
        print 'Upload file %s to server' % FILENAME
        try:
            ftp.storbinary('STOR ' + FILENAME, objf)
        except Exception as why:
            print 'upload failed: {0}'.format(why)
        else:
            print 'File uploaded, close ftp.'
        ftp.quit()
 
if __name__ == '__main__':
    # on boucle sur les noms de serveur
    for index, nom in SERVERS:
        upload(FILENAME, nom, LOGINS[index], PSWDS[index])
    os.remove(DATAFILE)

Mais j'ai une erreur. J'ai pas du tout piger sur la boucle :

Code :

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

1
2
3
4
5
6
 
root@ns363473:/home/jo# python scriptFTPpy.py testftp/UnivFlute.mp4
Traceback (most recent call last):
  File "scriptFTPpy.py", line 37, in <module>
    for index, nom in SERVERS:
ValueError: too many values to unpack

Ensuite, effectivement, je prendrais un autre script qui lancera celui ci avec le nom du fichier.

Merci pour ton aide

**VinsS** · 16/03/2014, 13h47

C'est de ma faute, remplace la ligne

Code :

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

1
2
 
    for index, nom in SERVERS:

par

Code :

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

1
2
 
    for index, nom in enumerate(SERVERS):

cela retourne l'index et le nom de chaque serveur, dans l'ordre de la liste bien sur.

Je pensais à autre chose, ton dossier de vidéo est normalement vide ? et c'est chaque nouveau contenu qui doit être uploadé et effacé par le démon ?

**Slaan** · 16/03/2014, 19h52

Yeah, je vais tester ça, merci

Oui, il est a la base vide. Mais il se peux que le remplissage du dit dossier soit plus rapide que l'upload et la suppression du fichier.
Autrement dit le daemon risque de tourner et de lancer le script régulièrement.
Pourquoi, tu penses a un truc ?

**Slaan** · 16/03/2014, 20h21

Super ! ça fonctionne nickel apriori avec :

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
 
import sys
import os
from ftplib import FTP
 
SERVERS = ['ftp0.server1.com', 'upload.server2.com']
LOGINS = ['log1', 'log2']
PSWDS = ['secret1', 'secret2']
DATAFILE = sys.argv[1] #le chemin/nom du fichier lorsqu'il est appellé par un autre process 
FILENAME = os.path.basename(DATAFILE) #le nom seul
 
def upload():
    print 'Connection to %s' % SERVERS[index]
    try:
        ftp = FTP(SERVERS[index])
        ftp.login(LOGINS[index], PSWDS[index])
    except Exception as why:
        print 'login error: {0}'.format(why)
        sys.exit()
 
 
    print 'Read file %s' % DATAFILE
    with open(DATAFILE, "rb") as objf:
        print 'Upload file %s to server' % FILENAME
        try:
            ftp.storbinary('STOR ' + FILENAME, objf)
        except Exception as why:
            print 'upload failed: {0}'.format(why)
        else:
            print 'File uploaded, close ftp.'
        ftp.quit()
 
if __name__ == '__main__':
    # on boucle sur les noms de serveur
    for index, nom in enumerate(SERVERS):
        upload()
    os.remove(DATAFILE)

avec pour résultat un très joli et très explicite :

Code :

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

1
2
3
4
5
6
7
8
9
 
Connection to ftp.serveur1.com
Read file fichier_to_move_on_ftp/fichier.mp4
Upload file fichier.mp4 to server
File uploaded, close ftp.
Connection to upload.serveur2.com
Read file fichier_to_move_on_ftp/fichier.mp4
Upload file fichier.mp4 to server
File uploaded, close ftp.

Et le fichier n'existe plus en local.
Royal, merci beaucoup

Allez hop, maintenant je m'attaque au daemon.

**Slaan** · 24/03/2014, 14h08

Hello !

Je reviens un peu sur ce sujet.
Le Script fonctionne nickel sauf qu'il efface tout de même le fichier si l'upload a foiré.
J'ai donc ajouté une fonction BRAVO=true/false, mais ça ne semble pas fonctionner, le fichier est tout de même effacé si l'upload fonctionne.
A votre avis, ça coince ou ?

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
 
 
import sys
import os
from ftplib import FTP
 
SERVERS = ['01', '02']
LOGINS = ['01', '02']
PSWDS = ['01', '02']
DATAFILE = sys.argv[1] #le chemin/nom du fichier lorsqu'il est appellé par un autre process 
FILENAME = os.path.basename(DATAFILE) #le nom seul
 
 
 
def upload():
    print 'Connection to %s' % SERVERS[index]
    try:
        ftp = FTP(SERVERS[index])
        ftp.login(LOGINS[index], PSWDS[index])
    except Exception as why:
        print 'login error: {0}'.format(why)
        sys.exit()
 
 
    print 'Read file %s' % DATAFILE
    with open(DATAFILE, "rb") as objf:
        print 'Upload file %s to server' % FILENAME
        try:
            ftp.storbinary('STOR ' + FILENAME, objf)
        except Exception as why:
            BRAVO=False
            print 'upload failed: {0}'.format(why)
        else:
            print 'File uploaded, close ftp.'
        ftp.quit()
 
if __name__ == '__main__':
    BRAVO=True
    # on boucle sur les noms de serveur
    for index, nom in enumerate(SERVERS):
        upload()
    if BRAVO:
        os.remove(DATAFILE)

Merci !

**VinsS** · 24/03/2014, 14h30

Salut,

Ça ne marche pas parce que le BRAVO de la fonction n'est pas le même. En fait tu crées un nouveau nom dans la fonction.

Le plus simple, utilise le retour de la fonction.

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
 
       try:
            ftp.storbinary('STOR ' + FILENAME, objf)
        except Exception as why:
            print 'upload failed: {0}'.format(why)
            ftp.quit()
            return False
        else:
            print 'File uploaded, close ftp.'
        ftp.quit()
        return True
 
if __name__ == '__main__':
    # on boucle sur les noms de serveur
    for index, nom in enumerate(SERVERS):
        reply =upload()
    if reply:
        os.remove(DATAFILE)

**Slaan** · 24/03/2014, 15h55

Yes, Merci VinsS !

Je viens de tester.
Le truc, c'est que j'ai plusieurs serveurs ftp qui sont appelés (ça boucle) et donc autant d'envois.
Ta solution semble marcher si tout les serveurs renvoient une erreur.
Lorsqu'un seul renvoie une erreur alors que les deux autres sont okay, ça renvoie à "True" et ça efface le fichier du coup.

Je vois pas trop comment faire :s peut etre en incrémentant une valeur, et lancer le os.remove seulement si la valeur = nombre de serveur ?
ça me parait un peu lourd

Merci pour ton aide !

**VinsS** · 24/03/2014, 16h20

Ce doit être parce que j'ai oublié d'indenter les dernières lignes .

C'est comme ceci:

Code :

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

1
2
3
4
5
6
7
 
if __name__ == '__main__':
    # on boucle sur les noms de serveur
    for index, nom in enumerate(SERVERS):
        reply =upload()
        if reply:
            os.remove(DATAFILE)

**Slaan** · 24/03/2014, 16h33

ça efface toujours :/
J'ai deux serveurs, le premier renvoie une erreurs a cause d'un problème de caractère.
Le second est plus permissif et le fichier passe bien.
Et le script efface le fichier.

**wiztricks** · 24/03/2014, 17h13

Salut,

upload effectue trop d’opérations et le contrôle passe par des variables globales: pas facile d'y retrouver son latin!
Vous pouvez arriver a ce que ça tombe en marche mais pourquoi ne pas utiliser les fonctions pour ce qu'elles sont?
En forçant un peu le trait, ça pourrait donner:

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
import sys
import os
from ftplib import FTP
 
 
def create_ftp(server, login, pwd):
    try:
        ftp = FTP(server)
        ftp.login(login, pwd)
    except Exception as why:
        print 'login error: {0}'.format(why)
    else:
        return ftp
 
def ftp_upload(ftp, filename):
    print 'Read file %s' % filename
    with open(filename, "rb") as f:
        print 'Upload file %s to server' % filename
        try:
            ftp.storbinary('STOR ' + filename, f)
        except Exception as why:
            print 'upload failed: {0}'.format(why)
        else:
            print 'File uploaded, close ftp.'
            return True
 
def do_copy(server, login, pwd, filename):
    ftp = create_ftp(server, login, pwd)
    if ftp:
        done = ftp_upload(ftp, filename)
        ftp.quit()
        return done
 
if __name__ == '__main__':
    SERVERS = ['01', '02']
    LOGINS = ['01', '02']
    PSWDS = ['01', '02']
    filename = sys.argv[1] #le chemin/nom du fichier lorsqu'il est appellé par un autre process 
 
    done = True
    # on boucle sur les noms de serveur
    for ix, server in enumerate(SERVERS):
        if not do_copy(server, LOGINS[ix], PSWDS[ix], filename)
            done = False 
    if done:
        os.remove(filename)

a vous de voir
- W
note: je n'ai rien teste, juste re-organise le code

Daemon upload automatique sur serveur ftp

Déploiement/Installation Python

Discussions similaires

Partager

Partager