home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / fnb101.zip / Lib / site-packages / Fnorb / orb / SelectReactor.py < prev    next >
Text File  |  1999-06-28  |  8KB  |  294 lines
  1. #!/usr/bin/env python
  2. #############################################################################
  3. # Copyright (C) DSTC Pty Ltd (ACN 052 372 577) 1997, 1998, 1999
  4. # All Rights Reserved.
  5. #
  6. # The software contained on this media is the property of the DSTC Pty
  7. # Ltd.  Use of this software is strictly in accordance with the
  8. # license agreement in the accompanying LICENSE.HTML file.  If your
  9. # distribution of this software does not contain a LICENSE.HTML file
  10. # then you have no rights to use this software in any manner and
  11. # should contact DSTC at the address below to determine an appropriate
  12. # licensing arrangement.
  13. # 
  14. #      DSTC Pty Ltd
  15. #      Level 7, GP South
  16. #      Staff House Road
  17. #      University of Queensland
  18. #      St Lucia, 4072
  19. #      Australia
  20. #      Tel: +61 7 3365 4310
  21. #      Fax: +61 7 3365 4311
  22. #      Email: enquiries@dstc.edu.au
  23. # 
  24. # This software is being provided "AS IS" without warranty of any
  25. # kind.  In no event shall DSTC Pty Ltd be liable for damage of any
  26. # kind arising out of or in connection with the use or performance of
  27. # this software.
  28. #
  29. # Project:      Fnorb
  30. # File:         $Source: /units/arch/src/Fnorb/orb/RCS/SelectReactor.py,v $
  31. # Version:      @(#)$RCSfile: SelectReactor.py,v $ $Revision: 1.18 $
  32. #
  33. #############################################################################
  34. """ A simple 'select' Reactor. """
  35.  
  36.  
  37. # Standard/built-in modules.
  38. import select
  39.  
  40. # Fnorb modules.
  41. import Reactor
  42.  
  43.  
  44. def SelectReactor_init():
  45.     """ Initialise the SelectReactor.
  46.  
  47.     There can only be one instance of any concrete reactor class per process.
  48.  
  49.     """
  50.     try:
  51.     reactor = SelectReactor()
  52.  
  53.     except Reactor.Reactor, reactor:
  54.     pass
  55.  
  56.     return reactor
  57.  
  58.  
  59. class SelectReactor(Reactor.Reactor):
  60.     """ The SelectReactor.
  61.  
  62.     This reactor uses a standard 'select' event loop.
  63.  
  64.     """
  65.     def __init__(self):
  66.     """ Constructor. """
  67.  
  68.     # There can be at most one instance of any concrete reactor class per
  69.     # process
  70.     if Reactor.Reactor._instance is not None:
  71.         # A reactor already exists.
  72.         raise Reactor.Reactor._instance
  73.  
  74.     Reactor.Reactor._instance = self
  75.  
  76.     # A dictionary of all registered event handlers. All handles in the
  77.     # SelectReactor are actually just file descriptors.
  78.     self.__handlers = {} # {Handle: (EventHandler, Mask)}
  79.  
  80.     return
  81.  
  82.     #########################################################################
  83.     # Reactor interface.
  84.     #########################################################################
  85.  
  86.     def register_handler(self, handler, mask):
  87.     """ Register an event handler. """
  88.  
  89.     # Get the event handler's underlying I/O handle.
  90.     handle = handler.handle()
  91.  
  92.     # If the handler is already registered then update the mask.
  93.     try:
  94.         # Find the event handler associated with the handle.
  95.         (handler, handler_mask) = self.__handlers[handle]
  96.  
  97.         # Update the mask.
  98.         handler_mask = handler_mask | mask
  99.  
  100.     # Otherwise, add the new handler.
  101.     except KeyError:
  102.         handler_mask = mask
  103.  
  104.     # Do the add/update.
  105.     self.__handlers[handle] = (handler, handler_mask)
  106.  
  107.     return
  108.  
  109.     def unregister_handler(self, handler, mask):
  110.     """ Withdraw a handler's registration. """
  111.  
  112.     # Get the event handler's underlying I/O handle.
  113.     handle = handler.handle()
  114.  
  115.     try:
  116.         # Find the event handler associated with the handle.
  117.         (handler, handler_mask) = self.__handlers[handle]
  118.  
  119.         # Update the mask.
  120.         handler_mask = handler_mask & ~mask
  121.  
  122.         # If the mask is now zero (ie. the handler is no longer interested
  123.         # in *any* events), then delete the handler.
  124.         if handler_mask == 0:
  125.         del self.__handlers[handle]
  126.  
  127.         # Otherwise, just update the handler's mask.
  128.         else:
  129.         self.__handlers[handle] = (handler, handler_mask)
  130.  
  131.     # Ignore any attempts to un-register a handler that wasn't registerd!
  132.     except KeyError:
  133.         pass
  134.  
  135.     return
  136.  
  137.     def start_event_loop(self, timeout=None):
  138.     """ Start the event loop. """
  139.  
  140.     self.__is_alive = 1
  141.     while self.__is_alive:
  142.         # Wait for and process a single event.
  143.         self.do_one_event(timeout)
  144.  
  145.     # Close all registered handlers.
  146.     self.__close_all_handlers()
  147.         
  148.     return
  149.  
  150.     def stop_event_loop(self):
  151.     """ Stop the event loop. """
  152.  
  153.     # This variable is checked before each call to 'do_one_event'.
  154.     self.__is_alive = 0
  155.  
  156.     return
  157.  
  158.     def do_one_event(self, timeout=None):
  159.     """ Dispatch a single event. """
  160.  
  161.     # Get the read/write/exception handles for all registered handlers.
  162.     (iwtd, owtd, ewtd) = self.__get_handles()
  163.  
  164.     # Blocking select (with timeout if specified).
  165.     if timeout is None:
  166.         (iwtd, owtd, ewtd) = select.select(iwtd, owtd, ewtd)
  167.         
  168.     else:
  169.         (iwtd, owtd, ewtd) = select.select(iwtd, owtd, ewtd, timeout)
  170.  
  171.     # Set up a 'try' block to catch 'KeyError' exceptions (sometimes
  172.     # handlers may remove themselves before we get to process them e.g
  173.     # if a handler has both a read and a write event then the processing
  174.     # of the read event could call 'unregister_handler' before the
  175.     # write event is processed).
  176.     try:
  177.         # Read events.
  178.         if len(iwtd) > 0:
  179.         for handle in iwtd:
  180.             # Find the event handler associated with the handle.
  181.             (handler, mask) = self.__handlers[handle]
  182.             
  183.             # Handler callback.
  184.             handler.handle_event(Reactor.READ)
  185.  
  186.         # Write events.
  187.         if len(owtd) > 0:
  188.         for handle in owtd:
  189.             # Find the event handler associated with the handle.
  190.             (handler, mask) = self.__handlers[handle]
  191.  
  192.             # Handler callback.
  193.             handler.handle_event(Reactor.WRITE)
  194.  
  195.         # Exceptional events.
  196.         if len(ewtd) > 0:
  197.         for handle in ewtd:
  198.             # Find the event handler associated with the handle.
  199.             (handler, mask) = self.__handlers[handle]
  200.  
  201.             # Handler callback.
  202.             handler.handle_event(Reactor.EXCEPTION)
  203.  
  204.     except KeyError:
  205.         pass
  206.  
  207.     return
  208.  
  209.     # The following two methods are provided to allow Fnorb events to be
  210.     # handled in other event loops.
  211.     def handles(self):
  212.     """ Return the read/write/exception handles for registered handlers.
  213.  
  214.     The return value is a tuple in the form:-
  215.  
  216.     ([ReadHandles], [WriteHandles], [ExceptionHandles])
  217.  
  218.     """
  219.     return self.__get_handles()
  220.  
  221.     def handle_one_event(self, handle, mask):
  222.     """ Handle a single event. """
  223.  
  224.     # Read event.
  225.     if mask & Reactor.READ:
  226.         # Find the event handler associated with the handle.
  227.         (handler, handler_mask) = self.__handlers[handle]
  228.         
  229.         # Handler callback.
  230.         handler.handle_event(Reactor.READ)
  231.  
  232.     # Write event.
  233.     if mask & Reactor.WRITE:
  234.         # Find the event handler associated with the handle.
  235.         (handler, handler_mask) = self.__handlers[handle]
  236.  
  237.         # Handler callback.
  238.         handler.handle_event(Reactor.WRITE)
  239.  
  240.     # Exception event.
  241.     if mask & Reactor.EXCEPTION:
  242.         # Find the event handler associated with the handle.
  243.         (handler, handler_mask) = self.__handlers[handle]
  244.  
  245.         # Handler callback.
  246.         handler.handle_event(Reactor.EXCEPTION)
  247.  
  248.     return
  249.  
  250.     #########################################################################
  251.     # Private interface.
  252.     #########################################################################
  253.  
  254.     def __get_handles(self):
  255.     """ Return the read/write/exception handles for registered handlers.
  256.  
  257.     The return value is a tuple in the form:-
  258.  
  259.     ([ReadHandles], [WriteHandles], [ExceptionHandles])
  260.  
  261.     """
  262.     iwtd = {}
  263.     owtd = {}
  264.     ewtd = {}
  265.  
  266.     for handle in self.__handlers.keys():
  267.         # Find the event handler associated with the handle.
  268.         (handler, mask) = self.__handlers[handle]
  269.  
  270.         if mask & Reactor.READ:
  271.         iwtd[handle] = None
  272.  
  273.         if mask & Reactor.WRITE:
  274.         owtd[handle] = None
  275.  
  276.         # Listen for errors on all handles.
  277.         ewtd[handle] = None
  278.  
  279.     return (iwtd.keys(), owtd.keys(), ewtd.keys())
  280.  
  281.     def __close_all_handlers(self):
  282.     """ Close all registered handlers. """
  283.  
  284.     # We work on a copy of the list, 'cos the handlers will most likely
  285.     # call 'unregister_handler' in their 'close' method which can cause
  286.     # them to be deleted from the handler dictionary, 'self.__handlers'.
  287.     for (handler, mask) in self.__handlers.values():
  288.         # Handler callback.
  289.         handler.handle_close()
  290.  
  291.     return
  292.  
  293. #############################################################################
  294.