home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / fnb101.zip / Lib / site-packages / Fnorb / orb / BOA.py < prev    next >
Text File  |  1999-06-28  |  14KB  |  484 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/BOA.py,v $
  31. # Version:      @(#)$RCSfile: BOA.py,v $ $Revision: 1.32 $
  32. #
  33. #############################################################################
  34. """ Implementation of the CORBA Basic Object Adapter (BOA). """
  35.  
  36.  
  37. # Standard/built-in modules.
  38. import regex, string
  39.  
  40. # Fnorb Modules.
  41. import fnorb_thread, CORBA, IOP, Util
  42.  
  43. # BOA identifier.
  44. BOA_ID = 'The Fnorb BOA v1.0.Threads.R.Us'
  45.  
  46.  
  47. #############################################################################
  48. # The BOA interface.
  49. #############################################################################
  50.  
  51. def BOA_init(argv=[], boa_id=BOA_ID):
  52.     """ Initialise the BOA.
  53.  
  54.     This is a factory function for the BOA class (the BOA is a singleton (ie.
  55.     there can only be one BOA instance per process)).
  56.  
  57.     """
  58.     try:
  59.     boa = BOA(argv, boa_id)
  60.  
  61.     except BOA, boa:
  62.     pass
  63.  
  64.     return boa
  65.  
  66.  
  67. class BOA:
  68.     """ The BOA object.
  69.  
  70.     The BOA is a singleton (ie. there can only be one BOA instance per
  71.     process).
  72.  
  73.     """
  74.     # Singleton instance.
  75.     __instance = None
  76.  
  77.     # Mutex to make access via the factory function thread-safe.
  78.     __lk = fnorb_thread.allocate_lock()
  79.  
  80.     def __init__(self, argv, boa_id):
  81.     """ Constructor.
  82.  
  83.     'argv'   command line arguments.
  84.     'boa_id' the unique identifier of the BOA implementation. This MUST
  85.              be the same string as the 'constant' BOA.BOA_ID.
  86.  
  87.     """
  88.     # The BOA id MUST be the same string as the 'constant' BOA_ID.
  89.     if boa_id != BOA_ID:
  90.         raise CORBA.INITIALIZE() # System exception.
  91.  
  92.     # The BOA is a singleton (ie. there can only be one BOA instance per
  93.     # process (have I made this point clear yet?!?).
  94.     BOA.__lk.acquire()
  95.     try:
  96.         if BOA.__instance is not None:
  97.         raise BOA.__instance
  98.  
  99.         BOA.__instance = self
  100.  
  101.     finally:
  102.         BOA.__lk.release()
  103.  
  104.     # Get a reference to the ORB that we are living in.
  105.     orb = CORBA.ORB_init()
  106.  
  107.     # Register ourselves with the ORB.
  108.     orb._fnorb_register_object_adapter(self)
  109.  
  110.     # Process any 'command line' options.
  111.     self.__options = self.__get_options(argv)
  112.  
  113.     # If a particular hostname or port number was specified then use them.
  114.     if self.__options.has_key('OAhost'):
  115.         host = self.__options['OAhost']
  116.  
  117.     else:
  118.         host = ''
  119.  
  120.     if self.__options.has_key('OAport'):
  121.         port = self.__options['OAport']
  122.  
  123.     else:
  124.         port = 0
  125.  
  126.     # To save a dictionary lookup on every operation invocation we set a
  127.     # flag if the 'thread per request' option was specified.
  128.     if self.__options.has_key('OAthread-per-request'):
  129.         self.__thread_per_request = 1
  130.  
  131.     else:
  132.         self.__thread_per_request = 0
  133.  
  134.     # A dictionary of active object implementations in the form:-
  135.     # {ObjectKey: Implementation} with types {String: Instance}.
  136.     self.__object_table = {}
  137.  
  138.     # A mutex for making access to the BOA's data structures thread-safe.
  139.     self.__lk = fnorb_thread.allocate_lock()
  140.     
  141.     # Ask each protocol to create an endpoint on which to listen for
  142.     # connection requests (no requests will actually be serviced until
  143.     # we start the event loop).
  144.     #
  145.     # fixme: We will need some sort of abstraction for protocol
  146.     # addresses. Hostname and port number are just kinda TCP/IP
  147.     # specific!
  148.     for protocol in orb._fnorb_protocols():
  149.         protocol.enable(host, port)
  150.  
  151.     return
  152.  
  153.     #########################################################################
  154.     # BOA interface.
  155.     #########################################################################
  156.  
  157.     def create(self, id, intrep_id):
  158.     """ Generate an object reference.
  159.  
  160.     'id'        is the object reference data (aka the object key).
  161.     'intrep_id' is the interface repository id of the interface.
  162.  
  163.         """
  164.     # Create an IOR.
  165.     ior = self._fnorb_create_ior(id, intrep_id)
  166.  
  167.     # Create an object reference from the IOR.
  168.     return CORBA.ORB_init()._fnorb_ior_to_object(ior)
  169.  
  170.     def obj_is_ready(self, obj, impl):
  171.     """ Inform the BOA that an object is prepared to accept requests.
  172.  
  173.     'obj'  is the object reference that the implementation will use.
  174.     'impl' is the implementation repository object that implements the
  175.            interface (in our case, simply a Python instance!).
  176.     
  177.         """
  178.     # Get the IOR from the object reference.
  179.     ior = obj._fnorb_ior()
  180.  
  181.     # Get the object key from *any* protocol (there is only one object key
  182.     # per IOR, not one per protocol!).
  183.     for protocol in CORBA.ORB_init()._fnorb_protocols():
  184.         object_key = protocol.get_object_key(ior)
  185.         if object_key is not None:
  186.         break
  187.  
  188.     else:
  189.         raise CORBA.INV_OBJREF() # System exception.
  190.  
  191.     # Add the implementation to our object table.
  192.     self.__lk.acquire()
  193.     self.__object_table[object_key] = impl
  194.     self.__lk.release()
  195.  
  196.     # Add the object key to the implementation's key table.
  197.     impl._fnorb_add_object_key(object_key)
  198.  
  199.     return
  200.  
  201.     def deactivate_obj(self, obj):
  202.     """ Remove an object implementation from the BOA. """
  203.  
  204.     # Get the IOR from the object reference.
  205.     ior = obj._fnorb_ior()
  206.  
  207.     # Get the object key from *any* protocol (there is only one object key
  208.     # per IOR, not one per protocol!).
  209.     for protocol in CORBA.ORB_init()._fnorb_protocols():
  210.         object_key = protocol.get_object_key(ior)
  211.         if object_key is not None:
  212.         break
  213.  
  214.     else:
  215.         raise CORBA.INV_OBJREF() # System exception.
  216.  
  217.     self.__lk.acquire()
  218.     try:
  219.         impl = self.__object_table[object_key]
  220.  
  221.         # Remove the object key from the implementation's key table.
  222.         impl._fnorb_delete_object_key()
  223.  
  224.         # Remove the object from the object table.
  225.         del self.__object_table[object_key]
  226.  
  227.     # Ignore attempts to delete an object that wasn't in the table in the
  228.     # first place!
  229.     except KeyError:
  230.         pass
  231.     self.__lk.release()
  232.  
  233.     return
  234.  
  235.     #########################################################################
  236.     # Fnorb-specific interface.
  237.     #########################################################################
  238.  
  239.     def _fnorb_mainloop(self, timeout=None):
  240.     """ Start the event loop. """
  241.  
  242.     # Get a reference to the ORB.
  243.     orb = CORBA.ORB_init()
  244.  
  245.     # If the ORB is running in multi-threaded mode then start a thread-pool
  246.     # to handle incoming requests.
  247.     if orb._fnorb_threading_model() == Util.THREADED:
  248.         # Get the size of the thread pool from the ORB.
  249.         size = orb._fnorb_thread_pool_size()
  250.         if size > 0:
  251.         from ThreadPoolQueue import ThreadPoolQueue
  252.  
  253.         # Create and start the queue.
  254.         self.__queue = ThreadPoolQueue(size, self.__process_request)
  255.         self.__queue.start()
  256.  
  257.     # Ladies and Gentlemen, start your engines...
  258.     for protocol in CORBA.ORB_init()._fnorb_protocols():
  259.         # Ask the protocol to start its event loop.
  260.         protocol.start(timeout)
  261.         
  262.     return
  263.  
  264.     def _fnorb_quit(self):
  265.     """ Exit the event loop. """
  266.  
  267.     # Get a reference to the ORB.
  268.     orb = CORBA.ORB_init()
  269.  
  270.     # Ok, that's enough...
  271.     for protocol in orb._fnorb_protocols():
  272.         # Ask the protocol to stop its event loop.
  273.         protocol.stop()
  274.  
  275.     # If the ORB is running in multi-threaded mode then stop the thread
  276.     # pool.
  277.     if orb._fnorb_threading_model() == Util.THREADED:
  278.         self.__queue.stop()
  279.  
  280.     return
  281.  
  282.     def _fnorb_get_implementation(self, object_key):
  283.     """ Return the implementation for the specified object key. """
  284.  
  285.     self.__lk.acquire()
  286.     try:
  287.         impl = self.__object_table[object_key]
  288.  
  289.     except KeyError:
  290.         impl = None
  291.     self.__lk.release()
  292.  
  293.     return impl
  294.  
  295.     def _fnorb_create_ior(self, object_key, intrep_id):
  296.     """ Create an IOR.
  297.  
  298.     'id'        is the object reference data (aka the object key).
  299.     'intrep_id' is the repository id of the object's interface.
  300.  
  301.         """
  302.     profiles = []
  303.     # Create a profile for each protocol.
  304.     for protocol in CORBA.ORB_init()._fnorb_protocols():
  305.         profiles.append(protocol.create_profile(object_key))
  306.  
  307.     return IOP.IOR(intrep_id, profiles)
  308.  
  309.     def _fnorb_request(self, request):
  310.     """ Process an operation request.
  311.  
  312.     Currently, the request is a tuple in the form:-
  313.  
  314.     (giop_server, request_header, cursor)
  315.  
  316.     """
  317.     if self.__thread_per_request:
  318.         fnorb_thread.start_new_thread(self.__process_request, (request,))
  319.  
  320.     else:
  321.         # Get a reference to the ORB.
  322.         orb = CORBA.ORB_init()
  323.  
  324.         # If the ORB is running in multi-threaded mode and we are using a
  325.         # thread pool to service requests then simply put the request on
  326.         # the queue.
  327.         if orb._fnorb_threading_model() == Util.THREADED and \
  328.            orb._fnorb_thread_pool_size() > 0:
  329.         self.__queue.add_item((request,))
  330.  
  331.         # Otherwise, we handle the request immediately.
  332.         else:
  333.         self.__process_request(request)
  334.  
  335.     return
  336.  
  337.     def _fnorb_object_here(self, object_key):
  338.     """ Does the BOA contain an implementation for this object key? """
  339.  
  340.     # See if the object is here!
  341.     self.__lk.acquire()
  342.     object_here = self.__object_table.has_key(object_key)
  343.     self.__lk.release()
  344.  
  345.     return object_here
  346.  
  347.     #########################################################################
  348.     # Private interface.
  349.     #########################################################################
  350.  
  351.     def __get_options(self, argv):
  352.     """ Process 'command line' options. """
  353.  
  354.     # Work on a copy of the command line arguments.
  355.     args = argv[:]
  356.     
  357.     # Command line arguments used by the BOA are stripped from the list.
  358.     # We accomplish this by first emptying the list and then putting back
  359.     # any non-BOA arguments.
  360.     #
  361.     # Empty the list without the destroying the list object itself.
  362.     del argv[:]
  363.  
  364.     # For convenience we return any BOA options in a dictionary.
  365.     options = {}
  366.  
  367.     i = 0
  368.     while i < len(args):
  369.         arg = args[i]
  370.  
  371.         if regex.match('--OAhost=.*', arg) != -1:
  372.         value = arg[string.find(arg, '=') + 1:]
  373.         options['OAhost'] = value
  374.  
  375.         elif regex.match('--OAport=.*', arg) != -1:
  376.         try:
  377.             value = arg[string.find(arg, '=') + 1:]
  378.             options['OAport'] = string.atoi(value)
  379.  
  380.         except ValueError:
  381.             raise CORBA.INITIALIZE() # System exception.
  382.  
  383.         elif arg == '--OAthread-per-request':
  384.         options['OAthread-per-request'] = None
  385.  
  386.         else:
  387.         argv.append(arg)
  388.  
  389.         i = i + 1
  390.  
  391.     return options
  392.  
  393.     def __process_request(self, request):
  394.     """ Handle a GIOP request. """
  395.  
  396.     # fixme: Need request abstraction?
  397.     (giop_server, request_header, cursor) = request
  398.     try:
  399.         self.__lk.acquire()
  400.         if self.__object_table.has_key(request_header.object_key):
  401.         impl = self.__object_table[request_header.object_key]
  402.         else:
  403.         impl = None
  404.         self.__lk.release()
  405.  
  406.         # Handle any 'non-existent' operations (some ORBs use
  407.         # '_not_existent' instead of '_non_existent').
  408.         if request_header.operation in ['_non_existent', '_not_existent']:
  409.         # If the implementation was found then it is NOT non-existent!
  410.         result = impl is None
  411.  
  412.         # Send the appropriate reply.
  413.         self.__non_existent(giop_server,request_header, cursor, result)
  414.  
  415.         return
  416.  
  417.         # If the implementation is not here then raise an appropriate
  418.         # exception.
  419.         if impl is None:
  420.         raise CORBA.NO_IMPLEMENT() # System exception.
  421.     
  422.         # Look for the skeleton method on the implementation.
  423.         try:
  424.         method = getattr(impl, '_skel_' + request_header.operation)
  425.  
  426.         # If the skeleton method is not implemented then see if there is a
  427.         # Dynamic Invocation Routine (DIR).
  428.         #
  429.         # fixme: Should the DIR be __getattr__?
  430.         except AttributeError:
  431.         try:
  432.             method = getattr(impl, 'invoke')
  433.  
  434.         # If there is no skeleton method and no DIR then the
  435.         # implementation does not support this operation!
  436.             except AttributeError:
  437.             raise CORBA.NO_IMPLEMENT() # System exception.
  438.  
  439.         # Add the object key to the implementation's key table.
  440.         impl._fnorb_add_object_key(request_header.object_key)
  441.  
  442.         # Create a server request.
  443.         server_request = CORBA.ServerRequest(request_header, cursor)
  444.  
  445.         # Invoke the skeleton method/DIR.
  446.         try:
  447.         apply(method, (server_request,))
  448.  
  449.         # Send the reply (unless this was a 'oneway' request).
  450.         if request_header.response_expected:
  451.             giop_server.reply(request_header, server_request)
  452.  
  453.         except CORBA.UserException, ex:
  454.         # Set the exception in the server request.
  455.         server_request.exception(ex)
  456.  
  457.         # Notify the GIOP server of the user exception.
  458.         giop_server.user_exception(request_header, server_request)
  459.  
  460.     except CORBA.SystemException, ex:
  461.         # Notify the GIOP server of the system exception.
  462.         giop_server.system_exception(request_header, ex)
  463.  
  464.     return
  465.  
  466.     def __non_existent(self, giop_server, request_header, cursor, result):
  467.     """ Send a reply to a 'non_existent' request. """
  468.  
  469.     # Create a server request.
  470.     server_request = CORBA.ServerRequest(request_header, cursor)
  471.  
  472.     # Initialise it.
  473.     server_request.initialise([], [CORBA.TC_boolean], [])
  474.  
  475.     # Set the result.
  476.     server_request.results(result)
  477.  
  478.     # Send the reply.
  479.     giop_server.reply(request_header, server_request)
  480.  
  481.     return
  482.  
  483. #############################################################################
  484.