home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2009 June / maximum-cd-2009-06.iso / DiscContents / digsby_setup.exe / lib / AsyncoreThread.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-02-26  |  10.2 KB  |  435 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from __future__ import with_statement
  5. import asyncore
  6. import errno
  7. import select
  8. import time
  9. import traceback
  10. import sys
  11. from select import error as select_error
  12. from Queue import Queue, Empty
  13. from sys import exc_clear
  14. from threading import RLock, currentThread
  15. from traceback import print_exc
  16. from asyncore import ExitNow
  17. from logging import getLogger
  18. log = getLogger('asyncore.thread')
  19. INTERRUPT_sentinel = 57005
  20. NO_SOCKET_SLEEP = 0.2
  21.  
  22. def read(obj):
  23.     
  24.     try:
  25.         obj.handle_read_event()
  26.     except ExitNow:
  27.         raise 
  28.     except Exception:
  29.         e = None
  30.         obj.handle_error(e)
  31.  
  32.  
  33.  
  34. def write(obj):
  35.     
  36.     try:
  37.         obj.handle_write_event()
  38.     except ExitNow:
  39.         raise 
  40.     except Exception:
  41.         e = None
  42.         obj.handle_error(e)
  43.  
  44.  
  45.  
  46. def exc(obj):
  47.     
  48.     try:
  49.         obj.handle_expt_event()
  50.     except ExitNow:
  51.         raise 
  52.     except Exception:
  53.         e = None
  54.         obj.handle_error(e)
  55.  
  56.  
  57.  
  58. def readwrite(obj, flags):
  59.     
  60.     try:
  61.         if flags & (select.POLLIN | select.POLLPRI):
  62.             obj.handle_read_event()
  63.         
  64.         if flags & select.POLLOUT:
  65.             obj.handle_write_event()
  66.         
  67.         if flags & (select.POLLERR | select.POLLHUP | select.POLLNVAL):
  68.             obj.handle_expt_event()
  69.     except ExitNow:
  70.         raise 
  71.     except Exception:
  72.         e = None
  73.         obj.handle_error(e)
  74.  
  75.  
  76.  
  77. def kpoll(timeout = 0, map = None, amap = asyncore.socket_map):
  78.     if map is None:
  79.         map = amap
  80.     
  81.     if map:
  82.         mapget = map.get
  83.         r = []
  84.         w = []
  85.         e = []
  86.         for fd, obj in map.items():
  87.             is_r = obj.readable()
  88.             is_w = obj.writable()
  89.             if is_r:
  90.                 r.append(fd)
  91.             
  92.             if is_w:
  93.                 w.append(fd)
  94.             
  95.             if is_r or is_w:
  96.                 e.append(fd)
  97.                 continue
  98.         
  99.         if r == r and w == w:
  100.             pass
  101.         elif w == e:
  102.             time.sleep(max(timeout, NO_SOCKET_SLEEP))
  103.             return None
  104.         
  105.         
  106.         try:
  107.             (r, w, e) = select.select(r, w, e, timeout)
  108.         except select_error:
  109.             []
  110.             err = []
  111.             if err[0] == errno.EINTR:
  112.                 return INTERRUPT_sentinel
  113.             elif err[0] == errno.ENOTSOCK:
  114.                 BAD = None
  115.                 for _list in (r, w, e):
  116.                     if BAD is not None:
  117.                         break
  118.                     
  119.                     for _fd in _list:
  120.                         
  121.                         try:
  122.                             real_fn = mapget(_fd).fileno()
  123.                             if real_fn != _fd:
  124.                                 raise Exception
  125.                         continue
  126.                         BAD = _fd
  127.                         break
  128.                         continue
  129.  
  130.                     
  131.                 
  132.                 del _fd
  133.                 del _list
  134.             None if BAD is None else None<EXCEPTION MATCH>KeyError
  135.             raise err
  136.         except:
  137.             r
  138.  
  139.         for fd in r:
  140.             obj = mapget(fd)
  141.             read(obj)
  142.         
  143.         for fd in w:
  144.             obj = mapget(fd)
  145.             if obj is None:
  146.                 continue
  147.             
  148.             write(obj)
  149.         
  150.         for fd in e:
  151.             obj = mapget(fd)
  152.             if obj is None:
  153.                 continue
  154.             
  155.             exc(obj)
  156.         
  157.         if r == []:
  158.             return True
  159.         
  160.     
  161.  
  162.  
  163. def callback_call(callable, callback):
  164.     
  165.     try:
  166.         callable()
  167.     except Exception:
  168.         e = None
  169.         print_exc()
  170.         
  171.         try:
  172.             callback.error(e)
  173.         print_exc()
  174.  
  175.  
  176.     
  177.     try:
  178.         callback.success()
  179.     except:
  180.         print_exc()
  181.  
  182.  
  183. import util.threads.bgthread as util
  184.  
  185. class AsyncoreThread(util.threads.bgthread.BackgroundThread):
  186.     
  187.     def __init__(self, timeout = 0.1, use_poll = 0, map = None):
  188.         self.flag = True
  189.         self.timeout = timeout
  190.         self.use_poll = use_poll
  191.         self.map = map
  192.         self.timeouts = { }
  193.         self.hooks = []
  194.         util.threads.bgthread.BackgroundThread.__init__(self, None, None, 'AsyncoreThread')
  195.  
  196.     
  197.     def run(self):
  198.         self.BeforeRun()
  199.         
  200.         try:
  201.             util.use_profiler(self, self.loop)
  202.         except:
  203.             traceback.print_exc()
  204.             raise 
  205.         finally:
  206.             self.AfterRun()
  207.  
  208.  
  209.     
  210.     def set_timeout(self, sock, secs):
  211.         self.timeouts[sock] = secs
  212.  
  213.     
  214.     def shortest_timeout(self):
  215.         if not self.timeouts.values():
  216.             pass
  217.         return min([
  218.             self.timeout])
  219.  
  220.     
  221.     def join(self, timeout = None):
  222.         self.flag = False
  223.         util.threads.bgthread.BackgroundThread.join(self, timeout)
  224.  
  225.     
  226.     def loop(self):
  227.         if self.map is None:
  228.             self.map = asyncore.socket_map
  229.         
  230.         last = 0
  231.         fastcount = 0
  232.         while self.flag:
  233.             now = time.clock()
  234.             if now - last < 0.1:
  235.                 fastcount += 1
  236.             else:
  237.                 fastcount = 0
  238.             last = now
  239.             if fastcount and not (fastcount % 5000):
  240.                 
  241.                 try:
  242.                     log.critical('Asyncorethread may be spinning, fastcount %r socket map is: %r', (fastcount, self.map))
  243.                 except Exception:
  244.                     
  245.                     try:
  246.                         log.critical('Asyncorethread may be spinning, failed to print socket map')
  247.                     except Exception:
  248.                         pass
  249.                     except:
  250.                         None<EXCEPTION MATCH>Exception
  251.                     
  252.  
  253.                     None<EXCEPTION MATCH>Exception
  254.                 
  255.  
  256.             None<EXCEPTION MATCH>Exception
  257.             setattr(self, 'loopcount', getattr(self, 'loopcount', 0) + 1)
  258.             
  259.             try:
  260.                 (tocall, callback) = to_call.get_nowait()
  261.             except Empty:
  262.                 e = None
  263.                 (tocall, callback) = (None, None)
  264.                 exc_clear()
  265.  
  266.             if tocall:
  267.                 callback_call(tocall, callback)
  268.             
  269.             empty = to_call.empty()
  270.             timeout = self.shortest_timeout() * empty
  271.             if self.map or not empty:
  272.                 
  273.                 try:
  274.                     kret = kpoll(timeout, self.map)
  275.                 except:
  276.                     print repr(self.map)
  277.                     raise 
  278.  
  279.                 if kret == INTERRUPT_sentinel:
  280.                     setattr(self, 'interrupt_count', getattr(self, 'interrupt_count', 0) + 1)
  281.                     if not self.interrupt_count % 5000:
  282.                         log.critical('interrupt count is high: %r', self.interrupt_count)
  283.                     
  284.                 else:
  285.                     setattr(self, 'interrupt_count', 0)
  286.             else:
  287.                 time.sleep(0.3)
  288.             exc_clear()
  289.         if self.map:
  290.             for sock in self.map.values():
  291.                 log.info('closing socket %r', sock)
  292.                 sock.close_when_done()
  293.             
  294.         
  295.         log.info('Asyncore Thread is done.')
  296.  
  297.     
  298.     def end(self):
  299.         log.info('stopping the network thread. obtaining lock...')
  300.         net_lock.__enter__()
  301.         
  302.         try:
  303.             log.info('Ending asyncore loop...')
  304.             self.flag = False
  305.             for sock in self.map.values():
  306.                 log.info('closing socket %r', sock)
  307.                 sock.close_when_done()
  308.         finally:
  309.             pass
  310.  
  311.  
  312.     
  313.     def force_exit(self):
  314.         net_lock.__enter__()
  315.         
  316.         try:
  317.             if self.map is None:
  318.                 return None
  319.             
  320.             for sock in self.map.values():
  321.                 
  322.                 try:
  323.                     peername = sock.getpeername()
  324.                 except:
  325.                     peername = None
  326.  
  327.                 log.critical('socket %s connected to %s', str(sock), peername)
  328.                 sock.close()
  329.             
  330.             self.map.clear()
  331.             self.map = None
  332.             self.flag = False
  333.             del self.hooks
  334.         finally:
  335.             pass
  336.  
  337.  
  338.     
  339.     def add_hook(self, cb):
  340.         self.hooks.append(cb)
  341.  
  342.  
  343. ref_count = 0
  344. net_thread = None
  345. net_lock = RLock()
  346. running = False
  347. to_call = Queue()
  348.  
  349. def __start():
  350.     global net_thread
  351.     
  352.     try:
  353.         net_thread
  354.     except NameError:
  355.         return None
  356.  
  357.     if not ref_count <= 1:
  358.         if net_thread:
  359.             pass
  360.         if not net_thread.isAlive():
  361.             net_thread = AsyncoreThread()
  362.             log.info('AsyncoreThread.start %s', ref_count)
  363.             net_thread.start()
  364.         
  365.  
  366.  
  367. def start():
  368.     global running, ref_count
  369.     running = True
  370.     net_lock.__enter__()
  371.     
  372.     try:
  373.         ref_count += 1
  374.         __start()
  375.     finally:
  376.         pass
  377.  
  378.  
  379.  
  380. def end():
  381.     log.critical('AsyncoreThread.end called!')
  382.     traceback.print_stack()
  383.  
  384.  
  385. def end_thread():
  386.     net_lock.__enter__()
  387.     
  388.     try:
  389.         log.info('AsyncoreThread.end %s', ref_count)
  390.         if net_thread:
  391.             net_thread.end()
  392.     finally:
  393.         pass
  394.  
  395.  
  396.  
  397. def timeout(sck, secs):
  398.     net_lock.__enter__()
  399.     
  400.     try:
  401.         net_thread.set_timeout(sck, secs)
  402.     finally:
  403.         pass
  404.  
  405.  
  406.  
  407. def join(timeout = 1.5):
  408.     global net_thread, call_later
  409.     if net_thread:
  410.         log.critical('Joining with network thread, timeout is %s...', timeout)
  411.         net_thread.join(timeout)
  412.         if net_thread.isAlive():
  413.             log.critical('  forcing critical exit.')
  414.             net_thread.force_exit()
  415.             net_thread.join()
  416.             del net_thread
  417.         
  418.         log.critical('...done joining.')
  419.         
  420.         call_later = lambda call, callback = None: (None, call() if callback else None)
  421.     
  422.  
  423.  
  424. def call_later(call, callback = None, callnow = True):
  425.     if not callable(call):
  426.         raise TypeError, 'argument must be callable'
  427.     
  428.     if callback is None:
  429.         import util.callbacks as util
  430.         callback = util.callbacks.EMPTY_CALLBACK
  431.     
  432.  
  433. import util.callbacks as util
  434. util.callbacks.register_call_later('AsyncoreThread', call_later)
  435.