Как я могу получить неблокирующие сокеты connect()?

Вам также необходимо распараллелить соединения, поскольку сокеты блокируются, когда вы устанавливаете тайм-аут. В качестве альтернативы вы могли бы не устанавливать тайм-аут и использовать модуль select.

Это можно сделать с помощью класса диспетчера в модуле asyncore. Взгляните на базовый пример HTTP-клиента. . Несколько экземпляров этого класса не будут блокировать друг друга при подключении. Вы можете сделать это так же легко, используя потоки, и я думаю, что это упрощает отслеживание времени ожидания сокета, но, поскольку вы уже используете асинхронные методы, вы можете оставаться на том же пути.

Например, следующее работает на всех моих 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()

Где в кластере 50 - кластере 100 есть множество машин, которые не отвечают или не существуют. Сразу начинается печать:

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

...

Это, однако, не принимает во внимание getaddrinfo, который должен блокироваться. Если у вас возникли проблемы с разрешением DNS-запросов, все должно подождать. Вероятно, вам нужно собирать DNS-запросы отдельно и использовать IP-адреса в вашем асинхронном цикле.

Если вам нужен набор инструментов побольше, чем asyncore, взгляните на Twisted Matrix. В него немного сложно вникнуть, но это лучший набор инструментов для сетевого программирования, который вы можете получить для Python.

Используйте модуль select. Это позволяет дождаться завершения ввода-вывода на нескольких неблокирующих сокетах. Вот дополнительная информация о выборе. Со страницы, на которую есть ссылка:

В C кодирование select довольно сложно. В Python это проще простого, но достаточно близко к версии C, поэтому, если вы понимаете select в Python, у вас не возникнет проблем с ним в C.

ready_to_read, ready_to_write, in_error = select.select(
                  potential_readers, 
                  potential_writers, 
                  potential_errs, 
                  timeout)

Вы передаете select три списка: первый содержит все сокеты, которые вы, возможно, захотите прочитать; второй — все сокеты, в которые вы, возможно, захотите попробовать записать, а последний (обычно оставленный пустым) — те, которые вы хотите проверить на наличие ошибок. Вы должны заметить, что сокет может входить в более чем один список. Вызов select блокируется, но вы можете дать ему тайм-аут. Как правило, это разумный поступок - дайте ему хороший длительный тайм-аут (скажем, минуту), если у вас нет веских причин поступать иначе.

Взамен вы получите три списка. У них есть сокеты, которые на самом деле доступны для чтения, записи и ошибок. Каждый из этих списков является подмножеством (возможно, пустым) соответствующего списка, который вы передали. И если вы поместите сокет более чем в один входной список, он будет (максимум) только в одном выходном списке.

Если сокет находится в выходном читаемом списке, вы можете быть настолько близки к уверенности, насколько мы когда-либо занимаемся этим делом, что recv в этом сокете что-то вернет. Та же идея для записываемого списка. Вы сможете send кое-что сделать. Может быть, не все, что вы хотите, но что-то лучше, чем ничего. (На самом деле, любой достаточно работоспособный сокет будет возвращен как доступный для записи - это просто означает, что пространство исходящего сетевого буфера доступно.)

Если у вас есть «серверный» сокет, поместите его в список потенциальных_читателей. Если он появится в читаемом списке, ваш accept (почти наверняка) сработает. Если вы создали новый сокет для подключения к кому-то еще, поместите его в список потенциальных_писателей. Если он отображается в списке доступных для записи, у вас есть неплохая вероятность, что он подключен.

К сожалению, нет примера кода, показывающего ошибку, поэтому немного сложно понять, откуда берется этот блок.

Он делает что-то вроде:

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setblocking(0)
s.connect(("www.nonexistingname.org", 80))

Модуль сокета использует внутри себя getaddrinfo, что является блокирующей операцией, особенно когда имя хоста не существует. Стандартный совместимый DNS-клиент подождет некоторое время, чтобы увидеть, действительно ли имя не существует или задействованы только некоторые медленные DNS-серверы.

Решение состоит в том, чтобы подключаться только к ip-адресам или использовать DNS-клиент, который разрешает неблокирующие запросы, например pydns< /а>.

Используйте twisted.

Это асинхронный сетевой движок, написанный на Python, поддерживающий множество протоколов, и вы можете добавить свой собственный. Его можно использовать для разработки клиентов и серверов. Он не блокируется при подключении.

Вы смотрели модуль asyncore? Может быть как раз то, что вам нужно.