Faire communiquer 2 scripts

Version imprimable

08/05/2010, 14h43
Gui310

Faire communiquer 2 scripts

Bonjour, voici ma question:

Est-il possible que, 2 scripts exécutés manuellement et distinctement peuvent communiquer entre eux?

Exemple:
J'allume un script (script1.py)
Le script1 s'interrompt et attends qu'on lui demande de continuer
J'allume un autre scrpit (script2.py)
Le script2 modifie une variable OU exécute une fonction du script1
Ce qui permet au script1 de continuer de s'executer

En gros, le script2 agit comme une clé sur le script1

Y-as-t-il un moyen de faire cela ?
08/05/2010, 15h19
miawaw

Hello,

il y avait cette discussion il y a quelques jours, peut-être est-ce utile :

Interrompre une fonction ou une boucle de manière intéractive

parce que ça parait nécessiter l'utilisation de threads, que je ne connais pas du tout...

bye
08/05/2010, 15h37
wiztricks

Salut,

Citation:

Envoyé par Gui310

Bonjour, voici ma question: Est-il possible que, 2 scripts exécutés manuellement et distinctement peuvent communiquer entre eux?

Notez que 2 scripts lancés simultanément signifient 2 process.

Citation:

Y-as-t-il un moyen de faire cela ?

Toutes les primitives IPC - Inter Process Communication - de l'OS devraient être utilisables.
Exemple: script1 peut attendre la réception d'un signal envoyé par l'exécution de script2.

- W
08/05/2010, 15h39
PauseKawa

Bonjour,

script1.py se lance et attend la création d'un fichier tonfichier.txt
script2.py se lance et crée tonfichier.txt avec pour contenu la valeur de la variablescript1 de script1.py à modifier.
script1.py trouve tonfichier.txt est change la valeur de variablescript1 puis continu.

En quoi est ce utile ?

@+
08/05/2010, 15h43
PauseKawa

Bonjour wiztricks,

Citation:

Envoyé par wiztricks

Toutes les primitives IPC - Inter Process Communication - de l'OS devraient être utilisables.
Exemple: script1 peut attendre la réception d'un signal envoyé par l'exécution de script2.

Cela ne concerne que le signal, pas les données malheureusement.
S'il existe autre chose je suis preneur.

@+
08/05/2010, 15h52
wiztricks

Citation:

Envoyé par miawaw

Interrompre une fonction ou une boucle de manière intéractive

En effet, c'est un peu la même chose.
le processus qu'on veut arrêter/redémarrer doit être en mesure d'écouter ce qu'on lui dit pendant qu'il 'tourne'. Maintenant s'il ne s'agit que d'un ctrl-C, ou d'un autre évènement que l'OS est capable d'envoyer au process, on peut souvent se passer de threads.

Citation:

parce que ça parait nécessiter l'utilisation de threads, que je ne connais pas du tout...

Des threads partageant le même espace virtuel, les possibilités d'échanges d'informations sont importantes. On retrouve quelques un de ces avantages dans les groupes de processus (voir la librairie process).

Dans le cas présenté ici, un script = 1 process, un autre script = 1 autre process: ils ne partagent rien mais ils peuvent se parler en échangeant des messages en fonction d'un protocole plus ou moins sophistiqué.

Plutôt que passer par un signal,... script1 pourrait attendre la création d'un fichier particulier... ou la réception d'un message sur un pipe ou se transformer en serveur web et offrir des services de type XML-RPC.

- W
08/05/2010, 15h58
PauseKawa

Bonjour wiztricks,

Par PIPE tu parle de regarder le stdout ? Il me semble que l'observation continuelle de celui ci par script1 risque d'être lourde non ?
Je me trompe pour le stdout ?

Merci
08/05/2010, 16h01
wiztricks

Bonjour PauseKawa,

Citation:

Envoyé par PauseKawa

Bonjour wiztricks,
Cela ne concerne que le signal, pas les données malheureusement.
S'il existe autre chose je suis preneur.
@+

mmap permet de partager des espaces mémoire et donc des données éventuellement sauvegardée sur disque.
Reste à choisir un protocole pour verrouiller les accès aux différents objets.

Ces deux fonctionnalités sont généralement basées sur des primitives spécifiques à l'OS. Dans Python, une bibliothèque qui les permette de les utiliser de façon abstraite est "multiprocessing".

- W
08/05/2010, 16h11
wiztricks

Citation:

Envoyé par PauseKawa

Bonjour wiztricks,

Par PIPE tu parle de regarder le stdout ? Il me semble que l'observation continuelle de celui ci par script1 risque d'être lourde non ?
Je me trompe pour le stdout ?

Merci

Je pensais aux bon vieux "named pipe" unix qui s'appellent boite aux lettres (mailbox) ailleurs. Comme pour la plupart des objets d'E/S, les lectures peuvent être bloquantes, on peut aussi "pooler", faire des "select" ou avoir le déclenchement d'un callback lorsque des données sont "là".
- W
08/05/2010, 16h12
PauseKawa

Bonjour,

Ok pour le multiprocessing, c'est du thread avec pipe et queue.
Mais cela implique un seul script non ?

@+
08/05/2010, 16h24
wiztricks

Citation:

Envoyé par PauseKawa

Bonjour,

Ok pour le multiprocessing, c'est du thread avec pipe et queue.
Mais cela implique un seul script non ?

@+

multiprocessing est une bibliothèque qui permet de communiquer entre "processus" comme s'il s'agissait de threads.
C'est une façon de résoudre les soucis posés par GIL.
Et donc on a un machin (le script) qui profite de l'ensemble des CPUs.
Du point de vue de l'OS, ce sont des processus indépendants.

Plusieurs scripts ressemblerait à une bibliothèque partagée: on crée plusieurs programmes indépendants qui communiquent à travers.

Tous les OS permettent de faire çà (c'est leur fonction) mais je n'ai pas regardé s'il existait une bibliothèque permettant d'intégrer la chose à des programmes/scripts Python.

- W
08/05/2010, 16h52
wiztricks

Re

PauseKawa jettes un oeil à POSH (ou à parallel processing)
Une des difficultés qu'a Python a sortir d'un modèle "un seul script" est sa richesse...

L'OS ne permettant que le partage de "pages" mémoire, intégrer cela dans le contexte d'exécution de plusieurs machine virtuelles "disparates" est assez "sportif" - la question n'est pas tant d'avoir un tas de bytes mais de vrais "objets" python.
La bibliothèque posix_ipc permet par exemple cela (le tas de bytes).

- W
08/05/2010, 17h04
Gui310

Je pense me rabattre sur l'idée de monter un réseau XML-RPC, je suis en train d'étudier le fonctionnement
09/05/2010, 19h47
Gui310

Citation:

Envoyé par wiztricks

Je pensais aux bon vieux "named pipe" unix qui s'appellent boite aux lettres (mailbox) ailleurs. Comme pour la plupart des objets d'E/S, les lectures peuvent être bloquantes, on peut aussi "pooler", faire des "select" ou avoir le déclenchement d'un callback lorsque des données sont "là".

Puis-je avoir quelques exemples sur tes procédés?

(:oops:Débutant:oops:)

Bonsoir,

Citation:

Envoyé par Gui310

Puis-je avoir quelques exemples sur tes procédés?

(:oops:Débutant:oops:)

Désolé pour le squat mais : Idem :roll:

Sinon après pas mal de tests, sur les recommandations de wiztricks, j'ai fais un tour et je pense que la solution xmlrpclib n'est pas mal.

Je suis encore dans mes tests mais :

Code:

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
 
#!/usr/bin/env python
# -*- coding: ISO8859-1 -*-
#
#
import xmlrpclib
 
class MyMarshall(xmlrpclib.Marshaller):
    def __init__(self, encoding=None, allow_none=0):
        self.memo = {}
        self.data = None
        self.encoding = encoding
        self.allow_none = 1
 
xmlrpclib.Marshaller = MyMarshall
 
from SimpleXMLRPCServer import SimpleXMLRPCServer
 
class appsvr(object):
    def __init__(self):
        object.__init__(self)
        self.clidial = {}
        appserver = SimpleXMLRPCServer(("localhost", 8000))
        print "Serveur en écoute sur le port 8000..."
        appserver.register_function(self.reg_me, "reg_me")
        appserver.register_function(self.dial_us, "dial_us")
        appserver.register_function(self.give_me, "give_me")
        appserver.register_function(self.unreg_me, "unreg_me")
        appserver.register_function(self.clear_me, "clear_me")
        appserver.register_function(self.list_me, "list_me")
        try:
            print 'Utilisez Control-C pour finir'
            appserver.serve_forever()
        except KeyboardInterrupt:
            print 'Fin'
 
 
    def reg_me(self, cliname):
        # Enregistrement d'un client et création de sa file d'attente
        if cliname in self.clidial:
            print "client", cliname, "déjà enregistré"
            return False
        else:
            self.clidial[cliname]=[]
            print 'Enregistrement du client', cliname
            print self.clidial
            return True
 
    def dial_us(self, cliname, msg):
        # Ajout d'un message pour un client
        if cliname in self.clidial:
            self.clidial[cliname].append(msg)
            print "Réception d'un message pour", msg[0], "avec la variable", msg[1], "qui a pour valeur", msg[2]
            return True
        else:
            print 'Client inconnu'
            return False
 
    def give_me(self, cliname):
        # Retourne les messages a un client
        if cliname in self.clidial:
            print "Retourne", self.clidial[cliname]
            return self.clidial[cliname]
        else: return None
 
    def clear_me(self, cliname):
        # Supprime les messages d'un client
        if cliname in self.clidial:
            print "Messages pour le client", cliname, "supprimés"
            self.clidial[cliname]=[]
            return True
        else:
            print 'Client inconnu'
            return False
 
    def unreg_me(self, cliname):
        # Supprime un client
        if cliname in self.clidial:
            print "Supprime", self.clidial[cliname]
            del self.clidial[cliname]
            return True
        else:
            print 'Client inconnu'
            return False
 
    def list_me(self):
        return self.clidial.keys()
 
if __name__ == "__main__":
    appsvr()

Code:

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
#!/usr/bin/env python
# -*- coding: ISO8859-1 -*-
#
# Tests de base
import xmlrpclib
 
def envoie(cliname, dest, varname, valvar):
    msg=(dest, varname, valvar)
    proxy.dial_us(cliname, msg)
 
def recup(client):
    try:
        retour = proxy.give_me(client)
        print retour
    except xmlrpclib.Fault:
        print 'Client inconnu'
 
def createcli(client):
    if proxy.reg_me(client) == True: print 'Ok'
    else: print 'Nok'
 
def videmess(client):
    if proxy.clear_me(client) == True: print 'Ok'
    else: print 'Nok'
 
def delcli(client):
    if proxy.unreg_me(client) == True: print 'Ok'
    else: print 'Nok'
 
def liste():
    print proxy.list_me()
 
proxy = xmlrpclib.ServerProxy("http://localhost:8000/")
 
# Tests création destinataire
print "Tests création destinataire"
createcli('cli1') # destinataire
createcli('cli1') # test sur destinataire existant
createcli('cli2') # nouveau destinataire
 
# Test liste des clients
print "Test liste des clients"
liste()
 
# Test envoi message
print "Test envoi message"
envoie('cli2', 'cli1', 'test0', 10)
envoie('cli1', 'cli2', 'test1', 10)
envoie('cli2', 'cli1', 'test0', 20)
 
# Test réception message
print "Test réception message"
recup('cli1')
recup('cli2')
recup('cli3')
 
# Test vidage messages
print "Test vidage messages"
videmess('cli1')
videmess('cli2')
videmess('cli4')
 
# Test supression d'un client
print "Test supression d'un client"
delcli('cli1')
delcli('cli2')
delcli('cli4')
 
# Test liste des clients
print "Test liste des clients"
liste()

Code:

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
 
#!/usr/bin/env python
# -*- coding: ISO8859-1 -*-
#
# Tests threads
import xmlrpclib
import threading
 
 
class recupvar(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        self._stopevent = threading.Event()
        self.proxy = xmlrpclib.ServerProxy("http://localhost:8000/")
        self.createcli('cli3')
 
    def run(self):
        i=0
        while not self._stopevent.isSet():
            self.envoie('cli3', 'cli2', 'test', i)
            self.recup('cli3')
            self.videmess('cli3')
            i += 1
            if i == 50: self.stop()
            self._stopevent.wait(1.0)
        print "Fin du thread"
        self.delcli('cli2')
 
    def stop(self):
        self.delcli('cli2')
        self._stopevent.set()
 
    def recup(self, client):
        try:
            retour = self.proxy.give_me(client)
            print retour
        except xmlrpclib.Fault:
            print 'Client inconnu'
            self.stop()
 
    def createcli(self, client):
        print "Création client :"
        if self.proxy.reg_me(client) == True: print 'Ok'
        else: print 'Nok'
 
    def envoie(self, cliname, dest, varname, valvar):
        msg=(dest, varname, valvar)
        self.proxy.dial_us(cliname, msg)
 
    def videmess(self, client):
        print "Vidage messages:"
        if self.proxy.clear_me(client) == True: print 'Ok'
        else: print 'Nok'
 
    def liste(self):
        print "Liste clients :"
        print self.proxy.list_me()
 
    def delcli(self, client):
        print "Supprimer client :"
        if self.proxy.unreg_me(client) == True: print 'Ok'
        else: print 'Nok'
 
test=recupvar()
test.start()

Dans l'attente de la lecture de wiztricks.

@+

10/05/2010, 10h15
dahtah
Bonjour à tous,
Pour l'utilisation des pipes, on peut faire quelque chose du genre:
shell1:
Code:

1 2 3 mkfifo /tmp/fifo cat /tmp/fifo
shell2:
Code:

1 2 echo "test" >> /tmp/fifo
L'exemple est en bash, mais on peut faire la même chose en python très simplement:

Code:

os.mkfifo(pipe_name)

puis des read/write depuis la fifo crée.
PS: cette solution n'est pas portable, contrairement à la solution RPC
10/05/2010, 18h13
wiztricks

Bravo dahtah

Oui çà fonctionne mais... ce n'est généralement pas portable et je n'ai pas le temps en semaine de faire le tour des API qui restant d'assez bas niveau restent 'intégrées' dans Python.

Si on veut un peu plus achevé que XML-RPC mais peut être un peu trop clos au monde Python vous avez Pyro qui s'appuie sur ce que les Java-istes appellent RMI.

Ce que j'ai compris de la demande de PauseKawa est du style, deux scripts Python lancés indépendamment l'un de l'autre partageant des objets dans un même espace virtuel.

3 problèmes:

1 - Partager l'espace virtuel... Python offre un mmap assez indépendant de l'OS mais ce ne sont pas des objets Python mais un grand tableau de caractères,
2 - Comment poser des "objets" Python dans ce grand tableau? Ce n'est plus une question d'OS mais très machine virtuelle Python,
3 - Reste la synchronisation d'accès à ces objets - qui repose là encore sur des primitives d'OS,

POSH semble faire un peu cela.
Mais, je n'aurais pas de temps avant le week end prochain pour voir ce que ca vaut, snif

- W
10/05/2010, 18h14
ju_bicycle

il me semble qu'on peut aussi faire des truc avec des socket et se parler a soit même...
En tout cas je l'ai fais quand je bossais sur le tuto de swinnen et qu'on fait un serveur et un client sur le même PC avec deux scripts différents:
http://python.developpez.com/cours/T...apitre18#L18.1