Comment rendre le serveur accepte les connexions à partir de plusieurs ports?

Comment puis-je faire un simple serveur(simple comme dans l'acceptation d'une connexion et d'impression à la borne de tout ce qui est reçu) accepter la connexion à partir de plusieurs ports ou une plage de ports?

Dois-je utiliser plusieurs threads, un pour chaque appel de liaison. Ou est-il une autre solution?

La simple serveur peut ressembler à quelque chose comme ça.

def server():
import sys, os, socket

port = 11116
host = ''
backlog = 5 # Number of clients on wait.
buf_size = 1024

try:
    listening_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    listening_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) 
    listening_socket.bind((host, port)) 
    listening_socket.listen(backlog)
except socket.error, (value, message):
    if listening_socket:
        listening_socket.close()
    print 'Could not open socket: ' + message
    sys.exit(1)

while True:
    accepted_socket, adress = listening_socket.accept()

    data = accepted_socket.recv(buf_size)
    if data:
        accepted_socket.send('Hello, and goodbye.')
    accepted_socket.close()

server()

EDIT:
Ceci est un exemple de la façon dont il peut être fait. Merci à tous.

import socket, select

def server():
import sys, os, socket

port_wan = 11111
port_mob = 11112
port_sat = 11113

sock_lst = []
host = ''
backlog = 5 # Number of clients on wait.
buf_size = 1024

try:
    for item in port_wan, port_mob, port_sat:
        sock_lst.append(socket.socket(socket.AF_INET, socket.SOCK_STREAM))
        sock_lst[-1].setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) 
        sock_lst[-1].bind((host, item)) 
        sock_lst[-1].listen(backlog)
except socket.error, (value, message):
    if sock_lst[-1]:
        sock_lst[-1].close()
        sock_lst = sock_lst[:-1]
    print 'Could not open socket: ' + message
    sys.exit(1)

while True:
    read, write, error = select.select(sock_lst,[],[])

    for r in read:
        for item in sock_lst:
            if r == item:
                accepted_socket, adress = item.accept()

                print 'We have a connection with ', adress
                data = accepted_socket.recv(buf_size)
                if data:
                    print data
                    accepted_socket.send('Hello, and goodbye.')
                accepted_socket.close()

server()
InformationsquelleAutor Orjanp | 2009-08-05
  1. 7

    Je ne suis pas un python gars, mais la fonction qui vous intéresse est "select". Cela vous permettra de regarder des prises multiples et les pauses lorsque l'activité se produit sur l'un d'eux.

    Voici un exemple python qui utilise sélectionnez.

    InformationsquelleAutor Eric Petroelje
  2. 3

    Depuis le Python a beaucoup de frais généraux, multithread apps sont un gros point de débat. Ensuite, il y a tout blocage de fonctionnement-GIL question aussi. Heureusement, le Python devise de "Si cela ressemble à un gros problème, quelqu'un est probablement déjà trouvé une solution (ou plusieurs!)" vrai ici. Ma solution préférée tend à être la microthread modèle, plus précisément gevent.

    Gevent est un événement piloté par un thread unique de la simultanéité de la bibliothèque qui gère la plupart des problèmes pour vous sortir de la boîte via le singe de correction. gevent.monkey.patch_socket() est une fonction qui remplace la prise d'appels avec les non-blocage de variantes, d'interrogation et de sommeil pour permettre le passage à d'autres greenlets en tant que de besoin. Si vous voulez plus de contrôle, ou il n'est pas de coupe c'est pour vous, vous pouvez facilement gérer la commutation de la sélectionner et de gevent's de la coopérative de rendement.

    Voici un exemple simple.

    import gevent
import socket
import gevent.monkey; gevent.monkey.patch_socket()

ALL_PORTS=[i for i in xrange(1024, 2048)]
MY_ADDRESS = "127.0.0.1"    

def init_server_sock(port):
    try: 
        s=socket.socket()
        s.setblocking(0)
        s.bind((MY_ADDRESS, port))
        s.listen(5)
        return s
    except Exception, e:
        print "Exception creating socket at port %i: %s" % (port, str(e))
        return False

def interact(port, sock):
    while 1:
        try:
            csock, addr = sock.accept()
        except:
            continue
        data = ""
        while not data:
            try:
                data=csock.recv(1024)
                print data
            except:
                gevent.sleep(0) #this is the cooperative yield
        csock.send("Port %i got your message!" % port)
        csock.close()
        gevent.sleep(0)


def main():
   socks = {p:init_server_sock(p) for p in ALL_PORTS}
   greenlets = []
   for k,v in socks.items():
       if not v:
           socks.pop(k)
       else:
           greenlets.append(gevent.spawn(interact, k, v))

   #now we've got our sockets, let's start accepting
   gevent.joinall(greenlets)

    Ce serait un super-simple, complètement non testé serveur portion de texte brut We got your message! sur les ports 1024-2048. Impliquant select est un peu plus difficile; vous devez avoir un gestionnaire de greenlet qui appelle sélectionnez-la, puis démarre actifs; mais ce n'est pas massivement difficile à mettre en œuvre.

    Espérons que cette aide! La belle partie de l'greenlet base de la philosophie, c'est que l'appel à select est en fait une partie de leur hub module, comme je le rappel, ce qui vous permettra de créer un beaucoup plus évolutif et complexe serveur plus facilement. C'est assez efficace aussi; il ya un couple de repères flottant autour.

    InformationsquelleAutor Anon
  3. 2

    Si tu voulais vraiment être paresseux (à partir d'un programmeur point de vue, non pas une évaluation du point de vue de), vous pouvez définir un délai d'attente sur votre blocage lire et juste une boucle sur toutes vos prises de courant; si un délai d'attente se produit, il n'y avait pas de données disponibles. Fonctionnellement, ce qui est similaire à ce que l' select est en train de faire, mais il est de prendre le contrôle à l'écart de l'OS et de le mettre dans votre application.

    Bien sûr, cela implique que votre temps de sommeil diminue, votre programme s'approche de 100% d'utilisation du PROCESSEUR, de sorte que vous n'utilisez pas sur une production de l'app. C'est bien pour un jouet bien.

    Ce serait quelque chose comme ceci: (pas testé)

    def server():
    import sys, os, socket

    port = 11116
    host = ''
    backlog = 5 # Number of clients on wait.
    buf_size = 1024
    NUM_SOCKETS = 10
    START_PORT = 2000

    try:
            socket.setdefaulttimeout(0.5) # raise a socket.timeout error after a half second
            listening_sockets = []
            for i in range(NUM_SOCKETS):
                listening_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                listening_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) 
                listening_socket.bind((host, START_PORT + i)) 
                listening_socket.listen(backlog)
                listening_sockets.append(listening_socket)
    except socket.error, (value, message):
            if listening_socket:
                    listening_socket.close()
            print 'Could not open socket: ' + message
            sys.exit(1)

    while True:
            for sock in listening_sockets:
                try:
                    accepted_socket, adress = sock_socket.accept()

                    data = sock.recv(buf_size)
                    if data:
                            sock_socket.send('Hello, and goodbye.')
                    sock.close()
                except socket.timeout:
                    pass

    server()
    • Pourquoi mettre en place votre propre choix? N'est-ce pas le haut-sélectionnez le module plus simple que cela?
    • Merci. Je suppose que depuis le sélectionner utilise moins de CPU. Je suis pour cette solution.
    • J'ai vaguement rappeler pas être plus simple. Mais maintenant que j'y pense un peu plus, il ya une très bonne chance que je travaillais en C, pas en Python, quand je faisais que 🙁
    InformationsquelleAutor Mark Rushakoff