GNU Info
(python2.1-lib.info)asyncore
Asynchronous socket handler
===========================
A base class for developing asynchronous socket handling services.
This module was written by Sam Rushing <rushing@nightmare.com>.
This manual section was written by Christopher Petrilli
<petrilli@amber.org>.
This module provides the basic infrastructure for writing asynchronous
socket service clients and servers.
There are only two ways to have a program on a single processor do
"more than one thing at a time." Multi-threaded programming is the
simplest and most popular way to do it, but there is another very
different technique, that lets you have nearly all the advantages of
multi-threading, without actually using multiple threads. It's really
only practical if your program is largely I/O bound. If your program
is CPU bound, then pre-emptive scheduled threads are probably what you
really need. Network servers are rarely CPU-bound, however.
If your operating system supports the `select()' system call in its I/O
library (and nearly all do), then you can use it to juggle multiple
communication channels at once; doing other work while your I/O is
taking place in the "background." Although this strategy can seem
strange and complex, especially at first, it is in many ways easier to
understand and control than multi-threaded programming. The module
documented here solves many of the difficult problems for you, making
the task of building sophisticated high-performance network servers and
clients a snap.
`dispatcher()'
The first class we will introduce is the `dispatcher' class. This
is a thin wrapper around a low-level socket object. To make it
more useful, it has a few methods for event-handling on it.
Otherwise, it can be treated as a normal non-blocking socket
object.
The direct interface between the select loop and the socket object
are the `handle_read_event()' and `handle_write_event()' methods.
These are called whenever an object `fires' that event.
The firing of these low-level events can tell us whether certain
higher-level events have taken place, depending on the timing and
the state of the connection. For example, if we have asked for a
socket to connect to another host, we know that the connection has
been made when the socket fires a write event (at this point you
know that you may write to it with the expectation of success).
The implied higher-level events are:
Event Description
------ -----
handle_connect() Implied by a write event
handle_close() Implied by a read event with no
data available
handle_accept() Implied by a read event on a
listening socket
This set of user-level events is larger than the basics. The full set
of methods that can be overridden in your subclass are:
`handle_read()'
Called when there is new data to be read from a socket.
`handle_write()'
Called when there is an attempt to write data to the object.
Often this method will implement the necessary buffering for
performance. For example:
def handle_write(self):
sent = self.send(self.buffer)
self.buffer = self.buffer[sent:]
`handle_expt()'
Called when there is out of band (OOB) data for a socket
connection. This will almost never happen, as OOB is tenuously
supported and rarely used.
`handle_connect()'
Called when the socket actually makes a connection. This might be
used to send a "welcome" banner, or something similar.
`handle_close()'
Called when the socket is closed.
`handle_accept()'
Called on listening sockets when they actually accept a new
connection.
`readable()'
Each time through the `select()' loop, the set of sockets is
scanned, and this method is called to see if there is any interest
in reading. The default method simply returns `1', indicating
that by default, all channels will be interested.
`writable()'
Each time through the `select()' loop, the set of sockets is
scanned, and this method is called to see if there is any interest
in writing. The default method simply returns `1', indicating
that by default, all channels will be interested.
In addition, there are the basic methods needed to construct and
manipulate "channels," which are what we will call the socket
connections in this context. Note that most of these are nearly
identical to their socket partners.
`create_socket(family, type)'
This is identical to the creation of a normal socket, and will use
the same options for creation. Refer to the `socket'
documentation for information on creating sockets.
`connect(address)'
As with the normal socket object, ADDRESS is a tuple with the
first element the host to connect to, and the second the port.
`send(data)'
Send DATA out the socket.
`recv(buffer_size)'
Read at most BUFFER_SIZE bytes from the socket.
`listen(backlog)'
Listen for connections made to the socket. The BACKLOG argument
specifies the maximum number of queued connections and should be
at least 1; the maximum value is system-dependent (usually 5).
`bind(address)'
Bind the socket to ADDRESS. The socket must not already be bound.
(The format of ADDRESS depends on the address family -- see
above.)
`accept()'
Accept a connection. The socket must be bound to an address and
listening for connections. The return value is a pair `(CONN,
ADDRESS)' where CONN is a _new_ socket object usable to send and
receive data on the connection, and ADDRESS is the address bound
to the socket on the other end of the connection.
`close()'
Close the socket. All future operations on the socket object will
fail. The remote end will receive no more data (after queued data
is flushed). Sockets are automatically closed when they are
garbage-collected.
automatically generated by info2www version 1.2.2.9