Discussion :

[sluke]

Bonjour,

J'aimerai réaliser un programme faisant appel au réseau. Jusque là rien de compliqué.
Le problème est que dans ce programme, il y a 2 serveurs qui doivent communiquer entre eux.

Un petit schéma, ça sera tout suite plus clair (les étapes sont numérotées) :



- en jaune le serveur physique
- en vert les clients physiques

Dans l'exemple, on voit que la brique "Socket TCP (client)" sert de console d'administration et pilote tout le programme. C'est elle qui envoie les ordres.
Elle demande de voir les différences du fichier "file1".

La question est la suivante :

Comment dois-je m'y prendre pour faire communiquer les 2 sockets (Serveur) entre elles ?

En effet, j'utilise SocketServer qui est franchement pratique mais le handler se trouve dans une classe à part. Je ne peux donc pas récupérer "self.wfile" et "self.rfile" des 2 sockets dans une méthode qui gèrerait le dialogue entre les 2 serveurs.

Je vous met en exemple un client/serveur bateau avec SocketServer :

exemple de serveur :

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
 
import SocketServer
import socket
 
class SimpleTCPServer(SocketServer.ThreadingTCPServer):
 
    def __init__(self, ip, port, handler):
        SocketServer.ThreadingTCPServer.__init__(self, (ip, port), handler)
 
    def start(self):
        try:
            self.serve_forever()
        except KeyboardInterrupt as e:
            self.socket.shutdown(socket.SHUT_RDWR)
            self.socket.close()
 
class SimpleTCPHandler(SocketServer.StreamRequestHandler):
 
    def handle(self):
        print("New connection from %s:%d" %self.client_address)
        self.wfile.write("Welcome to server")
        print(self.rfile.readline().strip())
 
if __name__ == "__main__":
    server = SimpleTCPServer("localhost", 2001, SimpleTCPHandler)
    server.start()

exemple de client

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
 
import socket
 
class AdminClient:
 
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port
 
    def connect(self):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.connect((self.ip, self.port))
        print("wait message")
        print(self.sock.recv(100))
        print("after message")
        self.sock.send("exit")
 
    def disconnect(self):
        self.sock.shutdown(socket.SHUT_RDWR)
        self.sock.close()
 
if __name__ == "__main__":
    client = AdminClient("localhost", 2001)
    client.connect()
    client.disconnect()

Je m'y prend mal ? Quelqu'un aurait un conseil ?
Et si je ne suis pas très clair, n'hésitez pas à me demander des précisions.

[wiztricks]

Salut,

Comment dois-je m'y prendre pour faire communiquer les 2 sockets (Serveur) entre elles ?

"Socket" est une API de programmation IP hérité d'UNIX BSD.
On fait communiquer un client et un serveur au dessus d'IP en utilisant l'API "socket".

Un serveur "écoute" (listen) les demandes de connexion d'un client à un port (2001) et à des adresses IP spécifiques (sinon toutes) tel que décrit via 'bind'.
Il "accepte" les connexion et "traite" les requêtes.

Le client effectue les demande de connexion à l'adresse du 'host' et sur le port spécifié. C'est client ou serveur et pas les deux...

Après rien n'empêche d'avoir un "process" qui soit "client" et "serveur" mais côté API, les sockets (instances) devront être différentes et il faudra choisir une technique de multiplexage (select, thread) pour être à la fois client et serveur.

Cordialement,
- W

[sluke]

Salut wiztricks

Merci pour ta réponse.
Du point de vue fonctionnement des sockets, le principe est maitrisé.

Je pense que mon problème est plus d'ordre algorithmique.

Je vais tenter d'expliquer les choses autrement.

Avec mon implémentation actuelle, j'ai donc :
- un client/serveur(que j'appellerai remote) qui gère les connexions multiples vers des hotes distants
- un client/serveur(que j'appellerai admin) qui permet de traiter les commandes qui passe l'utilisateur

Je lance les 2 serveurs (remote et admin)
je lance le client remote. La connexion s'établie, la fonction SimpleTCPHandler.handle de l'instance du serveur remote s'execute.
je lance le client admin. La connexion s'établie, la fonction SimpleTCPHandler.handle de l'instance du serveur admin s'execute.

Logiquement il faudrait que dans la fonction handle du serveur admin "traduise" et "forward" les instructions vers le serveur remote.
Le problème est que dans le "scope" de fonction handle du serveur admin, je n'ai aucune reférence au serveur remote.

La fonction handle est appelée directement dans le module SocketServer donc pas moyen de passer une variable en paramètre. Je peux même pas passer la référence d'une socket d'un serveur vers l'autre puisse que la fonction handle est dans une classe séparée.

Bref je vois pas de solution à part réécrire entièrement un serveur TCP sans passer par ServerSocket.

[utopman]

Salut sluke,

je ne maitrise pas tout ton projet mais si je comprends bien , tu es bloqué par ce que tu ne sais pas faire un lien entre deux sockets?

si tel est le cas, je te propose dans ton serveur frontal une interface dans ce genre (en utilisant des threads en fait)

Code :

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

1
2
3
4
5
6
7
8
9
 
def main():
 
  s1 = socket1(adress)
  s2 = socket2(adress)
 
  #serve forever
  while True:
    s2.write(s1.input())

Avec les sockets qui ouvrent des connexion threadées

[fred1599]

Sur ce lien tu dois avoir ce que tu cherches, c'est à dire une emission et réception simultanée.

[wiztricks]

Salut,

Logiquement il faudrait que dans la fonction handle du serveur admin "traduise" et "forward" les instructions vers le serveur remote.
Le problème est que dans le "scope" de fonction handle du serveur admin, je n'ai aucune reférence au serveur remote.

Ben il faut la créer! i.e lorsque le serveur "admin" reçoit une nouvelle connexion il créera une connexion vers "remote"

Et çà se passera dans handle:

Code :

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

1
2
3
4
 
    def handle(self):
        print("New connection from %s:%d" %self.client_address)
        ...

La fonction handle est appelée directement dans le module SocketServer donc pas moyen de passer une variable en paramètre. Je peux même pas passer la référence d'une socket d'un serveur vers l'autre puisse que la fonction handle est dans une classe séparée.

Cela suppose (mais vous n'êtes pas très clair) partager une connexion entre "admin" et "remote" pour multiplexer les requêtes de plusieurs clients.

Rien ne vous empêche dans ce cas de créer la connexion, la stocker dans l'instance de "SimpleTCPServer" et de la récuperer dans "handle" via self.server.connexion.

note: "multiplexer les requêtes" dans le tuyau est bien plus compliqué et un design différent que réer autant de tuyaux que de client et les gérer séparément via des threads.

Bref je vois pas de solution à part réécrire entièrement un serveur TCP sans passer par ServerSocket.

Ben voyons, rien que çà!

- W