Comment puis-je obtenir un socket connect () non bloquant?

J'ai un assez simple problème ici. J'ai besoin de communiquer avec un grand nombre d'hôtes simultanément, mais je n'ai pas vraiment besoin d'une synchronisation parce que chaque demande est assez suffisant.

À cause de cela, j'ai choisi de travailler avec des sockets asynchrones, plutôt que de spammer les threads.
Maintenant j'ai un petit problème:

Async ça marche comme un charme, mais lorsque je me connecte à 100 hôtes, et je reçois 100 délais d'attente (timeout = 10 secondes), puis-je attendre de 1000 secondes, juste pour trouver toutes mes connexions échoué.

Est-il possible également d'obtenir non blocage de la douille se connecte?
Mon socket est déjà réglé à non bloquantes, mais les appels à connect() sont toujours de blocage.

Réduction du délai d'attente n'est pas une solution acceptable.

Je le fais en Python, mais je suppose que le langage de programmation ne marche pas vraiment d'importance dans ce cas.

Ai-je vraiment besoin d'utiliser des threads?

source d'informationauteur Tom

4

Vous avez besoin pour paralléliser le relie ainsi, depuis les prises de bloc lorsque vous définissez un délai d'attente. Sinon, vous ne pouvez pas définir un délai d'attente, et l'utilisation de l'sélectionnez le module.

Vous pouvez le faire avec la classe dispatcher dans le asyncore module. Jetez un oeil à la base client http exemple. Plusieurs instances de cette classe de ne pas bloquer les uns les autres sur se connecter. Vous pouvez le faire facilement à l'aide de threads, et je pense que rend le suivi de socket délais d'attente plus facile, mais puisque vous êtes déjà à l'aide de méthodes asynchrones vous pourriez aussi bien rester sur la même piste.

Comme un exemple, le code suivant fonctionne sur tous mes systèmes linux
```
import asyncore, socket

class client(asyncore.dispatcher):
    def __init__(self, host):
        self.host = host
        asyncore.dispatcher.__init__(self)
        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        self.connect((host, 22))

    def handle_connect(self):
        print 'Connected to', self.host

    def handle_close(self):
        self.close()

    def handle_write(self):
        self.send('')

    def handle_read(self):
        print ' ', self.recv(1024)

clients = []
for i in range(50, 100):
    clients.append(client('cluster%d' % i))

asyncore.loop()
```
Où dans cluster50 - cluster100, il y a de nombreuses machines qui ne répondent pas, ou inexistant. Cela commence tout de suite l'impression:
```
Connected to cluster50
  SSH-2.0-OpenSSH_4.3

Connected to cluster51
  SSH-2.0-OpenSSH_4.3

Connected to cluster52
  SSH-2.0-OpenSSH_4.3

Connected to cluster60
  SSH-2.0-OpenSSH_4.3

Connected to cluster61
  SSH-2.0-OpenSSH_4.3

...
```
Ceci, cependant, ne tient pas compte de getaddrinfo, qui, pour le bloquer. Si vous rencontrez des problèmes de résoudre les requêtes dns, tout est à attendre. Vous avez probablement besoin de recueillir les requêtes dns séparément sur votre propre et utiliser les adresses ip de votre asynchrone en boucle

Si vous voulez un plus grand toolkit d'asyncore, jetez un oeil à Tordu De La Matrice. C'est un peu lourd à aborder, mais c'est le meilleur de la programmation réseau trousse d'outils que vous pouvez obtenir pour python.
8

Utiliser le select module. Cela vous permet d'attendre la fin d'e/S sur plusieurs sockets non blocage. Voici plus d'information sur sélectionner. À partir de la liés à la page:

En C, le codage select est assez complexe.
En Python, c'est un morceau de gâteau, mais
il est assez proche de la version de C
que si vous comprenez sélectionnez dans
Python, vous aurez peu de mal à
dans C.
```
ready_to_read, ready_to_write, in_error = select.select(
                  potential_readers, 
                  potential_writers, 
                  potential_errs, 
                  timeout)
```
Vous passez select trois listes: la première
contient toutes les prises que vous pourriez
envie d'essayer de lire; la deuxième
les prises de courant, vous pourriez vouloir essayer
l'écriture et la dernière (normalement
laissé vide) ceux que vous voulez
vérifier les erreurs. Vous devriez noter que
un socket peut aller dans plus d'un
liste. Le select appel est bloquant, mais
vous pouvez lui donner un délai d'attente. C'est
généralement une chose sensée à faire -
donner une belle délai long (disons un
minute), sauf si vous avez de bonnes raisons de
faire autrement.

En retour, vous obtiendrez trois listes.
Ils ont les sockets
en fait lisible, accessible en écriture et en
erreur. Chacune de ces listes est un sous-ensemble
(éventuellement vide) de l'correspondant
liste passée dans. Et si vous mettez un
douille en plus d'une entrée de la liste, il
ne seront (au plus) dans une sortie
liste.

Si une prise est dans la sortie lisible
liste, vous pouvez être
as-près-pour-certains-comme-on-jamais-obtenir-dans-cette-business
qu'un recv sur ce socket sera de retour
quelque chose. Même idée pour l'écriture
liste. Vous serez en mesure de send
quelque chose. Peut-être pas tout ce que vous voulez,
mais quelque chose est mieux que rien.
(En fait, tout en assez bonne santé
socket sera de retour comme l'écriture - il
signifie simplement sortant du tampon réseau
l'espace est disponible.)

Si vous avez un serveur de socket, de mettre
dans le potential_readers liste. Si c'
vient dans la lisible liste, votre
accepter sera (presque certainement).
Si vous avez créé un nouveau socket
se connecter à quelqu'un d'autre, le mettre dans le
potential_writers liste. Si elle se montre
dans l'écriture de la liste, vous avez une
bonnes chances qu'il s'est connecté.
7

Malheureusement, il n'y a pas d'exemple de code qui montre le bug, donc c'est un peu dur de voir où ce bloc vient de.

Il fait quelque chose comme:
```
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setblocking(0)
s.connect(("www.nonexistingname.org", 80))
```
Le support de module utilise getaddrinfo l'interne, ce qui est une opération de blocage, en particulier lorsque le nom d'hôte n'existe pas. Un standard conforme dns client va attendre un certain temps pour voir si le nom n'existe, ou si il y a juste une certaine lenteur des serveurs dns impliqués.

La solution est de se connecter à des adresses ip uniquement ou utiliser un client dns qui permet à des non-blocage des demandes, comme pydns.
4

Utilisation tordu.

C'est un réseau asynchrone moteur écrit en Python, supportant de nombreux protocoles, et vous pouvez ajouter vos propres. Il peut être utilisé pour développer des clients et des serveurs. Il n'est pas sur le bloc de connexion.
0

Avez-vous regarder le asyncore module? Pourrait être juste ce dont vous avez besoin.

Vous devez vous connecter pour publier un commentaire.