Back to index

python3.2  3.2.2
Public Member Functions | Public Attributes | Static Public Attributes | Private Member Functions
asynchat.async_chat Class Reference
Inheritance diagram for asynchat.async_chat:
Inheritance graph
[legend]
Collaboration diagram for asynchat.async_chat:
Collaboration graph
[legend]

List of all members.

Public Member Functions

def __init__
def collect_incoming_data
def found_terminator
def set_terminator
def get_terminator
def handle_read
def handle_write
def handle_close
def push
def push_with_producer
def readable
def writable
def close_when_done
def initiate_send
def discard_buffers
def __repr__
def add_channel
def del_channel
def create_socket
def set_socket

Public Attributes

 ac_in_buffer
 incoming
 producer_fifo
 terminator
 socket
 family_and_type

Static Public Attributes

int ac_in_buffer_size = 4096
int ac_out_buffer_size = 4096
int use_encoding = 0
string encoding = 'latin1'
 debug = False
 connected = False
 accepting = False
 closing = False
 addr = None
tuple ignore_log_types = frozenset(['warning'])

Private Member Functions

def _collect_incoming_data
def _get_data

Detailed Description

This is an abstract class.  You must derive from this class, and add
the two methods collect_incoming_data() and found_terminator()

Definition at line 65 of file asynchat.py.


Constructor & Destructor Documentation

def asynchat.async_chat.__init__ (   self,
  sock = None,
  map = None 
)

Reimplemented from asyncore.dispatcher.

Reimplemented in test.test_ftplib.DummyTLS_DTPHandler, test.test_asynchat.echo_client, and test.test_ftplib.DummyDTPHandler.

Definition at line 80 of file asynchat.py.

00080 
00081     def __init__ (self, sock=None, map=None):
00082         # for string terminator matching
00083         self.ac_in_buffer = b''
00084 
00085         # we use a list here rather than cStringIO for a few reasons...
00086         # del lst[:] is faster than sio.truncate(0)
00087         # lst = [] is faster than sio.truncate(0)
00088         # cStringIO will be gaining unicode support in py3k, which
00089         # will negatively affect the performance of bytes compared to
00090         # a ''.join() equivalent
00091         self.incoming = []
00092 
00093         # we toss the use of the "simple producer" and replace it with
00094         # a pure deque, which the original fifo was a wrapping of
00095         self.producer_fifo = deque()
00096         asyncore.dispatcher.__init__ (self, sock, map)

Here is the caller graph for this function:


Member Function Documentation

def asyncore.dispatcher.__repr__ (   self) [inherited]

Definition at line 264 of file asyncore.py.

00264 
00265     def __repr__(self):
00266         status = [self.__class__.__module__+"."+self.__class__.__name__]
00267         if self.accepting and self.addr:
00268             status.append('listening')
00269         elif self.connected:
00270             status.append('connected')
00271         if self.addr is not None:
00272             try:
00273                 status.append('%s:%d' % self.addr)
00274             except TypeError:
00275                 status.append(repr(self.addr))
00276         return '<%s at %#x>' % (' '.join(status), id(self))

def asynchat.async_chat._collect_incoming_data (   self,
  data 
) [private]

Definition at line 100 of file asynchat.py.

00100 
00101     def _collect_incoming_data(self, data):
00102         self.incoming.append(data)

def asynchat.async_chat._get_data (   self) [private]

Definition at line 103 of file asynchat.py.

00103 
00104     def _get_data(self):
00105         d = b''.join(self.incoming)
00106         del self.incoming[:]
00107         return d

def asyncore.dispatcher.add_channel (   self,
  map = None 
) [inherited]

Definition at line 279 of file asyncore.py.

00279 
00280     def add_channel(self, map=None):
00281         #self.log_info('adding channel %s' % self)
00282         if map is None:
00283             map = self._map
00284         map[self._fileno] = self

Here is the caller graph for this function:

Definition at line 224 of file asynchat.py.

00224 
00225     def close_when_done (self):
00226         "automatically close this channel once the outgoing queue is empty"
00227         self.producer_fifo.append(None)

Here is the caller graph for this function:

def asynchat.async_chat.collect_incoming_data (   self,
  data 
)

Reimplemented in smtpd.SMTPChannel, test.test_asynchat.echo_client, test.test_ftplib.DummyFTPHandler, and test.test_poplib.DummyPOP3Handler.

Definition at line 97 of file asynchat.py.

00097 
00098     def collect_incoming_data(self, data):
00099         raise NotImplementedError("must be implemented in subclass")

Here is the caller graph for this function:

def asyncore.dispatcher.create_socket (   self,
  family,
  type 
) [inherited]

Definition at line 294 of file asyncore.py.

00294 
00295     def create_socket(self, family, type):
00296         self.family_and_type = family, type
00297         sock = socket.socket(family, type)
00298         sock.setblocking(0)
00299         self.set_socket(sock)

Here is the caller graph for this function:

def asyncore.dispatcher.del_channel (   self,
  map = None 
) [inherited]

Definition at line 285 of file asyncore.py.

00285 
00286     def del_channel(self, map=None):
00287         fd = self._fileno
00288         if map is None:
00289             map = self._map
00290         if fd in map:
00291             #self.log_info('closing channel %d:%s' % (fd, self))
00292             del map[fd]
00293         self._fileno = None

Here is the caller graph for this function:

Definition at line 270 of file asynchat.py.

00270 
00271     def discard_buffers (self):
00272         # Emergencies only!
00273         self.ac_in_buffer = b''
00274         del self.incoming[:]
00275         self.producer_fifo.clear()

Reimplemented in smtpd.SMTPChannel, test.test_asynchat.echo_client, test.test_ftplib.DummyFTPHandler, and test.test_poplib.DummyPOP3Handler.

Definition at line 108 of file asynchat.py.

00108 
00109     def found_terminator(self):
00110         raise NotImplementedError("must be implemented in subclass")

Here is the caller graph for this function:

Definition at line 117 of file asynchat.py.

00117 
00118     def get_terminator (self):
00119         return self.terminator

Here is the caller graph for this function:

Reimplemented in test.test_ftplib.DummyDTPHandler.

Definition at line 196 of file asynchat.py.

00196 
00197     def handle_close (self):
00198         self.close()

Here is the caller graph for this function:

Reimplemented in test.test_poplib.DummyPOP3_SSLHandler, and test.test_ftplib.DummyDTPHandler.

Definition at line 125 of file asynchat.py.

00125 
00126     def handle_read (self):
00127 
00128         try:
00129             data = self.recv (self.ac_in_buffer_size)
00130         except socket.error as why:
00131             self.handle_error()
00132             return
00133 
00134         if isinstance(data, str) and self.use_encoding:
00135             data = bytes(str, self.encoding)
00136         self.ac_in_buffer = self.ac_in_buffer + data
00137 
00138         # Continue to search for self.terminator in self.ac_in_buffer,
00139         # while calling self.collect_incoming_data.  The while loop
00140         # is necessary because we might read several data+terminator
00141         # combos with a single recv(4096).
00142 
00143         while self.ac_in_buffer:
00144             lb = len(self.ac_in_buffer)
00145             terminator = self.get_terminator()
00146             if not terminator:
00147                 # no terminator, collect it all
00148                 self.collect_incoming_data (self.ac_in_buffer)
00149                 self.ac_in_buffer = b''
00150             elif isinstance(terminator, int):
00151                 # numeric terminator
00152                 n = terminator
00153                 if lb < n:
00154                     self.collect_incoming_data (self.ac_in_buffer)
00155                     self.ac_in_buffer = b''
00156                     self.terminator = self.terminator - lb
00157                 else:
00158                     self.collect_incoming_data (self.ac_in_buffer[:n])
00159                     self.ac_in_buffer = self.ac_in_buffer[n:]
00160                     self.terminator = 0
00161                     self.found_terminator()
00162             else:
00163                 # 3 cases:
00164                 # 1) end of buffer matches terminator exactly:
00165                 #    collect data, transition
00166                 # 2) end of buffer matches some prefix:
00167                 #    collect data to the prefix
00168                 # 3) end of buffer does not match any prefix:
00169                 #    collect data
00170                 terminator_len = len(terminator)
00171                 index = self.ac_in_buffer.find(terminator)
00172                 if index != -1:
00173                     # we found the terminator
00174                     if index > 0:
00175                         # don't bother reporting the empty string (source of subtle bugs)
00176                         self.collect_incoming_data (self.ac_in_buffer[:index])
00177                     self.ac_in_buffer = self.ac_in_buffer[index+terminator_len:]
00178                     # This does the Right Thing if the terminator is changed here.
00179                     self.found_terminator()
00180                 else:
00181                     # check for a prefix of the terminator
00182                     index = find_prefix_at_end (self.ac_in_buffer, terminator)
00183                     if index:
00184                         if index != lb:
00185                             # we found a prefix, collect up to the prefix
00186                             self.collect_incoming_data (self.ac_in_buffer[:-index])
00187                             self.ac_in_buffer = self.ac_in_buffer[-index:]
00188                         break
00189                     else:
00190                         # no prefix, collect it all
00191                         self.collect_incoming_data (self.ac_in_buffer)
00192                         self.ac_in_buffer = b''

Here is the call graph for this function:

Definition at line 193 of file asynchat.py.

00193 
00194     def handle_write (self):
00195         self.initiate_send()

Here is the call graph for this function:

Definition at line 228 of file asynchat.py.

00228 
00229     def initiate_send(self):
00230         while self.producer_fifo and self.connected:
00231             first = self.producer_fifo[0]
00232             # handle empty string/buffer or None entry
00233             if not first:
00234                 del self.producer_fifo[0]
00235                 if first is None:
00236                     ## print("first is None")
00237                     self.handle_close()
00238                     return
00239                 ## print("first is not None")
00240 
00241             # handle classic producer behavior
00242             obs = self.ac_out_buffer_size
00243             try:
00244                 data = buffer(first, 0, obs)
00245             except TypeError:
00246                 data = first.more()
00247                 if data:
00248                     self.producer_fifo.appendleft(data)
00249                 else:
00250                     del self.producer_fifo[0]
00251                 continue
00252 
00253             if isinstance(data, str) and self.use_encoding:
00254                 data = bytes(data, self.encoding)
00255 
00256             # send the data
00257             try:
00258                 num_sent = self.send(data)
00259             except socket.error:
00260                 self.handle_error()
00261                 return
00262 
00263             if num_sent:
00264                 if num_sent < len(data) or obs < len(first):
00265                     self.producer_fifo[0] = first[num_sent:]
00266                 else:
00267                     del self.producer_fifo[0]
00268             # we tried to send some actual data
00269             return

Here is the call graph for this function:

Here is the caller graph for this function:

def asynchat.async_chat.push (   self,
  data 
)

Reimplemented in smtpd.SMTPChannel, test.test_ftplib.DummyFTPHandler, test.test_poplib.DummyPOP3Handler, and test.test_ftplib.DummyDTPHandler.

Definition at line 199 of file asynchat.py.

00199 
00200     def push (self, data):
00201         sabs = self.ac_out_buffer_size
00202         if len(data) > sabs:
00203             for i in range(0, len(data), sabs):
00204                 self.producer_fifo.append(data[i:i+sabs])
00205         else:
00206             self.producer_fifo.append(data)
00207         self.initiate_send()

Here is the call graph for this function:

def asynchat.async_chat.push_with_producer (   self,
  producer 
)

Definition at line 208 of file asynchat.py.

00208 
00209     def push_with_producer (self, producer):
00210         self.producer_fifo.append(producer)
00211         self.initiate_send()

Here is the call graph for this function:

Definition at line 212 of file asynchat.py.

00212 
00213     def readable (self):
00214         "predicate for inclusion in the readable for select()"
00215         # cannot use the old predicate, it violates the claim of the
00216         # set_terminator method.
00217 
00218         # return (len(self.ac_in_buffer) <= self.ac_in_buffer_size)
00219         return 1

def asyncore.dispatcher.set_socket (   self,
  sock,
  map = None 
) [inherited]

Definition at line 300 of file asyncore.py.

00300 
00301     def set_socket(self, sock, map=None):
        self.socket = sock

Here is the call graph for this function:

Here is the caller graph for this function:

def asynchat.async_chat.set_terminator (   self,
  term 
)

Definition at line 111 of file asynchat.py.

00111 
00112     def set_terminator (self, term):
00113         "Set the input delimiter.  Can be a fixed string of any length, an integer, or None"
00114         if isinstance(term, str) and self.use_encoding:
00115             term = bytes(term, self.encoding)
00116         self.terminator = term

Here is the caller graph for this function:

Definition at line 220 of file asynchat.py.

00220 
00221     def writable (self):
00222         "predicate for inclusion in the writable for select()"
00223         return self.producer_fifo or (not self.connected)


Member Data Documentation

Definition at line 82 of file asynchat.py.

Definition at line 71 of file asynchat.py.

Definition at line 72 of file asynchat.py.

asyncore.dispatcher.accepting = False [static, inherited]

Definition at line 227 of file asyncore.py.

asyncore.dispatcher.addr = None [static, inherited]

Reimplemented in smtpd.SMTPChannel.

Definition at line 229 of file asyncore.py.

asyncore.dispatcher.closing = False [static, inherited]

Definition at line 228 of file asyncore.py.

asyncore.dispatcher.connected = False [static, inherited]

Reimplemented in asyncore.file_dispatcher.

Definition at line 226 of file asyncore.py.

asyncore.dispatcher.debug = False [static, inherited]

Definition at line 225 of file asyncore.py.

string asynchat.async_chat.encoding = 'latin1' [static]

Definition at line 78 of file asynchat.py.

Definition at line 295 of file asyncore.py.

tuple asyncore.dispatcher.ignore_log_types = frozenset(['warning']) [static, inherited]

Definition at line 230 of file asyncore.py.

Definition at line 90 of file asynchat.py.

Definition at line 94 of file asynchat.py.

Definition at line 115 of file asynchat.py.

Definition at line 77 of file asynchat.py.


The documentation for this class was generated from the following file: