Back to index

python3.2  3.2.2
Public Member Functions | Public Attributes | Static Public Attributes
test.test_ftplib.DummyFTPHandler Class Reference
Inheritance diagram for test.test_ftplib.DummyFTPHandler:
Inheritance graph
[legend]
Collaboration diagram for test.test_ftplib.DummyFTPHandler:
Collaboration graph
[legend]

List of all members.

Public Member Functions

def __init__
def collect_incoming_data
def found_terminator
def handle_error
def push
def cmd_port
def cmd_pasv
def cmd_eprt
def cmd_epsv
def cmd_echo
def cmd_noop
def cmd_user
def cmd_pass
def cmd_acct
def cmd_rnfr
def cmd_rnto
def cmd_dele
def cmd_cwd
def cmd_size
def cmd_mkd
def cmd_rmd
def cmd_pwd
def cmd_type
def cmd_quit
def cmd_abor
def cmd_stor
def cmd_rest
def cmd_retr
def cmd_list
def cmd_nlst
def set_terminator
def get_terminator
def handle_read
def handle_write
def handle_close
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

 in_buffer
 dtp
 last_received_cmd
 last_received_data
 next_response
 rest
 ac_in_buffer
 incoming
 producer_fifo
 terminator
 socket
 family_and_type

Static Public Attributes

 dtp_handler = DummyDTPHandler
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'])

Detailed Description

Definition at line 58 of file test_ftplib.py.


Constructor & Destructor Documentation

def test.test_ftplib.DummyFTPHandler.__init__ (   self,
  conn 
)

Reimplemented in test.test_ftplib.DummyTLS_FTPHandler.

Definition at line 62 of file test_ftplib.py.

00062 
00063     def __init__(self, conn):
00064         asynchat.async_chat.__init__(self, conn)
00065         # tells the socket to handle urgent data inline (ABOR command)
00066         self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_OOBINLINE, 1)
00067         self.set_terminator(b"\r\n")
00068         self.in_buffer = []
00069         self.dtp = None
00070         self.last_received_cmd = None
00071         self.last_received_data = ''
00072         self.next_response = ''
00073         self.rest = None
00074         self.push('220 welcome')

Here is the call graph for this function:

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 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:

def asynchat.async_chat.close_when_done (   self) [inherited]

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 test.test_ftplib.DummyFTPHandler.cmd_abor (   self,
  arg 
)

Definition at line 186 of file test_ftplib.py.

00186 
00187     def cmd_abor(self, arg):
00188         self.push('226 abor ok')

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_acct (   self,
  arg 
)

Definition at line 152 of file test_ftplib.py.

00152 
00153     def cmd_acct(self, arg):
00154         self.push('230 acct ok')

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_cwd (   self,
  arg 
)

Definition at line 164 of file test_ftplib.py.

00164 
00165     def cmd_cwd(self, arg):
00166         self.push('250 cwd ok')

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_dele (   self,
  arg 
)

Definition at line 161 of file test_ftplib.py.

00161 
00162     def cmd_dele(self, arg):
00163         self.push('250 dele ok')

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_echo (   self,
  arg 
)

Definition at line 139 of file test_ftplib.py.

00139 
00140     def cmd_echo(self, arg):
00141         # sends back the received string (used by the test suite)
00142         self.push(arg)

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_eprt (   self,
  arg 
)

Definition at line 122 of file test_ftplib.py.

00122 
00123     def cmd_eprt(self, arg):
00124         af, ip, port = arg.split(arg[0])[1:-1]
00125         port = int(port)
00126         s = socket.create_connection((ip, port), timeout=10)
00127         self.dtp = self.dtp_handler(s, baseclass=self)
00128         self.push('200 active data connection established')

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_epsv (   self,
  arg 
)

Definition at line 129 of file test_ftplib.py.

00129 
00130     def cmd_epsv(self, arg):
00131         with socket.socket(socket.AF_INET6) as sock:
00132             sock.bind((self.socket.getsockname()[0], 0))
00133             sock.listen(5)
00134             sock.settimeout(10)
00135             port = sock.getsockname()[1]
00136             self.push('229 entering extended passive mode (|||%d|)' %port)
00137             conn, addr = sock.accept()
00138             self.dtp = self.dtp_handler(conn, baseclass=self)

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_list (   self,
  arg 
)

Definition at line 206 of file test_ftplib.py.

00206 
00207     def cmd_list(self, arg):
00208         self.push('125 list ok')
00209         self.dtp.push(LIST_DATA)
00210         self.dtp.close_when_done()

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_mkd (   self,
  arg 
)

Definition at line 170 of file test_ftplib.py.

00170 
00171     def cmd_mkd(self, arg):
00172         self.push('257 "%s"' %arg)

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_nlst (   self,
  arg 
)

Definition at line 211 of file test_ftplib.py.

00211 
00212     def cmd_nlst(self, arg):
00213         self.push('125 nlst ok')
00214         self.dtp.push(NLST_DATA)
00215         self.dtp.close_when_done()
00216 

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_noop (   self,
  arg 
)

Definition at line 143 of file test_ftplib.py.

00143 
00144     def cmd_noop(self, arg):
00145         self.push('200 noop ok')

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_pass (   self,
  arg 
)

Definition at line 149 of file test_ftplib.py.

00149 
00150     def cmd_pass(self, arg):
00151         self.push('230 password ok')

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_pasv (   self,
  arg 
)

Definition at line 111 of file test_ftplib.py.

00111 
00112     def cmd_pasv(self, arg):
00113         with socket.socket() as sock:
00114             sock.bind((self.socket.getsockname()[0], 0))
00115             sock.listen(5)
00116             sock.settimeout(10)
00117             ip, port = sock.getsockname()[:2]
00118             ip = ip.replace('.', ','); p1 = port / 256; p2 = port % 256
00119             self.push('227 entering passive mode (%s,%d,%d)' %(ip, p1, p2))
00120             conn, addr = sock.accept()
00121             self.dtp = self.dtp_handler(conn, baseclass=self)

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_port (   self,
  arg 
)

Definition at line 103 of file test_ftplib.py.

00103 
00104     def cmd_port(self, arg):
00105         addr = list(map(int, arg.split(',')))
00106         ip = '%d.%d.%d.%d' %tuple(addr[:4])
00107         port = (addr[4] * 256) + addr[5]
00108         s = socket.create_connection((ip, port), timeout=10)
00109         self.dtp = self.dtp_handler(s, baseclass=self)
00110         self.push('200 active data connection established')

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_pwd (   self,
  arg 
)

Definition at line 176 of file test_ftplib.py.

00176 
00177     def cmd_pwd(self, arg):
00178         self.push('257 "pwd ok"')

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_quit (   self,
  arg 
)

Definition at line 182 of file test_ftplib.py.

00182 
00183     def cmd_quit(self, arg):
00184         self.push('221 quit ok')
00185         self.close()

def test.test_ftplib.DummyFTPHandler.cmd_rest (   self,
  arg 
)

Definition at line 192 of file test_ftplib.py.

00192 
00193     def cmd_rest(self, arg):
00194         self.rest = arg
00195         self.push('350 rest ok')

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_retr (   self,
  arg 
)

Definition at line 196 of file test_ftplib.py.

00196 
00197     def cmd_retr(self, arg):
00198         self.push('125 retr ok')
00199         if self.rest is not None:
00200             offset = int(self.rest)
00201         else:
00202             offset = 0
00203         self.dtp.push(RETR_DATA[offset:])
00204         self.dtp.close_when_done()
00205         self.rest = None

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_rmd (   self,
  arg 
)

Definition at line 173 of file test_ftplib.py.

00173 
00174     def cmd_rmd(self, arg):
00175         self.push('250 rmd ok')

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_rnfr (   self,
  arg 
)

Definition at line 155 of file test_ftplib.py.

00155 
00156     def cmd_rnfr(self, arg):
00157         self.push('350 rnfr ok')

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_rnto (   self,
  arg 
)

Definition at line 158 of file test_ftplib.py.

00158 
00159     def cmd_rnto(self, arg):
00160         self.push('250 rnto ok')

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_size (   self,
  arg 
)

Definition at line 167 of file test_ftplib.py.

00167 
00168     def cmd_size(self, arg):
00169         self.push('250 1000')

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_stor (   self,
  arg 
)

Definition at line 189 of file test_ftplib.py.

00189 
00190     def cmd_stor(self, arg):
00191         self.push('125 stor ok')

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_type (   self,
  arg 
)

Definition at line 179 of file test_ftplib.py.

00179 
00180     def cmd_type(self, arg):
00181         self.push('200 type ok')

Here is the call graph for this function:

def test.test_ftplib.DummyFTPHandler.cmd_user (   self,
  arg 
)

Definition at line 146 of file test_ftplib.py.

00146 
00147     def cmd_user(self, arg):
00148         self.push('331 username ok')

Here is the call graph for this function:

Reimplemented from asynchat.async_chat.

Definition at line 75 of file test_ftplib.py.

00075 
00076     def collect_incoming_data(self, data):
00077         self.in_buffer.append(data)

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:

def asynchat.async_chat.discard_buffers (   self) [inherited]

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 from asynchat.async_chat.

Definition at line 78 of file test_ftplib.py.

00078 
00079     def found_terminator(self):
00080         line = b''.join(self.in_buffer).decode('ascii')
00081         self.in_buffer = []
00082         if self.next_response:
00083             self.push(self.next_response)
00084             self.next_response = ''
00085         cmd = line.split(' ')[0].lower()
00086         self.last_received_cmd = cmd
00087         space = line.find(' ')
00088         if space != -1:
00089             arg = line[space + 1:]
00090         else:
00091             arg = ""
00092         if hasattr(self, 'cmd_' + cmd):
00093             method = getattr(self, 'cmd_' + cmd)
00094             method(arg)
00095         else:
00096             self.push('550 command "%s" not understood.' %cmd)

Here is the call graph for this function:

def asynchat.async_chat.get_terminator (   self) [inherited]

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:

def asynchat.async_chat.handle_close (   self) [inherited]

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:

Definition at line 97 of file test_ftplib.py.

00097 
00098     def handle_error(self):
00099         raise

Here is the caller graph for this function:

def asynchat.async_chat.handle_read (   self) [inherited]

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:

def asynchat.async_chat.handle_write (   self) [inherited]

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:

def asynchat.async_chat.initiate_send (   self) [inherited]

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 test.test_ftplib.DummyFTPHandler.push (   self,
  data 
)

Reimplemented from asynchat.async_chat.

Definition at line 100 of file test_ftplib.py.

00100 
00101     def push(self, data):
00102         asynchat.async_chat.push(self, data.encode('ascii') + b'\r\n')

Here is the call graph for this function:

def asynchat.async_chat.push_with_producer (   self,
  producer 
) [inherited]

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:

def asynchat.async_chat.readable (   self) [inherited]

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 
) [inherited]

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:

def asynchat.async_chat.writable (   self) [inherited]

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.

int asynchat.async_chat.ac_in_buffer_size = 4096 [static, inherited]

Definition at line 71 of file asynchat.py.

int asynchat.async_chat.ac_out_buffer_size = 4096 [static, inherited]

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.

Definition at line 68 of file test_ftplib.py.

Reimplemented in test.test_ftplib.DummyTLS_FTPHandler.

Definition at line 60 of file test_ftplib.py.

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

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 67 of file test_ftplib.py.

Definition at line 90 of file asynchat.py.

Definition at line 69 of file test_ftplib.py.

Definition at line 70 of file test_ftplib.py.

Definition at line 71 of file test_ftplib.py.

Definition at line 94 of file asynchat.py.

Definition at line 72 of file test_ftplib.py.

Definition at line 115 of file asynchat.py.

int asynchat.async_chat.use_encoding = 0 [static, inherited]

Definition at line 77 of file asynchat.py.


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