home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2009 June / maximum-cd-2009-06.iso / DiscContents / digsby_setup.exe / lib / asyncore.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-02-26  |  13.7 KB  |  559 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import select
  5. import socket
  6. import sys
  7. import time
  8. import os
  9. from errno import EALREADY, EINPROGRESS, EWOULDBLOCK, ECONNRESET, ENOTCONN, ESHUTDOWN, EINTR, EISCONN, errorcode
  10.  
  11. try:
  12.     socket_map
  13. except NameError:
  14.     socket_map = { }
  15.  
  16.  
  17. class ExitNow(Exception):
  18.     pass
  19.  
  20.  
  21. def read(obj):
  22.     
  23.     try:
  24.         obj.handle_read_event()
  25.     except ExitNow:
  26.         raise 
  27.     except:
  28.         obj.handle_error()
  29.  
  30.  
  31.  
  32. def write(obj):
  33.     
  34.     try:
  35.         obj.handle_write_event()
  36.     except ExitNow:
  37.         raise 
  38.     except:
  39.         obj.handle_error()
  40.  
  41.  
  42.  
  43. def _exception(obj):
  44.     
  45.     try:
  46.         obj.handle_expt_event()
  47.     except ExitNow:
  48.         raise 
  49.     except:
  50.         obj.handle_error()
  51.  
  52.  
  53.  
  54. def readwrite(obj, flags):
  55.     
  56.     try:
  57.         if flags & (select.POLLIN | select.POLLPRI):
  58.             obj.handle_read_event()
  59.         
  60.         if flags & select.POLLOUT:
  61.             obj.handle_write_event()
  62.         
  63.         if flags & (select.POLLERR | select.POLLHUP | select.POLLNVAL):
  64.             obj.handle_expt_event()
  65.     except ExitNow:
  66.         raise 
  67.     except:
  68.         obj.handle_error()
  69.  
  70.  
  71.  
  72. def poll(timeout = 0, map = None):
  73.     if map is None:
  74.         map = socket_map
  75.     
  76.     if map:
  77.         r = []
  78.         w = []
  79.         e = []
  80.         for fd, obj in map.items():
  81.             is_r = obj.readable()
  82.             is_w = obj.writable()
  83.             if is_r:
  84.                 r.append(fd)
  85.             
  86.             if is_w:
  87.                 w.append(fd)
  88.             
  89.             if is_r or is_w:
  90.                 e.append(fd)
  91.                 continue
  92.         
  93.         if r == r and w == w:
  94.             pass
  95.         elif w == e:
  96.             time.sleep(timeout)
  97.         else:
  98.             
  99.             try:
  100.                 (r, w, e) = select.select(r, w, e, timeout)
  101.             except select.error:
  102.                 []
  103.                 err = []
  104.                 if err[0] != EINTR:
  105.                     raise 
  106.                 else:
  107.                     return None
  108.             except:
  109.                 err[0] != EINTR
  110.  
  111.         for fd in r:
  112.             obj = map.get(fd)
  113.             read(obj)
  114.         
  115.         for fd in w:
  116.             obj = map.get(fd)
  117.             if obj is None:
  118.                 continue
  119.             
  120.             write(obj)
  121.         
  122.         for fd in e:
  123.             obj = map.get(fd)
  124.             if obj is None:
  125.                 continue
  126.             
  127.             _exception(obj)
  128.         
  129.     
  130.  
  131.  
  132. def poll2(timeout = 0, map = None):
  133.     if map is None:
  134.         map = socket_map
  135.     
  136.     if timeout is not None:
  137.         timeout = int(timeout * 1000)
  138.     
  139.     pollster = select.poll()
  140.     if map:
  141.         for fd, obj in map.items():
  142.             flags = 0
  143.             if obj.readable():
  144.                 flags |= select.POLLIN | select.POLLPRI
  145.             
  146.             if obj.writable():
  147.                 flags |= select.POLLOUT
  148.             
  149.             if flags:
  150.                 flags |= select.POLLERR | select.POLLHUP | select.POLLNVAL
  151.                 pollster.register(fd, flags)
  152.                 continue
  153.         
  154.         
  155.         try:
  156.             r = pollster.poll(timeout)
  157.         except select.error:
  158.             err = None
  159.             if err[0] != EINTR:
  160.                 raise 
  161.             
  162.             r = []
  163.  
  164.         for fd, flags in r:
  165.             obj = map.get(fd)
  166.             if obj is None:
  167.                 continue
  168.             
  169.             readwrite(obj, flags)
  170.         
  171.     
  172.  
  173. poll3 = poll2
  174.  
  175. def loop(timeout = 30, use_poll = False, map = None, count = None):
  176.     if map is None:
  177.         map = socket_map
  178.     
  179.     if use_poll and hasattr(select, 'poll'):
  180.         poll_fun = poll2
  181.     else:
  182.         poll_fun = poll
  183.     if count is None:
  184.         while map:
  185.             poll_fun(timeout, map)
  186.     else:
  187.         while map and count > 0:
  188.             poll_fun(timeout, map)
  189.             count = count - 1
  190.  
  191.  
  192. class dispatcher:
  193.     debug = False
  194.     connected = False
  195.     accepting = False
  196.     closing = False
  197.     addr = None
  198.     
  199.     def __init__(self, sock = None, map = None):
  200.         if map is None:
  201.             self._map = socket_map
  202.         else:
  203.             self._map = map
  204.         if sock:
  205.             self.set_socket(sock, map)
  206.             self.socket.setblocking(0)
  207.             self.connected = True
  208.             
  209.             try:
  210.                 self.addr = sock.getpeername()
  211.             except socket.error:
  212.                 pass
  213.             except:
  214.                 None<EXCEPTION MATCH>socket.error
  215.             
  216.  
  217.         None<EXCEPTION MATCH>socket.error
  218.         self.socket = None
  219.  
  220.     
  221.     def __repr__(self):
  222.         status = [
  223.             self.__class__.__module__ + '.' + self.__class__.__name__]
  224.         if self.accepting and self.addr:
  225.             status.append('listening')
  226.         elif self.connected:
  227.             status.append('connected')
  228.         
  229.         if self.addr is not None:
  230.             
  231.             try:
  232.                 status.append('%s:%d' % self.addr)
  233.             except TypeError:
  234.                 status.append(repr(self.addr))
  235.             except:
  236.                 None<EXCEPTION MATCH>TypeError
  237.             
  238.  
  239.         None<EXCEPTION MATCH>TypeError
  240.         return '<%s at %#x>' % (' '.join(status), id(self))
  241.  
  242.     
  243.     def add_channel(self, map = None):
  244.         if map is None:
  245.             map = self._map
  246.         
  247.         map[self._fileno] = self
  248.  
  249.     
  250.     def del_channel(self, map = None):
  251.         fd = self._fileno
  252.         if map is None:
  253.             map = self._map
  254.         
  255.         if map.has_key(fd):
  256.             del map[fd]
  257.         
  258.         self._fileno = None
  259.  
  260.     
  261.     def create_socket(self, family, type):
  262.         self.family_and_type = (family, type)
  263.         self.socket = socket.socket(family, type)
  264.         self.socket.setblocking(0)
  265.         self._fileno = self.socket.fileno()
  266.         self.add_channel()
  267.  
  268.     
  269.     def set_socket(self, sock, map = None):
  270.         self.socket = sock
  271.         self._fileno = sock.fileno()
  272.         self.add_channel(map)
  273.  
  274.     
  275.     def set_reuse_addr(self):
  276.         
  277.         try:
  278.             self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) | 1)
  279.         except socket.error:
  280.             pass
  281.  
  282.  
  283.     
  284.     def readable(self):
  285.         return True
  286.  
  287.     
  288.     def writable(self):
  289.         return True
  290.  
  291.     
  292.     def listen(self, num):
  293.         self.accepting = True
  294.         if os.name == 'nt' and num > 5:
  295.             num = 1
  296.         
  297.         return self.socket.listen(num)
  298.  
  299.     
  300.     def bind(self, addr):
  301.         self.addr = addr
  302.         return self.socket.bind(addr)
  303.  
  304.     
  305.     def connect(self, address):
  306.         self.connected = False
  307.         err = self.socket.connect_ex(address)
  308.         if err in (EINPROGRESS, EALREADY, EWOULDBLOCK):
  309.             return None
  310.         
  311.         if err in (0, EISCONN):
  312.             self.addr = address
  313.             self.connected = True
  314.             self.handle_connect()
  315.         else:
  316.             raise socket.error, (err, errorcode[err])
  317.  
  318.     
  319.     def accept(self):
  320.         
  321.         try:
  322.             (conn, addr) = self.socket.accept()
  323.             return (conn, addr)
  324.         except socket.error:
  325.             why = None
  326.             if why[0] == EWOULDBLOCK:
  327.                 pass
  328.             else:
  329.                 raise 
  330.         except:
  331.             why[0] == EWOULDBLOCK
  332.  
  333.  
  334.     
  335.     def send(self, data):
  336.         
  337.         try:
  338.             result = self.socket.send(data)
  339.             return result
  340.         except socket.error:
  341.             why = None
  342.             if why[0] == EWOULDBLOCK:
  343.                 return 0
  344.             else:
  345.                 raise 
  346.             return 0
  347.  
  348.  
  349.     
  350.     def recv(self, buffer_size):
  351.         
  352.         try:
  353.             data = self.socket.recv(buffer_size)
  354.             if not data:
  355.                 self.handle_close()
  356.                 return ''
  357.             else:
  358.                 return data
  359.         except socket.error:
  360.             why = None
  361.             if why[0] in [
  362.                 ECONNRESET,
  363.                 ENOTCONN,
  364.                 ESHUTDOWN]:
  365.                 self.handle_close()
  366.                 return ''
  367.             else:
  368.                 raise 
  369.         except:
  370.             why[0] in [
  371.                 ECONNRESET,
  372.                 ENOTCONN,
  373.                 ESHUTDOWN]
  374.  
  375.  
  376.     
  377.     def close(self):
  378.         self.del_channel()
  379.         self.socket.close()
  380.  
  381.     
  382.     def __getattr__(self, attr):
  383.         return getattr(self.socket, attr)
  384.  
  385.     
  386.     def log(self, message):
  387.         sys.stderr.write('log: %s\n' % str(message))
  388.  
  389.     
  390.     def log_info(self, message, type = 'info'):
  391.         if __debug__ or type != 'info':
  392.             print '%s: %s' % (type, message)
  393.         
  394.  
  395.     
  396.     def handle_read_event(self):
  397.         if self.accepting:
  398.             if not self.connected:
  399.                 self.connected = True
  400.             
  401.             self.handle_accept()
  402.         elif not self.connected:
  403.             self.handle_connect()
  404.             self.connected = True
  405.             self.handle_read()
  406.         else:
  407.             self.handle_read()
  408.  
  409.     
  410.     def handle_write_event(self):
  411.         if not self.connected:
  412.             self.handle_connect()
  413.             self.connected = True
  414.         
  415.         self.handle_write()
  416.  
  417.     
  418.     def handle_expt_event(self):
  419.         self.handle_expt()
  420.  
  421.     
  422.     def handle_error(self):
  423.         (nil, t, v, tbinfo) = compact_traceback()
  424.         
  425.         try:
  426.             self_repr = repr(self)
  427.         except:
  428.             self_repr = '<__repr__(self) failed for object at %0x>' % id(self)
  429.  
  430.         self.log_info('uncaptured python exception, closing channel %s (%s:%s %s)' % (self_repr, t, v, tbinfo), 'error')
  431.         self.close()
  432.  
  433.     
  434.     def handle_expt(self):
  435.         self.log_info('unhandled exception', 'warning')
  436.  
  437.     
  438.     def handle_read(self):
  439.         self.log_info('unhandled read event', 'warning')
  440.  
  441.     
  442.     def handle_write(self):
  443.         self.log_info('unhandled write event', 'warning')
  444.  
  445.     
  446.     def handle_connect(self):
  447.         self.log_info('unhandled connect event', 'warning')
  448.  
  449.     
  450.     def handle_accept(self):
  451.         self.log_info('unhandled accept event', 'warning')
  452.  
  453.     
  454.     def handle_close(self):
  455.         self.log_info('unhandled close event', 'warning')
  456.         self.close()
  457.  
  458.  
  459.  
  460. class dispatcher_with_send(dispatcher):
  461.     
  462.     def __init__(self, sock = None, map = None):
  463.         dispatcher.__init__(self, sock, map)
  464.         self.out_buffer = ''
  465.  
  466.     
  467.     def initiate_send(self):
  468.         num_sent = 0
  469.         num_sent = dispatcher.send(self, self.out_buffer[:512])
  470.         self.out_buffer = self.out_buffer[num_sent:]
  471.  
  472.     
  473.     def handle_write(self):
  474.         self.initiate_send()
  475.  
  476.     
  477.     def writable(self):
  478.         if not not (self.connected):
  479.             pass
  480.         return len(self.out_buffer)
  481.  
  482.     
  483.     def send(self, data):
  484.         if self.debug:
  485.             self.log_info('sending %s' % repr(data))
  486.         
  487.         self.out_buffer = self.out_buffer + data
  488.         self.initiate_send()
  489.  
  490.  
  491.  
  492. def compact_traceback():
  493.     (t, v, tb) = sys.exc_info()
  494.     tbinfo = []
  495.     while tb:
  496.         tbinfo.append((tb.tb_frame.f_code.co_filename, tb.tb_frame.f_code.co_name, str(tb.tb_lineno)))
  497.         tb = tb.tb_next
  498.     del tb
  499.     (file, function, line) = tbinfo[-1]
  500.     info = []([ '[%s|%s|%s]' % x for x in tbinfo ])
  501.     return ((file, function, line), t, v, info)
  502.  
  503.  
  504. def close_all(map = None):
  505.     if map is None:
  506.         map = socket_map
  507.     
  508.     for x in map.values():
  509.         x.socket.close()
  510.     
  511.     map.clear()
  512.  
  513. if os.name == 'posix':
  514.     import fcntl
  515.     
  516.     class file_wrapper:
  517.         
  518.         def __init__(self, fd):
  519.             self.fd = fd
  520.  
  521.         
  522.         def recv(self, *args):
  523.             return os.read(self.fd, *args)
  524.  
  525.         
  526.         def send(self, *args):
  527.             return os.write(self.fd, *args)
  528.  
  529.         read = recv
  530.         write = send
  531.         
  532.         def close(self):
  533.             os.close(self.fd)
  534.  
  535.         
  536.         def fileno(self):
  537.             return self.fd
  538.  
  539.  
  540.     
  541.     class file_dispatcher(dispatcher):
  542.         
  543.         def __init__(self, fd, map = None):
  544.             dispatcher.__init__(self, None, map)
  545.             self.connected = True
  546.             self.set_file(fd)
  547.             flags = fcntl.fcntl(fd, fcntl.F_GETFL, 0)
  548.             flags = flags | os.O_NONBLOCK
  549.             fcntl.fcntl(fd, fcntl.F_SETFL, flags)
  550.  
  551.         
  552.         def set_file(self, fd):
  553.             self._fileno = fd
  554.             self.socket = file_wrapper(fd)
  555.             self.add_channel()
  556.  
  557.  
  558.  
  559.