Discussion :

[Grumul]

Bonjour,

Je suis actuellement en train de développer un script python qui me permet d'éxécuter via SSH des commandes sur des machines à distance.
La classe que j'utilise pour la connexion SSH est très proche de celle qu'il y a sur ce site : https://daanlenaerts.com/blog/2016/0...aramiko-shell/

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
import threading, paramiko
 
class ssh:
    shell = None
    client = None
    transport = None
 
    def __init__(self, address, username, password):
        print("Connecting to server on ip", str(address) + ".")
        self.client = paramiko.client.SSHClient()
        self.client.set_missing_host_key_policy(paramiko.client.AutoAddPolicy())
        self.client.connect(address, username=username, password=password, look_for_keys=False)
        self.transport = paramiko.Transport((address, 22))
        self.transport.connect(username=username, password=password)
 
        thread = threading.Thread(target=self.process)
        thread.daemon = True
        thread.start()
 
    def closeConnection(self):
        if(self.client != None):
            self.client.close()
            self.transport.close()
 
    def openShell(self):
        self.shell = self.client.invoke_shell()
 
    def sendShell(self, command):
        if(self.shell):
            self.shell.send(command + "\n")
        else:
            print("Shell not opened.")
 
    def process(self):
        global connection
        while True:
            # Print data when available
            if self.shell != None and self.shell.recv_ready():
                alldata = self.shell.recv(1024)
                while self.shell.recv_ready():
                    alldata += self.shell.recv(1024)
                strdata = str(alldata, "utf8")
                strdata.replace('\r', '')
                print(strdata, end = "")
                if(strdata.endswith("$ ")):
                    print("\n$ ", end = "")
 
 
sshUsername = "SSH USERNAME"
sshPassword = "SSH PASSWORD"
sshServer = "SSH SERVER ADDRESS"
 
 
connection = ssh(sshServer, sshUsername, sshPassword)
connection.openShell()
while True:
    command = input('$ ')
    if command.startswith(" "):
        command = command[1:]
    connection.sendShell(command)

J'aimerais que l'éxécution de mes commande soit séquentielle c'est à dire qu'avant d'éxécuter la commande suivante, on attende que celle en cours soit terminée.

Pour cela j'avais pensé à utiliser un mutex. Je prend le mutex à l'émission de la commande (dans ma "boucle" principale) , et j'attends la réception d'un pattern particulié qui signifie la fin de ma commande (genre "root >") et de libérer le mutex à ce moment la, afin que la boucle principale puisse passer à la commande suivante.
Cependant ca ne fonctionne pas. Soit mon programme se bloque au bout de la deuxième commande, soit il exécute toutes mes commandes d'un coup (sans forcémment laisser à une commande le temps de se finir).

Je ne suis également pas très fan de la solution du shell interactif que j'utilse, mais c'est la seule que j'ai trouvé qui me garde l'environnement comme je veux (comme si j'étais moi même sur le shell en fait)

Bref si quelqu'un a une idée je suis preneur

[wiztricks]

Salut,

Pour exécuter vos commandes de façon séquentielle, pourquoi lire et afficher tout ce qui arrive de façon asynchrone?

Après pour passer à la commande suivante, il faut pouvoir attendre que la commande précédente soit terminée.
Ce qui n'est pas facile à déterminer (on attend le prompt?). Mais on peut lancer à la suite de la commande, une commande "echo" qui retournera une ligne commençant par un pattern connu à l'avance.

- W

[tyrtamos]

Bonjour,

Pour autant que les threads soient une bonne solution, il est possible de faire intervenir plusieurs threads dans un ordre déterminé.

Voilà un petit exemple avec 5 threads numérotés de 0 à 4, et qui ont chacun un traitement de durée aléatoire de 0.0 à 1.0s:

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
#!/usr/bin/python3
# -*- coding: utf-8 -*-
 
import threading
import time
from random import random 
 
##############################################################################
etat = -1 # contient le numéro du thread en cours de traitement
verrou = threading.Lock() # verrou pour la variable etat
nummax = 5 # nombre de threads
 
##############################################################################
def traitement(num):
    global etat, verrou, nummax
    while True:
        with verrou:
            if etat==num-1 or (etat==nummax-1 and num==0): # condition de traitement
                etat = num if etat==num-1 else 0 # mise à jour de etat
                print("Traitement par le thread", num) # affiche le numéro du thread
                time.sleep(random()) # simule une durée aléatoire de traitement
 
##############################################################################
 
# création des threads
mesthreads = []
for i in range(0, nummax):
    mesthreads.append(threading.Thread(target=traitement, args=(i,), kwargs={}, daemon=True))
 
# lancement des threads
for i in range(0, nummax):
    mesthreads[i].start()    
 
x = input()

Ce qui affiche:

Traitement par le thread 0
Traitement par le thread 1
Traitement par le thread 2
Traitement par le thread 3
Traitement par le thread 4
Traitement par le thread 0
Traitement par le thread 1
Traitement par le thread 2
Traitement par le thread 3
Traitement par le thread 4
Traitement par le thread 0
Traitement par le thread 1
Traitement par le thread 2
Traitement par le thread 3
Traitement par le thread 4
...
...

Il s'agit ici d'un code de principe, mais on pourrait imaginer des conditions de traitement de chacun des threads plus complexes, portant par exemple sur les données à traiter, ou sur des méthodes de traitement. Par exemple, simuler le fonctionnement d'un atelier d'outillage.