Comment arrêter un python de socket.appel accept ()?

Je suis un débutant en python sockets et je suis vraiment troublé par l'entêtement de la socket.méthode accept (). J'ai vraiment besoin d'un moyen de mettre fin à une prise de courant.méthode accept() ou de toute autre alternative à la prise.accept() qui exécute une seule fois. Plzzzz quelqu'un de l'aide.

  • Vous devriez vérifier le socket.setblocking de la fonction et de la select module.
InformationsquelleAutor cybernerd | 2012-04-10
  1. 13

    Vous disposez de plusieurs options ici:

    1. Fermer la socket d'écoute à partir d'un autre thread - le accept() va lever une exception en cas d'échec.
    2. Ouvrir une connexion locale dans le socket d'écoute - qui fait de la accept() retour par la conception.
    3. Utiliser un accepter mécanisme qui peut bloquer sur plus d'un objet de synchronisation, de sorte que l'attente peut être signalé à la restitution sans connexion.
    4. Utiliser un non-bloquant alternative à accept(), (async comme AcceptEx() et se chevauchent IO sur Windows).
    • En Python accept va lever une exception en cas d'échec.
    • merci. Je n'ai pas de Python, mais l'OP question est plus générale TCP problème de serveur et le même ensemble de "trucs" sont nécessaires dans toutes les langues.
    • Pouvez-vous donner un exemple, parce que comme dit précédemment je suis un newbie....je suis en train d'écrire un serveur en pygtk. Mon problème est que la fenêtre se bloque à cause de la prise.appel accept ().
    • Sur OSX 10.10 avec Python 2.7.6, (1) n'est pas fiable. Cependant, à l'aide d'un quit_now style de drapeau dans le accepter la boucle, puis en le connectant (2) au déclenchement d'un retour d'accept() fonctionne très bien.
    • Option #2 semble être la plus appropriée pour plusieurs de mes applications.
    • Pourriez-vous montrer des exemples de ceux-ci? Vous n'avez aucune idée de l'utilité qu'ils seraient.

    InformationsquelleAutor Martin James
  2. 0

    De donner des précisions sur la réponse précédente.

    Si vous avez, disons, de créer un simple socket server thread comme suit:

    class SocketServerThread(threading.Thread):

    # Required by threading.Thread
    def __init__(self, socket_name):
        threading.Thread.__init__(self)

        # Simple Unix socket.
        # Could be a TCP socket instead.
        self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
        self.sock.bind(socket_name)
        self.sock.listen(1)
        self.sock_conn = None

    # Required by threading.Thread
    def run(self):
        self.sock_conn, _ = self.sock.accept()

        # Read just one message, then stop.
        with self.sock_conn:
            recv_data = self.sock_conn.recv(4096)
            print('Received message of size '+ str(len(recv_data)))

    Et puis, il arrive qu'il n'y a pas de clients, mais le fil continue de fonctionner parce que le sock.accept blocs, vous pouvez ajoutez la méthode suivante à la classe SocketServerThread ci-dessus pour arrêter le fil de blocage:

        def stop_accept(self):
        # Skip if sock.accept has executed.
        if self.sock_conn is None:

            # Connect to ourselves as a fake client.
            with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
                s.connect(self.socket_name)

    Ensuite, vous pouvez utiliser le fil comme suit:

    sock_thread = SocketServerThread('/tmp/my_socket_name')
sock_thread.start()

time.sleep(5)

# Decided that we don't want to 
# wait for clients anymore.
sock_thread.stop_accept()
sock_thread.join()

    Noter que le code suppose qu'une fois que vous décidez de ne pas accepter des clients, un client ne peut plus se connecter. Si un autre client se connecte entre le if self.sock_conn is None
    et with socket.socket lignes, vous obtiendrez un Connection refused, et aurez à gérer de manière appropriée. Si vous avez un contrôle serré des clients, cependant, cela devrait être suffisant.

    InformationsquelleAutor vasilyrud