Vega strike Python Modules doc  0.5.1
Documentation of the " Modules " folder of Vega strike
 All Data Structures Namespaces Files Functions Variables
Data Structures | Functions | Variables
asyncore Namespace Reference

Data Structures

class  ExitNow
 
class  dispatcher
 
class  dispatcher_with_send
 
class  file_wrapper
 
class  file_dispatcher
 

Functions

def poll
 
def poll2
 
def poll3
 
def loop
 
def set_reuse_addr
 self.__dict__['socket'] = sock More...
 
def readable
 
def writable
 
def listen
 
def bind
 
def connect
 
def accept
 
def send
 
def recv
 
def close
 
def __getattr__
 
def log
 
def log_info
 
def handle_read_event
 
def handle_write_event
 
def handle_expt_event
 
def handle_error
 
def handle_expt
 
def handle_read
 
def handle_write
 
def handle_connect
 
def handle_accept
 
def handle_close
 
def compact_traceback
 
def close_all
 

Variables

dictionary socket_map = {}
 
int DEBUG = 0
 
 accepting
 
 addr
 
 connected
 

Function Documentation

def asyncore.__getattr__ (   self,
  attr 
)

Definition at line 366 of file asyncore.py.

366 
367  def __getattr__ (self, attr):
368  return getattr (self.socket, attr)
def asyncore.accept (   self)

Definition at line 321 of file asyncore.py.

321 
322  def accept (self):
323  try:
324  conn, addr = self.socket.accept()
325  return conn, addr
326  except socket.error, why:
327  if why[0] == EWOULDBLOCK:
328  pass
329  else:
330  raise socket.error, why
def asyncore.bind (   self,
  addr 
)

Definition at line 305 of file asyncore.py.

305 
306  def bind (self, addr):
307  self.addr = addr
308  return self.socket.bind (addr)
def asyncore.close (   self)

Definition at line 360 of file asyncore.py.

360 
361  def close (self):
362  self.del_channel()
363  self.socket.close()
def asyncore.close_all (   map = None)

Definition at line 494 of file asyncore.py.

494 
495 def close_all (map=None):
496  if map is None:
497  map=socket_map
498  for x in map.values():
499  x.socket.close()
500  map.clear()
501 
502 # Asynchronous File I/O:
503 #
504 # After a little research (reading man pages on various unixen, and
505 # digging through the linux kernel), I've determined that select()
506 # isn't meant for doing doing asynchronous file i/o.
507 # Heartening, though - reading linux/mm/filemap.c shows that linux
508 # supports asynchronous read-ahead. So _MOST_ of the time, the data
509 # will be sitting in memory for us already when we go to read it.
510 #
511 # What other OS's (besides NT) support async file i/o? [VMS?]
512 #
513 # Regardless, this is useful for pipes, and stdin/stdout...
def asyncore.compact_traceback ( )

Definition at line 474 of file asyncore.py.

References dospath.join(), and locale.str().

474 
475 def compact_traceback ():
476  t,v,tb = sys.exc_info()
477  tbinfo = []
478  while 1:
479  tbinfo.append ((
480  tb.tb_frame.f_code.co_filename,
481  tb.tb_frame.f_code.co_name,
482  str(tb.tb_lineno)
483  ))
484  tb = tb.tb_next
485  if not tb:
486  break
487 
488  # just to be safe
489  del tb
490 
491  file, function, line = tbinfo[-1]
492  info = '[' + '] ['.join(map(lambda x: '|'.join(x), tbinfo)) + ']'
493  return (file, function, line), t, v, info
def asyncore.connect (   self,
  address 
)

Definition at line 309 of file asyncore.py.

309 
310  def connect (self, address):
311  self.connected = 0
312  err = self.socket.connect_ex(address)
313  if err in (EINPROGRESS, EALREADY, EWOULDBLOCK):
314  return
315  if err in (0, EISCONN):
316  self.addr = address
317  self.connected = 1
318  self.handle_connect()
319  else:
320  raise socket.error, err
def asyncore.handle_accept (   self)

Definition at line 436 of file asyncore.py.

436 
437  def handle_accept (self):
438  self.log_info ('unhandled accept event', 'warning')
def asyncore.handle_close (   self)

Definition at line 439 of file asyncore.py.

439 
440  def handle_close (self):
441  self.log_info ('unhandled close event', 'warning')
442  self.close()
443 
444 # ---------------------------------------------------------------------------
445 # adds simple buffered output capability, useful for simple clients.
446 # [for more sophisticated usage use asynchat.async_chat]
447 # ---------------------------------------------------------------------------
def asyncore.handle_connect (   self)

Definition at line 433 of file asyncore.py.

433 
434  def handle_connect (self):
435  self.log_info ('unhandled connect event', 'warning')
def asyncore.handle_error (   self)

Definition at line 404 of file asyncore.py.

References compact_traceback().

404 
405  def handle_error (self):
406  nil, t, v, tbinfo = compact_traceback()
407 
408  # sometimes a user repr method will crash.
409  try:
410  self_repr = repr (self)
411  except:
412  self_repr = '<__repr__ (self) failed for object at %0x>' % id(self)
413 
414  self.log_info (
415  'uncaptured python exception, closing channel %s (%s:%s %s)' % (
416  self_repr,
417  t,
418  v,
419  tbinfo
420  ),
421  'error'
422  )
423  self.close()
def asyncore.handle_expt (   self)

Definition at line 424 of file asyncore.py.

424 
425  def handle_expt (self):
426  self.log_info ('unhandled exception', 'warning')
def asyncore.handle_expt_event (   self)

Definition at line 401 of file asyncore.py.

401 
402  def handle_expt_event (self):
403  self.handle_expt()
def asyncore.handle_read (   self)

Definition at line 427 of file asyncore.py.

427 
428  def handle_read (self):
429  self.log_info ('unhandled read event', 'warning')
def asyncore.handle_read_event (   self)

Definition at line 380 of file asyncore.py.

380 
381  def handle_read_event (self):
382  if self.accepting:
383  # for an accepting socket, getting a read implies
384  # that we are connected
385  if not self.connected:
386  self.connected = 1
387  self.handle_accept()
388  elif not self.connected:
389  self.handle_connect()
390  self.connected = 1
391  self.handle_read()
392  else:
393  self.handle_read()
def asyncore.handle_write (   self)

Definition at line 430 of file asyncore.py.

430 
431  def handle_write (self):
432  self.log_info ('unhandled write event', 'warning')
def asyncore.handle_write_event (   self)

Definition at line 394 of file asyncore.py.

394 
395  def handle_write_event (self):
396  # getting a write implies that we are connected
397  if not self.connected:
398  self.handle_connect()
399  self.connected = 1
400  self.handle_write()
def asyncore.listen (   self,
  num 
)

Definition at line 299 of file asyncore.py.

299 
300  def listen (self, num):
301  self.accepting = 1
302  if os.name == 'nt' and num > 5:
303  num = 1
304  return self.socket.listen (num)
def asyncore.log (   self,
  message 
)

Definition at line 373 of file asyncore.py.

References locale.str().

373 
374  def log (self, message):
375  sys.stderr.write ('log: %s\n' % str(message))
def asyncore.log_info (   self,
  message,
  type = 'info' 
)

Definition at line 376 of file asyncore.py.

376 
377  def log_info (self, message, type='info'):
378  if __debug__ or type != 'info':
379  print '%s: %s' % (type, message)
def asyncore.loop (   timeout = 30.0,
  use_poll = 0,
  map = None 
)

Definition at line 187 of file asyncore.py.

187 
188 def loop (timeout=30.0, use_poll=0, map=None):
189 
190  if map is None:
191  map=socket_map
192 
193  if use_poll:
194  if hasattr (select, 'poll'):
195  poll_fun = poll3
196  else:
197  poll_fun = poll2
198  else:
199  poll_fun = poll
200 
201  while map:
202  poll_fun (timeout, map)
def asyncore.poll (   timeout = 0.0,
  map = None 
)

Definition at line 68 of file asyncore.py.

68 
69 def poll (timeout=0.0, map=None):
70  if map is None:
71  map = socket_map
72  if map:
73  r = []; w = []; e = []
74  for fd, obj in map.items():
75  if obj.readable():
76  r.append (fd)
77  if obj.writable():
78  w.append (fd)
79  try:
80  r,w,e = select.select (r,w,e, timeout)
81  except select.error, err:
82  if err[0] != EINTR:
83  raise
84  r = []; w = []; e = []
85 
86  if DEBUG:
87  print r,w,e
88 
89  for fd in r:
90  try:
91  obj = map[fd]
92  except KeyError:
93  continue
94 
95  try:
96  obj.handle_read_event()
97  except ExitNow:
98  raise ExitNow
99  except:
100  obj.handle_error()
101 
102  for fd in w:
103  try:
104  obj = map[fd]
105  except KeyError:
106  continue
107 
108  try:
109  obj.handle_write_event()
110  except ExitNow:
111  raise ExitNow
112  except:
113  obj.handle_error()
def asyncore.poll2 (   timeout = 0.0,
  map = None 
)

Definition at line 114 of file asyncore.py.

114 
115 def poll2 (timeout=0.0, map=None):
116  import poll
117  if map is None:
118  map=socket_map
119  if timeout is not None:
120  # timeout is in milliseconds
121  timeout = int(timeout*1000)
122  if map:
123  l = []
124  for fd, obj in map.items():
125  flags = 0
126  if obj.readable():
127  flags = poll.POLLIN
128  if obj.writable():
129  flags = flags | poll.POLLOUT
130  if flags:
131  l.append ((fd, flags))
132  r = poll.poll (l, timeout)
133  for fd, flags in r:
134  try:
135  obj = map[fd]
136  except KeyError:
137  continue
138 
139  try:
140  if (flags & poll.POLLIN):
141  obj.handle_read_event()
142  if (flags & poll.POLLOUT):
143  obj.handle_write_event()
144  except ExitNow:
145  raise ExitNow
146  except:
147  obj.handle_error()
def asyncore.poll3 (   timeout = 0.0,
  map = None 
)

Definition at line 148 of file asyncore.py.

148 
149 def poll3 (timeout=0.0, map=None):
150  # Use the poll() support added to the select module in Python 2.0
151  if map is None:
152  map=socket_map
153  if timeout is not None:
154  # timeout is in milliseconds
155  timeout = int(timeout*1000)
156  pollster = select.poll()
157  if map:
158  for fd, obj in map.items():
159  flags = 0
160  if obj.readable():
161  flags = select.POLLIN
162  if obj.writable():
163  flags = flags | select.POLLOUT
164  if flags:
165  pollster.register(fd, flags)
166  try:
167  r = pollster.poll (timeout)
168  except select.error, err:
169  if err[0] != EINTR:
170  raise
171  r = []
172  for fd, flags in r:
173  try:
174  obj = map[fd]
175  except KeyError:
176  continue
177 
178  try:
179  if (flags & select.POLLIN):
180  obj.handle_read_event()
181  if (flags & select.POLLOUT):
182  obj.handle_write_event()
183  except ExitNow:
184  raise ExitNow
185  except:
186  obj.handle_error()
def asyncore.readable (   self)

Definition at line 283 of file asyncore.py.

283 
284  def readable (self):
285  return 1
def asyncore.recv (   self,
  buffer_size 
)

Definition at line 342 of file asyncore.py.

342 
343  def recv (self, buffer_size):
344  try:
345  data = self.socket.recv (buffer_size)
346  if not data:
347  # a closed connection is indicated by signaling
348  # a read condition, and having recv() return 0.
349  self.handle_close()
350  return ''
351  else:
352  return data
353  except socket.error, why:
354  # winsock sometimes throws ENOTCONN
355  if why[0] in [ECONNRESET, ENOTCONN, ESHUTDOWN]:
356  self.handle_close()
357  return ''
358  else:
359  raise socket.error, why
def asyncore.send (   self,
  data 
)

Definition at line 331 of file asyncore.py.

331 
332  def send (self, data):
333  try:
334  result = self.socket.send (data)
335  return result
336  except socket.error, why:
337  if why[0] == EWOULDBLOCK:
338  return 0
339  else:
340  raise socket.error, why
341  return 0
def asyncore.set_reuse_addr (   self)

self.__dict__['socket'] = sock

Definition at line 266 of file asyncore.py.

266 
267  def set_reuse_addr (self):
268  # try to re-use a server port if possible
269  try:
270  self.socket.setsockopt (
271  socket.SOL_SOCKET, socket.SO_REUSEADDR,
272  self.socket.getsockopt (socket.SOL_SOCKET,
273  socket.SO_REUSEADDR) | 1
274  )
275  except socket.error:
276  pass
def writable (   self)

Definition at line 289 of file asyncore.py.

289 
290  def writable (self):
return not self.accepting

Variable Documentation

accepting

Definition at line 300 of file asyncore.py.

addr

Definition at line 306 of file asyncore.py.

connected

Definition at line 310 of file asyncore.py.

int DEBUG = 0

Definition at line 66 of file asyncore.py.

dictionary socket_map = {}

Definition at line 61 of file asyncore.py.