python serveur multithread

Ce que je suis en train de programme est simple multithread python serveur de jeu pour le plaisir. Après beaucoup de frustration, je n'ai pas été en mesure de comprendre pourquoi mon test de connexion du client. Voici mon server.py code:

    import socket
import threading
import clientThread
import struct
import string

class Server:
    def __init__(self):
        self.HOST = 'localhost'
        self.PORT = 22085
        self.BUFFIZE = 1024
        self.ADDRESS = (self.HOST,self.PORT)
        self.clientList = []
        input("Press enter to start the server. . .")
        self.running = True
        self.serverSock = socket.socket()
        self.serverSock.bind(self.ADDRESS)
        self.serverSock.listen(2)
        self.clientThread = clientThread.clientThread(self)
        print("Starting client thread. . .")
        self.clientThreadObj = threading.Thread(target = self.clientThread.start, args = (self))
        print("Awaiting connections. . .")
        while self.running:
            clientInfo = self.serverSock.accept()
            print("Client connected from %s." % clientInfo[1])
            # Append to clientThread list...

        self.serverSock.close()
        print("- end -")

serv = Server()

Le serveur démarre le thread pour les connexions existantes et commence à écouter. Le fil intégré pour les connexions existantes, clientThread, des boucles à travers une liste d'objets client qui pour l'instant ne rien faire, ils sont tout simplement architectural. Ici, c'est le clientThread.py

import socket
import threading
import struct
import string

class clientThread:
    def __init__(self, serv):
        self.server = serv
        self.clientList = []
        self.running = True
        print("Client thread created. . .")
    def start(self):
        print("Beginning client thread loop. . .")
        while self.running:
            for client in self.clientList:
                message = client.sock.recv(self.server.BUFFSIZE)
                if message != None and message != "":
                    client.update(message)

Et enfin, le très simple client de l'objet:

import string

class clientObject:
    def start(self,clientInfo):
        self.sock = clientInfo[0]
        self.address = clientInfo[1]
    def update(self,message):
        self.sock.send("Testamundo.\r\n".encode())

Maintenant, le problème ici est que mon client ne peut même pas se connecter à mon serveur. - Il simplement. Voici le code de mon client simple test:

import socket
import string

address = ("192.168.1.1",22085)
mySocket = socket.socket()

mySocket.connect(address)
print("Connected successfully!")

Cela renvoie, sur la ligne qui relie à l'adresse "Une tentative de connexion a échoué car le parti connecté n'a pas répondu convenablement après une période de temps, ou une connexion établie a échoué car l'hôte connecté n'a pas répondu".

Des suggestions? Merci! Désolé pour tout ce code, je ne savais pas si je devais poster tous ou pas, j'ai donc pensé qu'il ne pouvait pas trop mal.

Vous pourriez être en train de réinventer la roue. Découvrez docs.python.org/library/socketserver.html Plus précisément le paragraphe sur le multithreading mixin docs.python.org/library/socketserver.html#asynchronous-mixins
Comment est-ce module de m'échapper! Je ne savais même pas qu'il existait... Merci!
Cela devrait être une réponse.

OriginalL'auteur pajm | 2011-04-02

Avez-vous des deux systèmes? Le système de serveur IP: 192.168.1.1? Si vous ne disposez que d'un seul système, l'adresse localhost est 127.0.0.1. Qui a été le premier changement que j'ai eu à faire à votre code pour obtenir une connexion lors de l'exécution du client et serveur sur le même système.

Un autre problème est que votre client thread n'a pas de réellement commencer. Puisque vous voulez un client de la classe thread, voici comment déclarer et démarrer:

Sous-classe de filetage.Fil de discussion.
Remplacer __init__ de votre comportement, mais d'appeler __init__ dans la classe de base en premier.
Remplacer run pour le thread de travail.
Créer une instance et d'appel de sa start méthode.

Un autre problème est recv blocs si le client n'a pas envoyé toutes les données, donc si vous essayez de vous connecter plusieurs clients, il va s'accrocher dans votre boucle sur la liste des clients. Vous aurez besoin d'un thread par client ou de l'utilisation select.select pour interroger les sockets client pour la lecture/écriture de préparation.

Ci-dessous est le code modifié qui a un seul client pour répondre, mais il a besoin de travail pour gérer plusieurs clients. Il a également besoin de définir un protocole pour gérer les messages. TCP est un protocole de transmission en continu (pas de limites de message), donc un envoi de " abc " et " 123 "pourrait entraîner la dans un recevoir de "abc123" ou " ab " et "c123", etc. Il aura à gérer la fermeture des connexions et supprimer le client des objets à partir de la liste des clients.

Bonne chance! Vous apprendrez beaucoup de choses à trouver comment faire tout cela à partir de zéro. Regardez les socketserver.py bibliothèque ainsi par exemple, le code.

srv.py

import socket
import threading
import struct
import string
class clientThread(threading.Thread):
def __init__(self, serv):
threading.Thread.__init__(self)
self.server = serv
self.clientList = []
self.running = True
print("Client thread created. . .")
def run(self):
print("Beginning client thread loop. . .")
while self.running:
for client in self.clientList:
message = client.sock.recv(self.server.BUFFSIZE)
if message != None and message != "":
client.update(message)
class clientObject(object):
def __init__(self,clientInfo):
self.sock = clientInfo[0]
self.address = clientInfo[1]
def update(self,message):
self.sock.send("Testamundo.\r\n".encode())
class Server(object):
def __init__(self):
self.HOST = 'localhost'
self.PORT = 22085
self.BUFFSIZE = 1024
self.ADDRESS = (self.HOST,self.PORT)
self.clientList = []
input("Press enter to start the server. . .")
self.running = True
self.serverSock = socket.socket()
self.serverSock.bind(self.ADDRESS)
self.serverSock.listen(2)
self.clientThread = clientThread(self)
print("Starting client thread. . .")
self.clientThread.start()
print("Awaiting connections. . .")
while self.running:
clientInfo = self.serverSock.accept()
print("Client connected from {}.".format(clientInfo[1]))
self.clientThread.clientList.append(clientObject(clientInfo))
self.serverSock.close()
print("- end -")
serv = Server()

clnt.py

import socket
import string
address = ('localhost',22085)
mySocket = socket.socket()
mySocket.connect(address)
print("Connected successfully!")
mySocket.send('blah'.encode())
print(mySocket.recv(1024))

De sortie (srv.py)

Press enter to start the server. . .
Client thread created. . .
Starting client thread. . .
Beginning client thread loop. . .
Awaiting connections. . .
Client connected from ('127.0.0.1', 52850).

De sortie (clnt.py)

Connected successfully!
b'Testamundo.\r\n'

OriginalL'auteur Mark Tolonen

Vous devez vous connecter pour publier un commentaire.