Plusieurs connexions réseau simultanées - Serveur Telnet, Python

Question

J'écris actuellement un serveur telnet en Python. C'est un serveur de contenu. Les gens se connectent au serveur via telnet, et se voient présenter du contenu textuel.

Mon problème est que le serveur devrait évidemment supporter plus d'une connexion simultanée. La mise en œuvre actuelle que j'ai maintenant ne supporte qu'un seul.

Ceci est la base, la preuve de concept serveur j'ai commencé avec (alors que le programme a beaucoup changé au fil du temps, le cadre telnet de base n'a pas):

import socket, os 

class Server: 
    def __init__(self): 
     self.host, self.port = 'localhost', 50000 
     self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
     self.socket.bind((self.host, self.port)) 

    def send(self, msg): 
     if type(msg) == str: self.conn.send(msg + end) 
     elif type(msg) == list or tuple: self.conn.send('\n'.join(msg) + end) 

    def recv(self): 
     self.conn.recv(4096).strip() 

    def exit(self): 
     self.send('Disconnecting you...'); self.conn.close(); self.run() 
     # closing a connection, opening a new one 

    # main runtime 
    def run(self): 
     self.socket.listen(1) 
     self.conn, self.addr = self.socket.accept() 
     # there would be more activity here 
     # i.e.: sending things to the connection we just made 


S = Server() 
S.run() 

Merci pour votre aide.

Answer 1

Si vous êtes prêt pour un défi conceptuel, je voudrais utiliser Twisted.

Votre cas devrait être trivial à mettre en œuvre dans le cadre de torsadé. http://twistedmatrix.com/projects/core/documentation/howto/servers.html

Answer 2

Vous avez besoin d'une forme d'E/S de socket asynchrone. Jetez un oeil à this explanation, qui traite du concept dans les termes de socket de bas niveau, et les exemples connexes qui sont implémentés en Python. Cela devrait vous orienter dans la bonne direction.

Answer 3

Pour une victoire vraiment facile vous mettre en œuvre la solution à l'aide SocketServer & la SocketServer.ThreadingMixIn

un coup d'oeil un cet exemple de serveur d'écho, il semble tout à fait semblable à ce que vous faites de toute façon: http://www.oreillynet.com/onlamp/blog/2007/12/pymotw_socketserver.html

Answer 4

Mis en œuvre en twisted:

from twisted.internet.protocol import Factory, Protocol 
from twisted.internet import reactor 

class SendContent(Protocol): 
    def connectionMade(self): 
     self.transport.write(self.factory.text) 
     self.transport.loseConnection() 

class SendContentFactory(Factory): 
    protocol = SendContent 
    def __init__(self, text=None): 
     if text is None: 
      text = """Hello, how are you my friend? Feeling fine? Good!""" 
     self.text = text 

reactor.listenTCP(50000, SendContentFactory()) 
reactor.run() 

Test:

$ telnet localhost 50000 
Trying 127.0.0.1... 
Connected to localhost. 
Escape character is '^]'. 
Hello, how are you my friend? Feeling fine? Good! 
Connection closed by foreign host. 

Sérieusement, quand il s'agit d'un réseau asynchrone, c'est le chemin à parcourir. Il gère plusieurs connexions dans une approche mono-thread mono-processus.

Answer 5

Si vous voulez le faire en pure python (sans-twisted), vous devez faire du threading. Si vous havnt vu avant, consultez: http://heather.cs.ucdavis.edu/~matloff/Python/PyThreads.pdf

autour de la page 5/6 est un exemple qui est très pertinente;)

Answer 6

D'abord, acheter des livres de Comer sur TCP/IP programming.

Dans ces livres, Comer fournira plusieurs algorithmes alternatifs pour les serveurs. Il y a deux approches standard.

• Fil par requête.

• Processus par requête.

Vous devez choisir l'un des deux et implémenter cela. En thread-per, chaque session telnet est un fil séparé dans votre application globale.

Dans process-per, vous utilisez chaque session Telnet dans un sous-processus distinct.

Vous constaterez que le traitement par requête est beaucoup plus facile à gérer en Python et qu'il permet généralement une utilisation plus efficace de votre système. Thread-per-request est bien pour les choses qui vont et viennent rapidement (comme les requêtes HTTP).

Telnet a des sessions de longue durée où le coût de démarrage d'un sous-processus ne domine pas les performances.

Answer 7

En retard pour la réponse, mais avec les seules réponses étant Twisted ou threads (aïe), je voulais ajouter une réponse pour MiniBoa.

http://code.google.com/p/miniboa/

Twisted est grande, mais il est une bête assez grande qui peut ne pas être la meilleure introduction à la programmation Telnet asynchrone mono-thread. MiniBoa est une implémentation légère et asynchrone de Python Telnet à un seul thread, conçue à l'origine pour les boues, ce qui correspond parfaitement à la question de l'OP.

Answer 8

Essayez le serveur MiniBoa? Il a exactement 0 dépendances, pas de choses tordues ou autres. MiniBoa est un serveur telnet async non bloquant, à un seul thread, exactement ce dont vous avez besoin.

http://code.google.com/p/miniboa/

Answer 9

Utilisez le filetage puis ajoutez le gestionnaire dans une fonction. Le fil appellera à chaque fois que je demande faite:

Regardez ce

import socket    # Import socket module 
import pygame 
import thread 
import threading,sys 

s = socket.socket()   # Create a socket object 
host = socket.gethostname() # Get local machine name 
port = 12345    # Reserve a port for your service. 
s.bind((host, port)) 
print ((host, port)) 
name = "" 
users = [] 

def connection_handler (c, addr): 
     print "conn handle" 
     a = c.recv (1024) 
     if a == "c": 
     b = c.recv (1024) 
     if a == "o": 
     c.send (str(users)) 
     a = c.recv (1024) 
     if a == "c": 
      b = c.recv (1024) 
     print a,b 






s.listen(6)     # Now wait for client connection. 
while True: 
    c, addr = s.accept() 
    print 'Connect atempt from:', addr[0] 
    username = c.recv(1024) 
    print "2" 
    if username == "END_SERVER_RUBBISH101": 
     if addr[0] == "192.168.1.68": 
     break 
    users.append(username) 
    thread.start_new_thread (connection_handler, (c, addr)) #New thread for connection 

print 
s.close()