home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / AsyncoreThread.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  10.0 KB  |  474 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  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, do_log = False):
  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.         try:
  106.             _r = r
  107.             _w = w
  108.             _e = e
  109.             (r, w, e) = select.select(r, w, e, timeout)
  110.         except select_error:
  111.             err = None
  112.             if err[0] == errno.EINTR:
  113.                 return INTERRUPT_sentinel
  114.             if err[0] == errno.ENOTSOCK:
  115.                 BAD = None
  116.                 for _list in (r, w, e):
  117.                     if BAD is not None:
  118.                         break
  119.                     
  120.                     for _fd in _list:
  121.                         
  122.                         try:
  123.                             real_fn = mapget(_fd).fileno()
  124.                             if real_fn != _fd:
  125.                                 raise Exception
  126.                             real_fn != _fd
  127.                         continue
  128.                         BAD = _fd
  129.                         break
  130.                         continue
  131.  
  132.                     
  133.                 
  134.                 del _fd
  135.                 del _list
  136.                 if BAD is None:
  137.                     raise err
  138.                 BAD is None
  139.                 bad_obj = mapget(BAD)
  140.                 log.fatal('Removing the following item from the socket map because it is not a socket: %r', bad_obj)
  141.                 
  142.                 try:
  143.                     del map[BAD]
  144.                 except KeyError:
  145.                     pass
  146.  
  147.                 for _list in (r, w, e):
  148.                     if BAD in _list:
  149.                         _list.remove(BAD)
  150.                         continue
  151.                 
  152.                 del _list
  153.             else:
  154.                 raise err
  155.             err[0] == errno.ENOTSOCK
  156.  
  157.         if do_log:
  158.             log.critical('_r, _w, _e = %r, %r, %r', _r, _w, _e)
  159.             log.critical('r, w, e = %r, %r, %r', r, w, e)
  160.         
  161.         for fd in r:
  162.             obj = mapget(fd)
  163.             if obj is None:
  164.                 continue
  165.             
  166.             read(obj)
  167.         
  168.         for fd in w:
  169.             obj = mapget(fd)
  170.             if obj is None:
  171.                 continue
  172.             
  173.             write(obj)
  174.         
  175.         for fd in e:
  176.             obj = mapget(fd)
  177.             if obj is None:
  178.                 continue
  179.             
  180.             exc(obj)
  181.         
  182.         if r == []:
  183.             return True
  184.     
  185.  
  186.  
  187. def callback_call(callable, callback):
  188.     
  189.     try:
  190.         callable()
  191.     except Exception:
  192.         e = None
  193.         print_exc()
  194.         
  195.         try:
  196.             callback.error(e)
  197.         print_exc()
  198.  
  199.  
  200.     
  201.     try:
  202.         callback.success()
  203.     except:
  204.         print_exc()
  205.  
  206.  
  207. import util.threads.bgthread as util
  208.  
  209. class AsyncoreThread(util.threads.bgthread.BackgroundThread):
  210.     
  211.     def __init__(self, timeout = 0.1, use_poll = 0, map = None):
  212.         self.flag = True
  213.         self.timeout = timeout
  214.         self.use_poll = use_poll
  215.         self.map = map
  216.         self.timeouts = { }
  217.         self.hooks = []
  218.         util.threads.bgthread.BackgroundThread.__init__(self, None, None, 'AsyncoreThread')
  219.  
  220.     
  221.     def run(self):
  222.         self.BeforeRun()
  223.         
  224.         try:
  225.             util.use_profiler(self, self.loop)
  226.         except:
  227.             traceback.print_exc()
  228.             raise 
  229.         finally:
  230.             self.AfterRun()
  231.  
  232.  
  233.     
  234.     def join(self, timeout = None):
  235.         self.flag = False
  236.         util.threads.bgthread.BackgroundThread.join(self, timeout)
  237.  
  238.     
  239.     def loop(self):
  240.         if self.map is None:
  241.             self.map = asyncore.socket_map
  242.         
  243.         last = 0
  244.         fastcount = 0
  245.         while self.flag:
  246.             now = time.clock()
  247.             if now - last < 0.1:
  248.                 fastcount += 1
  249.             else:
  250.                 fastcount = 0
  251.             last = now
  252.             if not getattr(self, 'loopcount', 0) % 5000:
  253.                 log.debug('Asyncorethread socket map is: %r', self.map)
  254.             
  255.             do_log = False
  256.             if fastcount and not (fastcount % 5000):
  257.                 
  258.                 try:
  259.                     log.critical('Asyncorethread may be spinning, fastcount %r socket map is: %r', fastcount, self.map)
  260.                 except Exception:
  261.                     
  262.                     try:
  263.                         log.critical('Asyncorethread may be spinning, failed to print socket map')
  264.                     except Exception:
  265.                         pass
  266.                     except:
  267.                         None<EXCEPTION MATCH>Exception
  268.                     
  269.  
  270.                     None<EXCEPTION MATCH>Exception
  271.  
  272.                 do_log = True
  273.             
  274.             setattr(self, 'loopcount', getattr(self, 'loopcount', 0) + 1)
  275.             
  276.             try:
  277.                 (tocall, callback) = to_call.get_nowait()
  278.             except Empty:
  279.                 e = None
  280.                 (tocall, callback) = (None, None)
  281.                 exc_clear()
  282.  
  283.             if tocall:
  284.                 callback_call(tocall, callback)
  285.             
  286.             empty = to_call.empty()
  287.             timeout = self.timeout * empty
  288.             if self.map or not empty:
  289.                 
  290.                 try:
  291.                     kret = kpoll(timeout, self.map, do_log = do_log)
  292.                 except:
  293.                     print repr(self.map)
  294.                     raise 
  295.  
  296.                 if kret == INTERRUPT_sentinel:
  297.                     setattr(self, 'interrupt_count', getattr(self, 'interrupt_count', 0) + 1)
  298.                     if not self.interrupt_count % 5000:
  299.                         log.critical('interrupt count is high: %r', self.interrupt_count)
  300.                     
  301.                 else:
  302.                     setattr(self, 'interrupt_count', 0)
  303.             else:
  304.                 time.sleep(0.3)
  305.             exc_clear()
  306.         if self.map:
  307.             for sock in self.map.values():
  308.                 log.info('closing socket %r', sock)
  309.                 sock.close_when_done()
  310.             
  311.         
  312.         log.info('Asyncore Thread is done.')
  313.  
  314.     
  315.     def end(self):
  316.         log.info('stopping the network thread. obtaining lock...')
  317.         net_lock.__enter__()
  318.         
  319.         try:
  320.             log.info('Ending asyncore loop...')
  321.             self.flag = False
  322.             for sock in self.map.values():
  323.                 log.info('closing socket %r', sock)
  324.                 sock.close_when_done()
  325.         finally:
  326.             pass
  327.  
  328.  
  329.     
  330.     def force_exit(self):
  331.         net_lock.__enter__()
  332.         
  333.         try:
  334.             if self.map is None:
  335.                 return None
  336.             for sock in self.map.values():
  337.                 
  338.                 try:
  339.                     peername = sock.getpeername()
  340.                 except:
  341.                     self.map is None
  342.                     net_lock.__exit__
  343.                     net_lock
  344.                     peername = None
  345.  
  346.                 log.critical('socket %s connected to %s', str(sock), peername)
  347.                 sock.close()
  348.             
  349.             self.map.clear()
  350.             self.map = None
  351.             self.flag = False
  352.             del self.hooks
  353.         finally:
  354.             pass
  355.  
  356.  
  357.     
  358.     def add_hook(self, cb):
  359.         self.hooks.append(cb)
  360.  
  361.  
  362. ref_count = 0
  363. net_thread = None
  364. net_lock = RLock()
  365. running = False
  366. to_call = Queue()
  367.  
  368. def __start():
  369.     global net_thread
  370.     
  371.     try:
  372.         net_thread
  373.     except NameError:
  374.         return None
  375.  
  376.     if not ref_count <= 1:
  377.         if net_thread:
  378.             pass
  379.         if not net_thread.isAlive():
  380.             net_thread = AsyncoreThread()
  381.             log.info('AsyncoreThread.start %s', ref_count)
  382.             net_thread.start()
  383.         
  384.  
  385.  
  386. def start():
  387.     global running, ref_count
  388.     running = True
  389.     net_lock.__enter__()
  390.     
  391.     try:
  392.         ref_count += 1
  393.         __start()
  394.     finally:
  395.         pass
  396.  
  397.  
  398.  
  399. def end():
  400.     log.critical('AsyncoreThread.end called!')
  401.     traceback.print_stack()
  402.  
  403.  
  404. def end_thread():
  405.     net_lock.__enter__()
  406.     
  407.     try:
  408.         log.info('AsyncoreThread.end %s', ref_count)
  409.         if net_thread:
  410.             net_thread.end()
  411.     finally:
  412.         pass
  413.  
  414.  
  415.  
  416. def join(timeout = 1.5):
  417.     global net_thread, call_later
  418.     if net_thread:
  419.         log.critical('Joining with network thread, timeout is %s...', timeout)
  420.         net_thread.join(timeout)
  421.         if net_thread.isAlive():
  422.             log.critical('  forcing critical exit.')
  423.             net_thread.force_exit()
  424.             net_thread.join()
  425.             del net_thread
  426.         
  427.         log.critical('...done joining.')
  428.         
  429.         call_later = lambda call, callback = None: (None, call() if callback else None)
  430.     
  431.  
  432.  
  433. def call_later(call, callback = None, callnow = True, verbose = True):
  434.     if not callable(call):
  435.         raise TypeError, 'argument must be callable'
  436.     callable(call)
  437.     if callback is None:
  438.         import util.callbacks as util
  439.         callback = util.callbacks.EMPTY_CALLBACK
  440.     
  441.     if callnow or currentThread().getName() == 'AsyncoreThread' or 'net_thread' not in globals():
  442.         import util
  443.         
  444.         try:
  445.             call()
  446.         except Exception:
  447.             e = None
  448.             if verbose:
  449.                 traceback.print_exc()
  450.             
  451.             util.traceguard.__enter__()
  452.             
  453.             try:
  454.                 callback.error(e)
  455.             finally:
  456.                 pass
  457.  
  458.         except:
  459.             util.traceguard.__exit__
  460.  
  461.         util.traceguard.__enter__()
  462.         
  463.         try:
  464.             callback.success()
  465.         finally:
  466.             pass
  467.  
  468.         return None
  469.     to_call.put((call, callback))
  470.     start()
  471.  
  472. import util.callbacks as util
  473. util.callbacks.register_call_later('AsyncoreThread', call_later)
  474.