simple serveur avec plusieurs clients

Je suis en train de mettre en œuvre simple serveur avec plusieurs clients. Il devrait recevoir des données de prise et par la suite envoyer des données à d'autres clients. J'utilise sélectionnez le module à partir de la bibliothèque standard de Python.
Voici serveur:

class ProcessingServer:
    def __init__(self, bindaddress="localhost", portname=50001, maxqueue=5):
        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.socket.bind((bindaddress, portname))
        self.socket.listen(maxqueue)
        self.inputsocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.data = ""

    def connect_to_output(self, address, port):
        self.inputsocket.connect((address, port))

    def start(self):
        rsocks = []
        wsocks = []
        rsocks.append(self.socket)
        wsocks.append(self.inputsocket)
        self.socket.accept()

        while True:
            try:
                reads, writes, errs = select.select(rsocks, wsocks, [])
            except:
                return
            for sock in reads:
                if sock == self.socket:
                    client, address  = sock.accept()
                    rsocks.append(client)
                else:
                    self.socket.send(self.data)
                    rsocks.remove(sock) 
            for sock in writes:
               if sock == self.inputsocket:
                    self.data = sock.recv(512)
                    wsocks.remove(sock)
                    print repr(self.data)

Ici est simple client:

import socket
mysocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
mysocket.connect(("localhost", 50001))
while True:
    data = mysocket.recv(512)
    print repr(data)
mysocket.close()

Recevant une partie de serveur fonctionne bien, mais le serveur ne produit pas de sortie.
Je ne suis pas expérimenté dans la programmation de réseau à tout et Il se sent comme je suis en manque de quelque chose.

  • (chuchote) twisted
  • Merci, mais je tiens à garder les choses aussi simples que possible))
  • Twisted est beaucoup plus simple que d'utiliser les sockets. Vous n'avez même pas à vous soucier de threads. Tordu n' tous que le jazz pour vous.
InformationsquelleAutor qutron | 2011-08-23
  1. 2

    Il y a quelques choses qui semblent bizarres dans votre script.

    L'utilisation standard de l'sélectionnez le module est le suivant: vous avez un socket pour écouter les connexions, et une prise pour la connexion avec les clients.

    Au premier abord, que cette prise est ajoutée à vos lecteurs potentiels de liste et de votre potentiel écrivains liste est vide.

    Appel à select.sélectionnez(potential_readers, potential_writers, potential_errors) sera de retour 3 listes:
    - Les prises prêt pour la lecture
    - Les prises prêt pour l'écriture
    - Les prises en erreur

    Dans la liste des sockets prêt pour la lecture, si le socket est celui de l'écoute de la connexion, il doit l'accepter et de mettre le nouveau socket, le potentiel de lectures, le potentiel de l'écrit et les erreurs potentielles.

    Si le socket est un autre puis, il y a des données à lire à partir de cette prise. Il est recommandé de faire un appel à la chaussette.recv(longueur)

    Si vous souhaitez envoyer des données, vous devez l'envoyer à partir de votre wlist retournée par select.sélectionnez.

    La errlist n'est pas utilisé très souvent.

    Maintenant, pour la solution à votre problème, la façon dont vous décrivez votre protocole (si j'ai bien compris), il pourrait ressembler à ceci:

    import socket, select

sock_producer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_producer.bind(('localhost', 5000))
sock_producer.listen(5)
producers = []    

clients = []
sock_consumer_listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Note: different port to differentiate the clients who receive data from the one who sends messages
sock_consumer_listener.bind(('localhost', 5001))

rlist = [sock_producer, sock_listener]
wlist = []
errlist = []

out_buffer = []

while True:
    r, w, err = select.select(rlist, wlist, errlist)
    for sock in r:
        if sock == sock_producer:
            prod, addr = sock.accept()
            producers.append(prod)
            rlist.append(prod)
         elif sock == sock_consumer_listener:
            cons, addr = sock.accept()
            clients.append(cons)
            wlist.append(cons)
         else:
            out_buffer.append(sock.recv(1024))

     out_string = ''.join(out_buffer)
     out_buffer = []

     for sock in w:
         if sock in clients:
             sock.send(out_string)

    Je n'ai pas testé ce code, alors il pourrait y avoir quelques erreurs, mais c'est à la façon dont je le ferais.

    • +1 pour "port différent pour différencier les clients qui reçoivent des données à partir de celui qui envoie des messages " Oui. Un jour , j'ai passé plusieurs heures avant de comprendre que. Il n'est pas bien souligné dans les docs et tutos
    • Je n'ai pas l'obtenir. J'ai une femelle de la source de données. La source socket est un socket client et j'essaie de me connecter dès que je démarre mon serveur. (inputsocket dans mon exemple). Un autre socket socket d'écoute pour les connexions entrantes. Mais il y a deux "serveur" prises dans votre exemple - sock_producer, sock_listener. Pourriez-vous expliquer un peu plus?
    • La source de données est l'un socket. Dans mon cas, la source de socket est le producteur. J'écoute au lieu de se connecter quelque part, mais il devrait être facile à adapter (se Connecter à la place de l'écoute) et retirer le bloc if sock == sock_producer: ...
    • Eh bien, tout est bien maintenant. Fonctionne comme un charme. Merci!!!!
    InformationsquelleAutor Martin
  2. 2

    Ouais...utiliser zeromq à la place:

    server.py

    import zmq
context = zmq.Context()
socket = context.socket(zmq.REP)
socket.bind("tcp://127.0.0.1:50001")

while True:
    msg = socket.recv()
    print "Got", msg
    socket.send(msg)

    client.py

    import zmq
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://127.0.0.1:50001")

for i in range(100):
    msg = "msg %s" % i
    socket.send(msg)
    print "Sending", msg
    msg_in = socket.recv()
    • est-il sécuritaire de mettre zeromq sur l'internet public encore? comme de plus tôt cette année, il n'était pas, comme des tiers malveillants pourraient trivial cause de votre auditeur à l'accident en senfing il à des données incorrectes.
    • Pas sûr de ce que vous faites référence? Lien? J'imagine que ça va être plus stable que d'essayer de le faire à faible niveau de prise de trucs à la main. Si vous voulez quelque chose de plus robuste, tordu pourrait être le chemin à parcourir.
    • Par exemple, <lists.zeromq.org/pipermail/zeromq-dev/2010-September/...>. Les deux questions mentionnées, il semble y être fixe (malheureusement les liens sont rompus, ce qui n'est pas complètement évident). J'ai trouvé ce post avec juste une ou deux minutes de recherche sur google. Autres recherches, peut-être y aura d'autres problèmes similaires.
    • Difficile de déduire où zeromq peuplements en termes de stabilité. Dans mon utilisation, je n'ai pas eu de problèmes avec elle que ce soit, mais je ne suis pas du bâtiment services internet avec. Peut être bon pour l'amener jusqu'à votre cas d'utilisation dans le canal IRC, ou sur la liste de diffusion. Il n'a pas intégré de sécurité de sorte qu'il n'est pas idéal pour un internet service par lui-même. À l'aide de tordu serait une meilleure idée, si c'est ce que vous construisez.
    • Est-ce à zmq exemple, le travail pour essentiellement un client en cours d'exécution de script sur un et un seul client ip+port. De sens que si vous avez un bureau satellite à 10 nœuds (Pc) connexion par le biais d'une adresse IP à chaque nœud aura besoin de sa propre port? Ne serait pas en cours d'exécution de ce script dans des fenêtres différentes sur la même machine induire en erreur? Comment le serveur peut-il savoir qui, de la fenêtre de console pour envoyer des données trop?
    InformationsquelleAutor zeekay