Python Networking: Asynchat рукопожатие - PullRequest
Новая
       32

Python Networking: Asynchat рукопожатие

1 голос
/ 06 декабря 2011

Я использую python asynchat для реализации сетевого протокола. Во время подключения мне нужно отправить команду и ответ сервера с сеансом.

Моя главная проблема заключается в том, что мне нужно подождать, пока я получу ответ на сеанс. но не уверен, как это реализовать. я должен использовать socket.recv для настройки соединения? это хорошая идея?

1 Ответ

3 голосов
/ 06 декабря 2011

Когда вы пишете сетевое приложение с использованием асинхронных методов, вы ждете , записывая свое состояние где-то и затем продолжая основной цикл. Через некоторое время ожидаемые данные станут доступны, основной цикл уведомит вас об этом, и вы сможете объединить новые данные с записанным состоянием, чтобы выполнить любую задачу, над которой вы работаете. В зависимости от конкретной задачи вам может понадобиться пройти этот цикл много раз, прежде чем ваша задача будет фактически выполнена.

Эти идеи в основном одинаковы, независимо от того, какую асинхронную систему вы используете. Однако Twisted - это значительно превосходящая система до asynchat , поэтому я не буду пытаться объяснить какие-либо подробности асинхата. Вместо этого вот пример, который делает то, о чем вы спрашиваете, используя Twisted: 

from twisted.internet.defer import Deferred
from twisted.internet.protocol import Protocol, Factory
from twisted.internet.endpoints import TCP4ClientEndpoint
from twisted.internet import reactor

# Stream-oriented connections like TCP are handled by an instance 
# of a Protocol subclass
class SomeKindOfClient(Protocol):

     # When a new connection is established, the first thing that
     # happens is this method is called.
     def connectionMade(self):
         # self.transport is set by the superclass, and lets us 
         # send data over the connection
         self.transport.write("GREETING")

         # a Deferred is a generic, composable API for specifying
         # callbacks
         self.greetingComplete = Deferred()

         # Here's some local state
         self._buffer = ""

     # Whenever bytes arrive on the TCP connection, they're passed
     # to this method
     def dataReceived(self, bytes):

         # Incorportate the network event data into our local state.
         #  This kind of buffering is always necessary with TCP, because
         # there's no guarantees about how many bytes will be delivered
         # at once (except that it will be at least 1), regardless of
         # the size of the send() the peer did.
         self._buffer += bytes

         # Figure out if we're done - let's say the server response is 32
         # bytes of something
         if len(self._buffer) >= 32:
             # Deliver it to whomever is waiting, by way of the Deferred
             # object
             greeting, self._buffer = self._buffer[:32], self._buffer[32:]
             complete = self.greetingComplete
             self.greetingComplete = None
             complete.callback(greeting)

         # Otherwise we'll keep waiting until dataReceived is called again
         # and we have enough bytes.


# One of the normal ways to create a new client connection
f = Factory()
f.protocol = SomeKindOfClient
e = TCP4ClientEndpoint(reactor, "somehost", 1234)

# Connect returns one of those Deferreds - letting us specify a function
# to call when the connection is established.  The implementation of
# connect is also doing basically the same kind of thing as you're asking
# about.
d = e.connect(f)

# Execution continues to this point before the connection has been
# established.  Define a function to use as a callback when the connection
# does get established.
def connected(proto):
    # proto is an instance of SomeKindOfClient.  It has the 
    # greetingComplete attribute, which we'll attach a callback to so we
    # can "wait" for the greeting to be complete.
    d = proto.greetingComplete

    def gotGreeting(greeting):
        # Note that this is really the core of the answer.  This function
        # is called *only* once the protocol has decided it has received
        # some necessary data from the server.  If you were waiting for a
        # session identifier of some sort, this is where you might get it
        # and be able to proceed with the remainder of your application
        # logic.
        print "Greeting arrived", repr(greeting)

    # addCallback is how you hook a callback up to a Deferred - now
    # gotGreeting will be called when d "fires" - ie, when its callback
    # method is invoked by the dataReceived implementation above.
    d.addCallback(gotGreeting)

# And do the same kind of thing to the Deferred we got from 
# TCP4ClientEndpoint.connect
d.addCallback(connected)

# Start the main loop so network events can be processed
reactor.run()

Чтобы увидеть, как это происходит, вы можете запустить простой сервер (например, nc -l 1234) и указать клиенту на него. Вы увидите прибытие приветствия и можете отправить несколько байтов назад. Как только вы отправите обратно 30, клиент распечатает их (а затем будет зависать бесконечно, потому что в этом протоколе я не реализовал никакой логики).

...