Multitraitement et des prises en Python

Je suis en train de faire le multitraitement et la programmation socket travailler ensemble, mais, je suis coincé à ce point. Le problème est que, j'obtiens cette erreur:

  File "multiprocesssockserv.py", line 11, in worker
    clientsocket = socket.fromfd(clientfileno, socket.AF_INET, socket.SOCK_STREAM)
error: [Errno 9] Bad file descriptor

Code complet que l'origine de l'erreur est le suivant:

import multiprocessing as mp
import logging
import socket

logger = mp.log_to_stderr(logging.WARN)

def worker(queue):
    while True:
        clientfileno = queue.get()
        print clientfileno
        clientsocket = socket.fromfd(clientfileno, socket.AF_INET, socket.SOCK_STREAM)
        clientsocket.recv()
        clientsocket.send("Hello World")
        clientsocket.close()

if __name__ == '__main__':
    num_workers = 5
    socket_queue = mp.Queue()
    workers = [mp.Process(target=worker, args=(socket_queue,)) for i in
            range(num_workers)]

    for p in workers:
        p.daemon = True
        p.start()

    serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    serversocket.bind(('',9090))
    serversocket.listen(5)
    while True:
        client, address = serversocket.accept()
        socket_queue.put(client.fileno())

edit: je suis à l'aide d'une douille.fromfd parce que je ne peux pas mettre les douilles dans une file d'attente 🙂 j'ai besoin d'un moyen d'accéder aux mêmes prises à partir de différents processus en quelque sorte. C'est le coeur de mon problème.

Quelle plate-forme?
Désolé, j'ai oublié de mentionner que 🙂 plate-forme Linux.

OriginalL'auteur yasar | 2011-12-17

  1. 7

    Après avoir travaillé sur cette question depuis un certain temps, j'ai décidé d'aborder ce problème sous un angle différent, et en suivant la méthode semble fonctionner pour moi.

    import multiprocessing as mp
import logging
import socket
import time

logger = mp.log_to_stderr(logging.DEBUG)

def worker(socket):
    while True:
        client, address = socket.accept()
        logger.debug("{u} connected".format(u=address))
        client.send("OK")
        client.close()
if __name__ == '__main__':
    num_workers = 5

    serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    serversocket.bind(('',9090))
    serversocket.listen(5)

    workers = [mp.Process(target=worker, args=(serversocket,)) for i in
            range(num_workers)]

    for p in workers:
        p.daemon = True
        p.start()

    while True:
        try:
            time.sleep(10)
        except:
            break
    Cela semble être une solution intelligente. Avez-vous rencontrez des problèmes avec le fait d'avoir plusieurs auditeurs de la même serversocket?

    OriginalL'auteur yasar

  2. 3

    Je ne suis pas un expert donc je ne peux pas donner la vraie explication, mais si vous voulez utiliser les files d'attente, vous devez réduire la poignée, puis la recréer:

    dans votre principal :

    client, address = serversocket.accept()
client_handle = multiprocessing.reduction.reduce_handle(client.fileno())
socket_queue.put(client_handle)

    et dans votre travailleur:

    clientHandle = queue.get()
file_descriptor = multiprocessing.reduction.rebuild_handle(client_handle)
clientsocket = socket.fromfd(file_descriptor, socket.AF_INET, socket.SOCK_STREAM)

    aussi

    import multiprocessing.reduction

    Qui fonctionnera avec votre code d'origine.
    Cependant, je rencontre actuellement des problèmes avec la fermeture des douilles dans les processus de travail après qu'ils ont été créés comme je l'ai décrit.

    OriginalL'auteur Panter4

  3. 0

    Voici du code du travail sur ce qui est mentionné ci - dessus - https://gist.github.com/sunilmallya/4662837 multiprocessing.réduction de la socket serveur avec les parents de traitement en passant connexions de client après acceptation de connexions

    OriginalL'auteur Sunil