Discussion :

[____22]

Bonjour
j'ai une application que je lance en premier, et qui tourne en arriere plan
<engine.Engine instance at 0x00BB03F0>

ensuite je lance une autre application, est-il possible de passer en argument ou de retrouver et lier l'instance ci-dessus?
je peux faire import engine.Engine mais j'ai besoin de l'instance qui est en train d'etre executee

[wiztricks]

Salut,

Si ce sont des applications A et B qui s'exécutent dans des process différents, un objet tel qu'Engine de A ne sera pas accessible "simplement" depuis B.
La façon la plus simple pour que B parle à l'engine.Engine de A pourrait être de passer par XML/RPC...
Une autre solution pourrait être de mettre A et B dans deux threads séparées.

Mais ce "plus simple" étant relativement compliqué, il serait peut être plus sage que vous racontiez un peu comment vous en êtes arrivé là avant de.
- W

[PauseKawa]

Bonjour,

Je ne sais pas si c'est moi mais je trouve une certaine 'lenteur' à xmlrpclib.
Quelles sont les autres façons wiztricks?

Sinon pour ____22:

Faire communiquer via xmlrpclib ou socket oui:

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
#!/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 :

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
#!/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 suppression d'un client
print "Test suppression d'un client"
delcli('cli1')
delcli('cli2')
delcli('cli4')
 
# Test liste des clients
print "Test liste des clients"
liste()

A la limite passer du code en argument mais une instance...
J'espere qui tu auras ta réponse.

Bon code

Edit: Sur le même sujet

[____22]

merci de ces reponses

precisement la 1ere instances est un serveur pysnmp

la 2eme est une interface pour communiquer par série en console avec un composant

bon mettre le serveur snmp sur Thread je voulais pas trop d'une part parceque je voulais avoir ces 2 modules independants, demarrer le serveur puis l'interface 5 minutes après
et d'autre si je mets le serveur sur Thread et demarre en meme teps que l'interface, peut etre que le serveur crashera plus souvent s'il est sur thread

en fait j'ai besoin d'envoyer des infos du serveur vers l'interface, dans l'autre sens c'est facile, j'envoie des requete snmp
donc je vais voir si le serveur peut envoyer à l'aveugle (en UDP comme snmp) vers un client qui sera l'interface?, si celle-ci est démarrée elle recevra les infos sinon elle sont perdues

[wiztricks]

en fait j'ai besoin d'envoyer des infos du serveur vers l'interface, dans l'autre sens c'est facile, j'envoie des requete snmp

Si la console se contente d'afficher des infos expédiée par... le plus simple serait que le process SNMP les émette tout le temps et que la console ne les affiche que si nécessaire.
Ce qui pourrait se ramener à afficher le contenu d'un fichier style log contenant tout ou partie des informations émises par le serveur.
- W

[____22]

j'ai un probleme
c'est que le serveur pysnmp change toujours (incrémente) le port des sockets udp
j'ai essayé même en ajoutant
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

server start: ('127.0.0.1', 161)
requete client:
read [(ObjectName('1.3.6.1.4.1.12559.100.1.1.3'), Null(''))]
send ('127.0.0.1', 1075)

la prochaine requete sera sur 1076 etc

comme par ex:

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
import socket
 
UDP_IP="127.0.0.1"
UDP_PORT=5005
 
sock = socket.socket( socket.AF_INET, # Internet
                      socket.SOCK_DGRAM ) # UDP
sock.bind( (UDP_IP,UDP_PORT) )
 
while True:
    data, addr = sock.recvfrom( 1024 ) # buffer size is 1024 bytes
    print "received message:", data, addr
    sock.sendto( data+" ok", addr )
 
import socket
 
UDP_IP="127.0.0.1"
UDP_PORT=5005
MESSAGE="Hello, World!"
 
print "UDP target IP:", UDP_IP
print "UDP target port:", UDP_PORT
print "message:", MESSAGE
 
sock = socket.socket( socket.AF_INET, # Internet
                      socket.SOCK_DGRAM ) # UDP
sock.sendto( MESSAGE, (UDP_IP, UDP_PORT) )
data, addr = sock.recvfrom( 1024 ) # buffer size is 1024 bytes
print ":", data, addr
 
sock.sendto( MESSAGE+"2", (UDP_IP, UDP_PORT) )
data, addr = sock.recvfrom( 1024 ) # buffer size is 1024 bytes
print ":", data, addr

à chaque execution du client, le serveur aura un port incrémenté pour lui parler

donc je peux pas savoir sur laquelle envoyée à tout moment, j'aimerais bien avoir une adresse d'envoi fixe, ou broadcast

en fait, si au lancement de mon interface, j'envoie un simple message au serveur, le serveur reconnait et sauve le port pour communiquer avec l'interface, mais combien de temps le port reste valable?

[____22]

pour l'interface je pense que je peux lui mettre un thread avec

Code :

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

1
2
3
4
5
6
7
import socket
HOST = 'localhost'
s = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_IP)
s.bind((HOST, 0))
# receive all 
s.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
print(s.recvfrom(65565))

mais j'ai cette erreur en lançant:
s.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
File "<string>", line 1, in ioctl
socket.error: [Errno 10022] Un argument non valide a été fourni

l'option SIO_RCVALL n'est plus reconnue?