home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / fnb101.zip / Lib / site-packages / Fnorb / orb / GIOPServerWorkerReactive.py < prev    next >
Text File  |  1999-06-28  |  7KB  |  239 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/GIOPServerWorkerReactive.py,v $
  31. # Version:      @(#)$RCSfile: GIOPServerWorkerReactive.py,v $ $Revision: 1.5 $
  32. #
  33. #############################################################################
  34. """ GIOPServerWorkerReactive class. """
  35.  
  36.  
  37. # Fnorb modules.
  38. import CORBA, EventHandler, GIOPServerWorker, GIOPConnectionHandler, Reactor
  39.  
  40.  
  41. class GIOPServerWorkerReactive(GIOPServerWorker.GIOPServerWorker,
  42.                    EventHandler.EventHandler):
  43.     """ GIOPServerWorkerReactive class.
  44.  
  45.     A concrete 'EventHandler' in the 'Reactor' pattern.
  46.  
  47.     This class is *not* thread safe, but since the whole point of the 'Reactor'
  48.     pattern is to work in a single-threaded environment, I don't see this as
  49.     much of a problem ;^)
  50.  
  51.     """
  52.     def __init__(self, giop_server, connection):
  53.     """ Provide an interface to a remote object!
  54.  
  55.     'protocol'   is the protocol used by this worker.
  56.     'connection' is the aconnection to the remote object.
  57.  
  58.     """
  59.     self.__giop_server = giop_server
  60.     self.__connection = connection
  61.  
  62.     # Have we been closed down?
  63.     self.__closed = 0
  64.  
  65.     # Set the connection to NON-blocking mode.
  66.     self.__connection.blocking(0)
  67.  
  68.     # Queue of outgoing GIOP messages.
  69.     self.__outgoing = []
  70.  
  71.     # Get a reference to the active reactor.
  72.     self.__reactor = Reactor.Reactor_init()
  73.  
  74.     # Register our interest in read events (ie. operation requests) with
  75.     # the Reactor.
  76.     self.__reactor.register_handler(self, Reactor.READ)
  77.  
  78.     # Create a handler to look after the connection.
  79.     self.__handler = GIOPConnectionHandler.GIOPConnectionHandler \
  80.              (self, self.__connection)
  81.     return
  82.  
  83.     def pseudo__del__(self):
  84.     """ Pseudo destructor to remove circular references.
  85.  
  86.     This method is called from '__shutdown' only.
  87.  
  88.     """
  89.     # The GIOP server holds a (circular) reference to this instance so we
  90.     # have to explicitly clean it up.
  91.     self.__giop_server.pseudo__del__()
  92.  
  93.     # Clean up *our* reference to *it*!
  94.     del self.__giop_server
  95.  
  96.     # The handler also holds a (circular) reference to this instance so we
  97.     # have to explicitly clean it up.
  98.     self.__handler.pseudo__del__()
  99.  
  100.     # Clean up *our* reference to *it*!
  101.     del self.__handler
  102.  
  103.     return
  104.  
  105.     #########################################################################
  106.     # GIOPServerWorker interface.
  107.     #########################################################################
  108.  
  109.     def send(self, message):
  110.     """ Send a message to the 'client'.
  111.  
  112.     This method simply adds the message to the queue of outgoing messages
  113.     and registers out interest in write events with the Reactor.
  114.  
  115.     """
  116.     # Add the outgoing message to the queue.
  117.     self.__outgoing.append(message)
  118.         
  119.     # Register my interest in write events with the Reactor.
  120.     self.__reactor.register_handler(self, Reactor.WRITE)
  121.  
  122.     return
  123.  
  124.     def close_connection(self):
  125.     """ Close down the worker.
  126.  
  127.     Currently, Fnorb does not close down servers, so this is not used.
  128.  
  129.     """
  130.     if not self.__closed:
  131.         # Don't accept any more operation requests.
  132.         self.__reactor.unregister_handler(self, Reactor.READ)
  133.  
  134.         # Send all outstanding messages.
  135.         while len(self.__outgoing) > 0:
  136.         self.__reactor.do_one_event()
  137.  
  138.         # Close down the worker.
  139.         self.__close()
  140.  
  141.     return
  142.  
  143.     #########################################################################
  144.     # EventHandler interface.
  145.     #########################################################################
  146.  
  147.     def handle_event(self, mask):
  148.     """ Callback method to handle all events except close events. """
  149.  
  150.     # Read event.
  151.     if mask & Reactor.READ:
  152.         try:
  153.         self.__handler.recv()
  154.  
  155.         except CORBA.SystemException:
  156.         self.handle_close()
  157.  
  158.     # Write event.
  159.     elif mask & Reactor.WRITE:
  160.         try:
  161.         self.__handler.send(self.__outgoing[0])
  162.  
  163.         except CORBA.SystemException:
  164.         self.handle_close()
  165.  
  166.     # Exception event.
  167.     elif mask & Reactor.EXCEPTION:
  168.         self.handle_close()
  169.  
  170.     return
  171.  
  172.     def handle_close(self):
  173.     """ Callback method to handle close events. """
  174.  
  175.     # Close down the worker.
  176.     self.__close()
  177.  
  178.     return
  179.  
  180.     def handle(self):
  181.     """ Return my underlying I/O handle.
  182.  
  183.     In this case, my I/O handle is the file descriptor of my socket. 
  184.  
  185.     """
  186.     return self.__connection.handle()
  187.  
  188.     #########################################################################
  189.     # GIOPConnectionHandlerListener interface.
  190.     #########################################################################
  191.  
  192.     def message_received(self, message):
  193.     """ Called when a complete GIOP message has been received. """
  194.  
  195.     # Pass the message up to the GIOP server.
  196.     self.__giop_server.process_giop_message(message)
  197.  
  198.     return
  199.  
  200.     def message_sent(self):
  201.     """ Called when a complete GIOP message has been sent. """
  202.  
  203.     # Remove the message from the outgoing queue.
  204.     del self.__outgoing[0]
  205.  
  206.     # If there are no other messages left to send then tell the Reactor
  207.     # that I am no longer interested in write events.
  208.     if len(self.__outgoing) == 0:
  209.         self.__reactor.unregister_handler(self, Reactor.WRITE)
  210.  
  211.     return
  212.  
  213.     #########################################################################
  214.     # Private interface.
  215.     #########################################################################
  216.  
  217.     def __close(self):
  218.     """ Close down the worker. """
  219.  
  220.     if not self.__closed:
  221.         # Withdraw all of my Reactor registrations.
  222.         self.__reactor.unregister_handler(self, Reactor.ALL)
  223.  
  224.         # Set the connection to blocking mode.
  225.         self.__connection.blocking(1)
  226.  
  227.         # Close our connection.
  228.         self.__connection.disconnect()
  229.  
  230.         # All done!
  231.         self.__closed = 1
  232.  
  233.         # Remove circular references.
  234.         self.pseudo__del__()
  235.  
  236.     return
  237.  
  238. #############################################################################
  239.