Comment garder une socket ouverte jusqu'à ce que le client la ferme?

Un MyTcpHandler objet est créé pour chaque connexion, et handle est appelée à traiter avec le client. La connexion est fermée lorsque handle retourne, de sorte que vous avez à gérer la communication par le client dans le handle méthode:

class MyTCPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        while 1:
            self.data = self.request.recv(1024)
            if not self.data:
                break
            self.data = self.data.strip()
            print str(self.client_address[0]) + " wrote: "
            print self.data
            self.request.send(self.data.upper())

REMARQUE: recv retourne '' lorsque le client ferme la connexion, donc j'ai déménagé .strip() après la recv donc il n'y a pas de fausse alarme due au client de n'envoyer que des blancs de l'espace.

À un problème similaire ici erreur: [Errno 10053]

J'ai aussi essayé la même chose et j'ai obtenu le même message d'erreur.

Si il y a un code simple comme cela pour démontrer cette erreur:

import socket 

host = 'localhost' 
port = 5001 
size = 102400
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
s.connect((host,port))
for msg in ['Hello, world','Test','anything goes here']:
    s.send(msg)
    data = s.recv(size)
    print 'Received:', data 
s.close()  

Si vous créez une socket et l'amt, il peut envoyer et de récupérer à partir du serveur pour voir combien il récepteurs, si vous varier que, dire de 1024 à 102400(dans ce code);
Ce qui signifie que la prise ne doit pas se ferment, mais encore une fois dans mon système d'exploitation Windows, le serveur conserve l'écoute et l'impression de toutes les données que le client envoie mais sur le côté Client, vous obtenez cette erreur;

Toutefois, si c'est que le client peut se connecter qu'une seule fois et d'envoyer et de recevoir qu'une seule fois, alors que c'est la façon dont il a été conçu. D'essayer cela fonctionne sans erreur:

for msg in ['Hello, world','Test','anything goes here']:
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
    s.connect((host,port))
    s.send(msg)
    data = s.recv(size)
    s.close()
    print 'Received:', data

Je ne suis pas sûr si un socket objet fonctionne qu'une seule fois pour envoyer et recevoir des données.

Mise à JOUR
Je pense que le problème est la capacité par socket client pour la réception de données selon la taille de tampon fixe;
C'est pourquoi le deuxième extrait de code ci-dessus fonctionne donc de la création de nouveau client, prises de branchement sur le serveur. Mais de cette façon, beaucoup de prises allez obtenir.

À la place le code suivant résolu le problème en vérifiant l'amt de la taille utilisée. Si elle dépasse un certain montant, il crée un nouveau socket chez les clients, mais permet de s'assurer que le message est envoyé; en Fait le problème était avec le code du serveur, mais il fixe.

size = 10

C'est un moyen rapide de bébé lors de la tentative de code. Je suis sûr que vous comprenez et l'optimiser pour le mieux!

code client:

messag = ['Hello, world', 'Test', 'anything goes here']

def client_to_server(messag,host,port,size):
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((host, port))
    countmsg = 0
    restmsg = ''
    for msg in messag:
        strl = tmsg = msg
        if len(restmsg):
            tmsg = restmsg + ' ' + msg
        countmsg = len(tmsg)
        if countmsg <= size:
            pass
        else:
            restmsg = tmsg[size:]
            tmsg = tmsg[:size]
            #s.close()
            countmsg = len(tmsg)
            #s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
            #s.connect((host, port))
        print 'Sending to server msg {}'.format(tmsg)
        s.send(tmsg)
        # s.settimeout(1)
        try: 
            data = s.recv(size)
            print 'Received:', data
            if strl == data:
                print strl,data
                countmsg = 0
                restmsg = ''
        except (socket.error), e: 
            print e.args,e.message
            s.close()
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
            s.connect((host, port))
    s.close()
    if restmsg: 
        client_to_server([restmsg],host,port,size)
    return


client_to_server(messag,host,port,size)

Code Serveur:

size = 1024  #This has to be bigger than client buf size!
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((host, port)) 
s.listen(backlog)
while True:
        #this is what accepts and creates a P2P dedicated client socket per socket
        client, address = s.accept()
        try: 
            data = client.recv(size)
            while data or 0:
                print "Client sent {} | Server sending data to client address {}".format(data, address)
                client.send(data)
                data = client.recv(size)
            else: client.close()
        except (socket.error), e: 
            client.close()
            print e.args, e.message

De l'essayer. Il utilise le même socket.