home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / fnb101.zip / Lib / site-packages / Fnorb / orb / CORBA.py < prev    next >
Text File  |  1999-06-28  |  46KB  |  1,493 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/CORBA.py,v $
  31. # Version:      @(#)$RCSfile: CORBA.py,v $ $Revision: 1.43 $
  32. #
  33. #############################################################################
  34. """ CORBA module. """
  35.  
  36.  
  37. # Fnorb modules.
  38. import fnorb_thread, TypeManager, Util
  39.  
  40.  
  41. # ORB identifier.
  42. ORB_ID = 'The ORB called Fnorb v1.0.Threads.R.Us'
  43.  
  44. # Boolean 'constants' as specified in the Python language mapping.
  45. TRUE  = 1
  46. FALSE = 0
  47.  
  48. #############################################################################
  49. # Exception classes.
  50. #############################################################################
  51.  
  52. # Exception base class.
  53. class CORBAException: pass
  54.  
  55. # User exceptions.
  56. class UserException(CORBAException): pass
  57.  
  58. # System exceptions.
  59. #
  60. # Enum: IDL:omg.org/CORBA/completion_status:1.0
  61. COMPLETED_YES     = Util.EnumMember('COMPLETED_YES',   0)
  62. COMPLETED_NO      = Util.EnumMember('COMPLETED_NO',    1)
  63. COMPLETED_MAYBE   = Util.EnumMember('COMPLETED_MAYBE', 2)
  64. completion_status = Util.Enum("IDL:omg.org/CORBA/completion_status:1.0",
  65.                   [COMPLETED_YES, COMPLETED_NO, COMPLETED_MAYBE])
  66.  
  67. TypeManager.TypeManager_init().add_type("IDL:omg.org/CORBA/completion_status:1.0", "000000000000001100000088000000000000002849444C3A6F6D672E6F72672F434F5242412F636F6D706C6574696F6E5F7374617475733A312E300000000012636F6D706C6574696F6E5F737461747573000000000000030000000E434F4D504C455445445F5945530000000000000D434F4D504C455445445F4E4F0000000000000010434F4D504C455445445F4D4159424500", completion_status)
  68.  
  69. class SystemException(CORBAException):
  70.     """ Struct: IDL:omg.org/CORBA/SystemException:1.0 """
  71.  
  72.     _FNORB_ID = "IDL:omg.org/CORBA/SystemException:1.0"
  73.  
  74.     def __init__(self, _minor=0, _completed=COMPLETED_NO):
  75.         """ Constructor. """
  76.  
  77.         self.minor = _minor
  78.         self.completed = _completed
  79.         return
  80.  
  81.     def __getinitargs__(self):
  82.         """ Return the constructor arguments for unpickling. """
  83.  
  84.         return (self.minor, self.completed)
  85.  
  86.     def __str__(self):
  87.      """ Return a string representation of the exception. """
  88.  
  89.      return 'Minor: ' + `self.minor` + ' Completed: ' + str(self.completed)
  90.  
  91.     # fixme: Replace these methods with typecode marshalling?
  92.     def _fnorb_marshal(self, cursor):
  93.         """ Marshal the structure onto an octet stream. """
  94.  
  95.         cursor.marshal('L', self.minor)
  96.         cursor.marshal('L', self.completed.value())
  97.         return
  98.  
  99.     def _fnorb_unmarshal(self, cursor):
  100.         """ Unmarshal the structure from an octet stream. """
  101.  
  102.         self.minor = cursor.unmarshal('L')
  103.         self.completed = completion_status[int(cursor.unmarshal('L'))]
  104.         return
  105.  
  106. # A class for every system exception!
  107. class UNKNOWN         (SystemException): pass # The unknown exception!
  108. class BAD_PARAM       (SystemException): pass # Invalid parameter was passed.
  109. class NO_MEMORY       (SystemException): pass # Memory allocation failure.
  110. class IMP_LIMIT       (SystemException): pass # Violated implementation limit.
  111. class COMM_FAILURE    (SystemException): pass # Communication failure.
  112. class INV_OBJREF      (SystemException): pass # Invalid object reference.
  113. class NO_PERMISSION   (SystemException): pass # No permission for operation.
  114. class INTERNAL        (SystemException): pass # ORB internal error.
  115. class MARSHAL         (SystemException): pass # Error marshalling param/result.
  116. class INITIALIZE      (SystemException): pass # ORB initialisation failure.
  117. class NO_IMPLEMENT    (SystemException): pass # Op. implementation unavailable.
  118. class BAD_TYPECODE    (SystemException): pass # Bad typecode.
  119. class BAD_OPERATION   (SystemException): pass # Invalid operation.
  120. class NO_RESOURCES    (SystemException): pass # Insufficient resources for req.
  121. class NO_RESPONSE     (SystemException): pass # Response to req. not available.
  122. class PERSIST_STORE   (SystemException): pass # Persistent storage failure.
  123. class BAD_INV_ORDER   (SystemException): pass # Routine inv. out of order
  124. class TRANSIENT       (SystemException): pass # Transient failure, reissue req.
  125. class FREE_MEM        (SystemException): pass # Cannot free memory.
  126. class INV_IDENT       (SystemException): pass # Invalid identifier syntax.
  127. class INV_FLAG        (SystemException): pass # Invalid flag was specified.
  128. class INTF_REPOS      (SystemException): pass # Error accessing I/F repository.
  129. class BAD_CONTEXT     (SystemException): pass # Error processing context obj.
  130. class OBJ_ADAPTER     (SystemException): pass # Failure detected by adapter.
  131. class DATA_CONVERSION (SystemException): pass # Data conversion error.
  132. class OBJECT_NOT_EXIST(SystemException): pass # Non-existent object, del OR.
  133.  
  134. #############################################################################
  135. # The ORB interface.
  136. #############################################################################
  137.  
  138. def ORB_init(argv=[], orb_id=ORB_ID):
  139.     """ Initialise the ORB.
  140.  
  141.     This is a factory function for the ORB class (the ORB is a singleton (ie.
  142.     there can only be one ORB instance per process)).
  143.  
  144.     """
  145.     try:
  146.     orb = ORB(argv, orb_id)
  147.  
  148.     except ORB, orb:
  149.     pass
  150.  
  151.     return orb
  152.  
  153.  
  154. class ORB:
  155.     """ The ORB object.
  156.  
  157.     The ORB is a singleton (ie. there can only be one ORB instance per
  158.     process).
  159.  
  160.     """
  161.     # Singleton instance.
  162.     __instance = None
  163.  
  164.     # Mutex to make access via the factory function thread-safe.
  165.     __lk = fnorb_thread.allocate_lock()
  166.  
  167.     # Exceptions.
  168.     class InvalidName(UserException): pass
  169.  
  170.     def __init__(self, argv, orb_id):
  171.     """ Constructor.
  172.  
  173.     'argv'   command line arguments.
  174.     'orb_id' the unique identifier of the ORB implementation. This MUST be
  175.              the same string as the 'constant' CORBA.ORB_ID.
  176.  
  177.     """
  178.     # The ORB id MUST be the same string as the 'constant' ORB_ID.
  179.     if orb_id != ORB_ID:
  180.         raise INITIALIZE() # System exception.
  181.  
  182.     # The ORB is a singleton (ie. there can only be one ORB instance per
  183.     # process (have I made this point clear yet?!?).
  184.     ORB.__lk.acquire()
  185.     try:
  186.         if ORB.__instance is not None:
  187.         raise ORB.__instance
  188.  
  189.         ORB.__instance = self
  190.  
  191.     finally:
  192.         ORB.__lk.release()
  193.  
  194.     # A list of pending DII requests.
  195.     self.__pending = []
  196.  
  197.     # The object adapter registered with the ORB.
  198.     self.__object_adapter = None
  199.  
  200.     # A mutex to make access to the ORB's data structures thread-safe.
  201.     self.__lk = fnorb_thread.allocate_lock()
  202.  
  203.     # ORB options can be specified via a configuration file, environment
  204.     # variables, or the command-line (in order of increasing precedence).
  205.     self.__options = self.__get_options(argv)
  206.  
  207.     # Initialise all GIOP transport protocols.
  208.     self.__protocols = self.__initialise_protocols()
  209.  
  210.     # A dictionary containing the names and references of the available
  211.     # object services. Note that (currently) we do not have to lock this
  212.     # dictionary as it only written to in *this* constructor.  All other
  213.     # accesses are read-only.
  214.     self.__services = {} # {Identifier : ObjectReference}
  215.  
  216.     # Initialise the available object services.
  217.     #
  218.     # The only two reserved COS ids are 'InterfaceRepository' and 
  219.     # 'NameService' so these are the only two services that we attempt
  220.     # to initialise (it is assumed that, given a naming service,
  221.     # application objects can find any other required services/objects).
  222.     #
  223.     # Naming service.
  224.     ns = self.__initialise_naming_service()
  225.      if ns is not None:
  226.          self.__services['NameService'] = ns
  227.  
  228.      # Interface repository.
  229.       ir = self.__initialise_interface_repository()
  230.       if ir is not None:
  231.           self.__services['InterfaceRepository'] = ir
  232.  
  233.     return
  234.  
  235.     #########################################################################
  236.     # CORBA ORB interface.
  237.     #########################################################################
  238.  
  239.     def object_to_string(self, object):
  240.     """ Create a stringified object reference. """
  241.  
  242.     if object is not None:
  243.         # Get the IOR from the object reference.
  244.         ior = object._fnorb_ior()
  245.  
  246.     else:
  247.         # Create an IOR with no profiles.
  248.         ior = IOP.IOR()
  249.  
  250.     # Stringify it!
  251.     return ior._fnorb_to_string()
  252.  
  253.     def string_to_object(self, stringified_ior):
  254.     """ Convert a stringified object reference into a live object!
  255.     
  256.     Note that this call does NOT attempt to connect to the remote object
  257.     and it will succeed even if the object reference is 'stale' i.e even if
  258.     the remote object no longer exists.
  259.  
  260.     """
  261.     # This contains a subtle Fnorb-ism as it allows for UOL's in the
  262.     # string!
  263.     return self.__resolve_uol(stringified_ior)
  264.  
  265.     def list_initial_services(self):
  266.     """ List the names of the available object services. """
  267.  
  268.     # Only return the names of the services that are 'up and running'!
  269.     up_and_running = []
  270.     for identifier in self.__services.keys():
  271.         # Get the service's object reference.
  272.         service = self.__services[identifier]
  273.  
  274.          # To find out if the object reference is still valid we have to
  275.          # invoke an operation on it. The '_is_a' operation is pretty
  276.         # harmless, so we do that!
  277.          try:
  278.         # We don't care about the result!
  279.          service._is_a('IDL:omg.org/CORBA/Object:1.0')
  280.  
  281.         # The call succeeded, so add the name of the service to the
  282.         # list.
  283.         up_and_running.append(identifier)
  284.  
  285.          except SystemException:
  286.         pass
  287.  
  288.     return up_and_running
  289.  
  290.     def resolve_initial_references(self, identifier):
  291.     """ Return a reference to the object service named by 'identifier'. """
  292.  
  293.     try:
  294.         service = self.__services[identifier]
  295.  
  296.          # To find out if the object reference is still valid we have to
  297.          # invoke an operation on it. The '_is_a' operation is pretty
  298.         # harmless, so we do that!
  299.         #
  300.         # We don't care about the result!
  301.         service._is_a('IDL:omg.org/CORBA/Object:1.0')
  302.  
  303.     # We get a 'KeyError' if a service with the name 'identifier' is
  304.     # not present, and a 'SystemException' if the service's object
  305.     # reference is 'stale'.
  306.     except (KeyError, SystemException):
  307.         raise ORB.InvalidName()
  308.  
  309.     return service
  310.  
  311.     def nil(self):
  312.     """ Generate a NIL object reference. """
  313.  
  314.     return None
  315.  
  316.     #########################################################################
  317.     # CORBA TypeCode factory interface.
  318.     #########################################################################
  319.     
  320.     def create_struct_tc(self, id, name, members):
  321.     return StructTypeCode(id, name, members)
  322.  
  323.     def create_union_tc(self, id, name, discriminator_type, members):
  324.     return UnionTypeCode(id, name, discriminator_type, members)
  325.  
  326.     def create_enum_tc(self, id, name, members):
  327.     return EnumTypeCode(id, name, members)
  328.  
  329.     def create_alias_tc(self, id, name, original_type):
  330.     return AliasTypeCode(id, name, original_type)
  331.  
  332.     def create_exception_tc(self, id, name, members):
  333.     return ExceptionTypeCode(id, name, members)
  334.  
  335.     def create_interface_tc(self, id, name):
  336.     return InterfaceTypeCode(id, name)
  337.  
  338.     def create_string_tc(self, bound):
  339.     return StringTypeCode(bound)
  340.  
  341.     def create_wstring_tc(self, bound):
  342.     return WstringTypeCode(bound)
  343.  
  344.     def create_fixed_tc(self, digits, scale):
  345.     return FixedTypeCode(digits, scale)
  346.     
  347.     def create_sequence_tc(self, bound, element_type):
  348.     return SequenceTypeCode(bound, element_type)
  349.  
  350.     def create_recursive_sequence_tc(self, bound, offset):
  351.     return RecursiveSequenceTypeCode(bound, offset)
  352.  
  353.     def create_array_tc(self, length, element_type):
  354.     return ArrayTypeCode(length, element_type)
  355.  
  356.     #########################################################################
  357.     # CORBA DII interface.
  358.     #########################################################################
  359.  
  360.     def send_multiple_requests(self, requests):
  361.     """ Send multiple requests. """
  362.  
  363.     # Add the requests to our list of those pending.
  364.     #
  365.     # fixme: If the client never actually gets the replies, this list will
  366.     # grow and grow!!
  367.     self.__lk.acquire()
  368.     self.__pending = self.__pending + requests
  369.     self.__lk.release()
  370.  
  371.     # Send each request.
  372.     for request in requests:
  373.         request.send()
  374.  
  375.     return
  376.  
  377.     def send_multiple_requests_oneway(self, requests):
  378.     """ Send multiple requests as 'oneway' operations. """
  379.  
  380.     # Send each request 'oneway'.
  381.     for request in requests:
  382.         request.send_oneway()
  383.  
  384.     return
  385.  
  386.     def poll_next_response(self):
  387.     """ Return true if there is at least one response waiting. """
  388.  
  389.     self.__lk.acquire()
  390.     for request in self.__pending:
  391.         if request.poll_response():
  392.         result = 1
  393.         break
  394.  
  395.     else:
  396.         result = 0
  397.     self.__lk.release()
  398.  
  399.     return result
  400.  
  401.     def get_next_response(self):
  402.     """ Get the next DII response. """
  403.  
  404.     self.__lk.acquire()
  405.     got_response = 0
  406.     while not got_response:
  407.         for i in range(len(self.__pending)):
  408.         if self.__pending[i].poll_response():
  409.             result = self.__pending[i]
  410.             got_response = 1
  411.             break
  412.  
  413.     # Delete the request from the pending queue.
  414.     del self.__pending[i]
  415.  
  416.     self.__lk.release()
  417.     return result
  418.  
  419.     #########################################################################
  420.     # Fnorb-specific interface.
  421.     #########################################################################
  422.  
  423.     def _fnorb_register_object_adapter(self, object_adapter):
  424.     """ Register an Object Adapter. """
  425.  
  426.     self.__object_adapter = object_adapter
  427.     return
  428.  
  429.     def _fnorb_object_adapter(self):
  430.     """ Return the object adapter. """
  431.  
  432.     return self.__object_adapter
  433.  
  434.     def _fnorb_threading_model(self):
  435.     """ Return the threading model being used by the ORB. """
  436.  
  437.     self.__lk.acquire()
  438.     if self.__options['Threading Model'] == 'Threaded':
  439.         threading_model = Util.THREADED
  440.  
  441.     else:
  442.         threading_model = Util.REACTIVE
  443.     self.__lk.release()
  444.  
  445.     return threading_model
  446.  
  447.     def _fnorb_thread_pool_size(self):
  448.     """ Return the size of the thread pool. """
  449.  
  450.     self.__lk.acquire()
  451.     thread_pool_size = eval(self.__options['Thread Pool Size'])
  452.     self.__lk.release()
  453.  
  454.     return thread_pool_size
  455.  
  456.     def _fnorb_protocols(self):
  457.     """ Return the list of the GIOP transport protocols. """
  458.  
  459.     # Return a copy of the list so that it cannot be modified!
  460.     return self.__protocols[:]
  461.  
  462.     def _fnorb_register_type(self, old, new):
  463.     """ Register a new type. """
  464.  
  465.     # Get a reference to the Type Manager.
  466.     tm = TypeManager.TypeManager_init()
  467.  
  468.     # Get the Interface Repository id of the old type.
  469.     ifr_id = tm.get_ifr_id(old)
  470.  
  471.     # Get the typecode constant of the old type
  472.     typecode_constant = tm.get_typecode_constant(ifr_id)
  473.  
  474.     # Register the new type.
  475.     tm.add_type(ifr_id, typecode_constant, new)
  476.  
  477.     return
  478.  
  479.     # This method is used by the BOA and the TypeCode modules.
  480.     def _fnorb_ior_to_object(self, ior):
  481.     """ Convert an IOR instance into a live object! """
  482.  
  483.     # If the IOR has an empty list of profiles then it is a NIL object
  484.     # reference!
  485.     if len(ior.profiles) == 0:
  486.         object = None
  487.  
  488.     else:
  489.         # If the IOR references an object in *this* ORB, then we create
  490.         # a 'local' object reference.  Local object references are more
  491.         # efficient as they bypass the usual marshalling and unmarshalling
  492.         # stages of operation invocations.
  493.         if self.__is_local_object(ior):
  494.         object = LocalObject(ior)
  495.  
  496.         # Otherwise, the IOR references a 'remote' object.
  497.         else:
  498.         # Get a reference to the type manager.
  499.         tm = TypeManager.TypeManager_init()
  500.  
  501.         # Find the Python stub class that implements the interface.
  502.         klass = tm.get_python_object(ior.type_id)
  503.         
  504.         # If the Python class was found then create an instance of it!
  505.         if klass is not None:
  506.             object = apply(klass, (ior,))
  507.  
  508.         # Otherwise, we create an instance of the generic type,
  509.         # 'CORBA.Object'.  Operations can still be invoked on the
  510.         # object via the DII.
  511.         #
  512.         # This is used extensively in applications such as the Naming
  513.         # Service where IOR's must be sent and received without the
  514.         # application having access to the stubs.
  515.         else:
  516.             object = Object(ior)
  517.  
  518.     return object
  519.  
  520.     def _fnorb_override_options(self, options):
  521.     """ Override ORB options. """
  522.     
  523.     self.__lk.acquire()
  524.     self.__options.update(options)
  525.     options = self.__options.copy()
  526.     self.__lk.release()
  527.  
  528.     return options
  529.  
  530.     def _fnorb_options(self):
  531.     """ Return the ORB options in a dictionary. """
  532.  
  533.     self.__lk.acquire()
  534.     options = self.__options.copy()
  535.     self.__lk.release()
  536.  
  537.     return options
  538.  
  539.     #########################################################################
  540.     # Private interface.
  541.     #########################################################################
  542.  
  543.     def __get_options(self, argv):
  544.     """ Get any ORB options.
  545.  
  546.     ORB options can be specified via a configuration file, environment
  547.     variables, or the command-line (in order of increasing precedence).
  548.  
  549.     """
  550.     # Start with a dictionary of required default options.
  551.     options = {'Threading Model': 'Reactive', 'Thread Pool Size': '10'}
  552.  
  553.     # Get any options specified on the command line.
  554.     command_line = self.__get_command_line_options(argv)
  555.  
  556.     # Get any options specified via environment variables.
  557.     environment = self.__get_environment_options()
  558.  
  559.     # Does the command line contain the name of a configuration file?
  560.     if command_line.has_key('ConfigFile'):
  561.         # Read the options from the configuration file.
  562.         config_file = self.__get_config_options(command_line['ConfigFile'])
  563.  
  564.     # How about the environment?
  565.     elif environment.has_key('ConfigFile'):
  566.         # Read the options from the configuration file.
  567.         config_file = self.__get_config_options(environment['ConfigFile'])
  568.  
  569.     # Otherwise, there is no configuration file.
  570.     else:
  571.         config_file = {}
  572.  
  573.     # Now lets put them all together, starting with least precedence.
  574.     options.update(config_file)
  575.     options.update(environment)
  576.     options.update(command_line)
  577.  
  578.     return options
  579.  
  580.     def __get_command_line_options(self, argv):
  581.     """ Get any options specified on the command line. """
  582.  
  583.     # Work on a copy of the command line arguments.
  584.     args = argv[:]
  585.     
  586.     # Command line arguments used by the ORB are stripped from the list.
  587.     # We accomplish this by first emptying the list and then putting back
  588.     # any non-ORB arguments!
  589.     #
  590.     # Empty the list without the destroying the list object itself.
  591.     del argv[:]
  592.  
  593.     # For convenience we return any ORB options in a dictionary.
  594.     options = {}
  595.  
  596.     i = 0
  597.     while i < len(args):
  598.         arg = args[i]
  599.  
  600.         if regex.match('--ORBconfig-file=.*', arg) != -1:
  601.         value = arg[string.find(arg, '=') + 1:]
  602.         options['ConfigFile'] = value
  603.  
  604.         elif regex.match('--ORBinterface-repository=.*', arg) != -1:
  605.         value = arg[string.find(arg, '=') + 1:]
  606.         options['Interface Repository'] = value
  607.  
  608.         elif regex.match('--ORBnaming-service=.*', arg) != -1:
  609.         value = arg[string.find(arg, '=') + 1:]
  610.         options['Naming Service'] = value
  611.  
  612.         elif regex.match('--ORBthreading-model=.*', arg) != -1:
  613.         value = arg[string.find(arg, '=') + 1:]
  614.         options['Threading Model'] = value
  615.  
  616.         elif regex.match('--ORBthread-pool-size=.*', arg) != -1:
  617.         value = arg[string.find(arg, '=') + 1:]
  618.         options['Thread Pool Size'] = value
  619.  
  620.         else:
  621.         argv.append(arg)
  622.  
  623.         i = i + 1
  624.  
  625.     return options
  626.  
  627.     def __get_environment_options(self):
  628.     """ Get any options specified via environment variables. """
  629.  
  630.     options = {}
  631.  
  632.     if os.environ.has_key('FNORB_CONFIG_FILE'):
  633.         options['ConfigFile'] = os.environ['FNORB_CONFIG_FILE']
  634.  
  635.     if os.environ.has_key('FNORB_INTERFACE_REPOSITORY'):
  636.         options['Interface Repository'] = os.environ['FNORB_INTERFACE_REPOSITORY']
  637.     if os.environ.has_key('FNORB_NAMING_SERVICE'):
  638.         options['Naming Service'] = os.environ['FNORB_NAMING_SERVICE']
  639.  
  640.     if os.environ.has_key('FNORB_THREADING_MODEL'):
  641.         options['Threading Model'] = os.environ['FNORB_THREADING_MODEL']
  642.  
  643.     if os.environ.has_key('FNORB_THREAD_POOL_SIZE'):
  644.         options['Thread Pool Size'] = os.environ['FNORB_THREAD_POOL_SIZE']
  645.  
  646.     return options
  647.  
  648.     def __get_config_options(self, filename):
  649.     """ Get any options specified via a configuration file. """
  650.  
  651.     options = {}
  652.     try:
  653.         # Read the configuration file as lines of text.
  654.         lines = open(filename).readlines()
  655.  
  656.         for line in lines:
  657.         # If the line starts with a hash ('#') then it is a comment.
  658.         if line[0] != '#':
  659.             # Find the position of the first colon (':').
  660.             colon = string.find(line, ':')
  661.  
  662.             # If there is no colon then just ignore the line.
  663.             if colon != -1:
  664.             # Get the key and value.
  665.             key = string.strip(line[:colon])
  666.             value = string.strip(line[colon+1:])
  667.  
  668.             # Add them to the dictionary.
  669.             options[key] = value
  670.  
  671.     # We get an IOError if the file doesn't exist or is not readable!
  672.     except IOError:
  673.         pass
  674.  
  675.     return options
  676.  
  677.     def __initialise_protocols(self):
  678.     """ Initialise the GIOP transport protocols. """
  679.  
  680.     # fixme: Currently only IIOP!
  681.     modules = ['IIOPProtocol']
  682.  
  683.     protocols = []
  684.     for protocol in modules:
  685.         try:
  686.         # Import the module.
  687.         exec('from Fnorb.orb import %s' % protocol)
  688.  
  689.         # Find the class that implements the protocol (derived from the
  690.         # base class 'Protocol.'Protocol').
  691.         klass = eval('%s.%s' % (protocol, protocol))
  692.  
  693.         # Add the protocol to the list of protocols available to the
  694.         # ORB.
  695.         protocols.append(apply(klass, ()))
  696.  
  697.         # If anything goes wrong with the import then just ignore the
  698.         # protocol.
  699.         except:
  700.         pass
  701.  
  702.     # If there are no protocols then we can't do much!
  703.     assert(len(protocols) > 0)
  704.  
  705.     return protocols
  706.  
  707.     def __initialise_interface_repository(self):
  708.     """ Initialise the interface repository! """
  709.  
  710.     # Get the UOL for the interface repository.
  711.     if self.__options.has_key('Interface Repository'):
  712.         # Resolve the UOL to create an active object reference for the
  713.         # interface repository.
  714.         ir = self.__resolve_uol(self.__options['Interface Repository'])
  715.  
  716.     # No UOL for the interface repository 8^(
  717.     else:
  718.         # If there's no UOL then there sure as hell ain't no interface
  719.         # repository!
  720.         ir = None
  721.  
  722.     return ir
  723.  
  724.     def __initialise_naming_service(self):
  725.     """ Initialise the naming service! """
  726.  
  727.     # fixme: We do the import here to get around the old circular import
  728.     # problems!
  729.     from Fnorb.cos.naming import CosNaming
  730.  
  731.     # Get the UOL for the naming service.
  732.     if self.__options.has_key('Naming Service'):
  733.         # Resolve the UOL to create an active object reference for the
  734.         # naming service.
  735.         ns = self.__resolve_uol(self.__options['Naming Service'], 1)
  736.  
  737.     # No UOL for the naming service 8^(
  738.     else:
  739.         # If there's no UOL then there sure as hell ain't no naming
  740.         # service!
  741.         ns = None
  742.  
  743.     return ns
  744.  
  745.     def __resolve_uol(self, uol, bootstrap=0):
  746.     """ Resolve a UOL to produce a 'live' object reference.
  747.  
  748.     UOL's can currently be either:-
  749.     
  750.     1) 'file:/the/pathname/of/a/file/containing/a/UOL'
  751.     2) 'IOR:a stringified object reference'
  752.     3) 'http://a/URL/pointing/to/a/text/document/containing/a/UOL'
  753.     4) 'name:/a/path/through/the/naming/service'
  754.  
  755.     Naming service names are not allowed if this is a 'boostrap' UOL (ie.
  756.     if we are resolving the UOL of the naming service!).
  757.  
  758.     """
  759.     # Stringified IOR.
  760.     if string.lower(uol[:4]) == 'ior:':
  761.         # Convert the stringified IOR into an IOR instance.
  762.         ior = new.instance(IOP.IOR, {})
  763.         ior._fnorb_from_string(uol)
  764.  
  765.         # Create an object reference from the IOR.
  766.         #
  767.         # Note that the call to '_fnorb_ior_to_object' does not attempt to
  768.         # connect to the remote object,  and it will succeed even if the
  769.         # object reference is 'stale' i.e even if the remote object no
  770.         # longer exists.
  771.         object = self._fnorb_ior_to_object(ior)
  772.  
  773.     # Filename.
  774.     elif string.lower(uol[:5]) == 'file:':
  775.         try:
  776.         file = open(uol[5:])
  777.         uol = string.strip(file.read())
  778.         file.close()
  779.  
  780.         # Recursively resolve the UOL.
  781.         object = self.__resolve_uol(uol, bootstrap)
  782.  
  783.         # We get an IOError if the file doesn't exist or is not readable!
  784.         except IOError:
  785.         object = None
  786.  
  787.     # URL.
  788.     elif string.lower(uol[:5]) == 'http:':
  789.         # Do the import here 'cos I'm not sure how much this will actually
  790.         # be used.
  791.         import urllib
  792.         try:
  793.         file = urllib.urlopen(uol)
  794.         uol = string.strip(file.read())
  795.         file.close()
  796.  
  797.         # Recursively resolve the UOL.
  798.         object = self.__resolve_uol(uol, bootstrap)
  799.  
  800.         except:
  801.         object = None
  802.  
  803.     # Naming service name.
  804.     elif string.lower(uol[:5]) == 'name:' and not bootstrap:
  805.         # Get a reference to the initial naming service context.
  806.         ctx = self.resolve_initial_references("NameService")
  807.  
  808.         # Create a naming service name from the string representation.
  809.         #
  810.         # fixme: This only works for names that contain components that
  811.         # do not use the 'kind' field (let's face it the 'kind' field
  812.         # was a crap idea anyway ;^)
  813.         #
  814.         # fixme: This should now be implemented as per the extended naming
  815.         # service specification.
  816.         name = Util._fnorb_string_to_name(uol)
  817.         
  818.         # Lookup the name.
  819.         object = ctx.resolve(name)
  820.  
  821.     else:
  822.         object = None
  823.  
  824.     return object
  825.  
  826.     def __is_local_object(self, ior):
  827.     """ Does the IOR reference an object in *this* ORB? """
  828.  
  829.     # Does the ORB have an object adapter initialised? (ie. are there any
  830.     # servants in this process?).
  831.     #
  832.     # fixme: Multiple object adapters?
  833.     if self.__object_adapter is not None:
  834.         # If so then we ask each protocol to examine the IOR and see if
  835.         # they think that the servant is in this process.
  836.         for protocol in self.__protocols:
  837.         if protocol.is_local(ior):
  838.             result = 1
  839.             break
  840.  
  841.         else:
  842.         result = 0
  843.  
  844.     # If there is no object adaptor then there sure as hell ain't no
  845.     # servants!
  846.     else:
  847.         result = 0
  848.         
  849.     return result
  850.  
  851.  
  852. class Object:
  853.     """ CORBA Object References (implementation of the Object interface). """
  854.  
  855.     # Repository id attribute.
  856.     _FNORB_ID = 'IDL:omg.org/CORBA/Object:1.0'
  857.  
  858.     def __init__(self, ior):
  859.     """ Constructor.
  860.  
  861.     'ior' is the IOR used to construct the object reference.
  862.  
  863.     """
  864.     self._ior = ior
  865.  
  866.     # If the IOR has an empty list of profiles then it is a NIL object
  867.     # reference!
  868.     if len(ior.profiles) == 0:
  869.         self.__is_nil = 1
  870.  
  871.     else:
  872.         # We can only use the object if it lives in an ORB that supports
  873.         # IIOP!  If the object reference does NOT contain an IIOP profile,
  874.         # then this call will raise an 'INV_OBJREF' exception.
  875.         self.__iiop_profile = ior._fnorb_iiop_profile()
  876.  
  877.         # Get a reference to the GIOP Client Manager.
  878.         gcm = GIOPClientManager.GIOPClientManager_init()
  879.  
  880.         # Get a GIOP client that is connected to the remote object.
  881.         self.__client = gcm.get_client(ior)
  882.         self.__is_nil = 0
  883.  
  884.     # The following flag indicates whether or not we have received a
  885.     # 'LOCATION_FORWARD' reply from the remote object.
  886.     self.__forwarded = 0
  887.  
  888.     # Mutex to make access to the object reference thread-safe (this is a
  889.     # 'protected' attribute as it is used by the derived class
  890.     # 'LocalObject').
  891.     self._lk = fnorb_thread.allocate_lock()
  892.  
  893.     return
  894.  
  895.     def __del__(self):
  896.     """ Destructor. """
  897.     
  898.     if not self.__is_nil:
  899.         # Get a reference to the GIOP Client Manager.
  900.         gcm = GIOPClientManager.GIOPClientManager_init()
  901.  
  902.         # Let the Connection Manager know that we have finished with the
  903.         # GIOP client (GIOP clients are reference counted by the
  904.         # Connection Manager so that they can be cleaned up when
  905.         # necessary).
  906.         gcm.delete_client(self._ior)
  907.  
  908.     return
  909.  
  910.     #########################################################################
  911.     # Client-side CORBA Object interface.
  912.     #########################################################################
  913.  
  914.     def _is_nil(self):
  915.     """ True if the object reference is nil, otherwise false.
  916.  
  917.     A Nil object reference contains an empty set of profiles!
  918.  
  919.     """
  920.     return self.__is_nil
  921.  
  922.     def _hash(self):
  923.     """ Return a hash value for the object reference. """
  924.  
  925.     self._lk.acquire()
  926.     if self.__is_nil:
  927.         hash_value = hash(None)
  928.  
  929.     else:
  930.         hash_value = abs(hash(self._ior))
  931.     self._lk.release()
  932.  
  933.     return hash_value
  934.  
  935.     def _create_request(self, operation, inputs, outputs, exceptions, **kw):
  936.     """ Create a DII Request. """
  937.  
  938.     return apply(Request,
  939.              (self, operation, inputs, outputs, exceptions), kw)
  940.  
  941.     def _narrow(self, klass):
  942.     """ Narrow the object reference to the specified interface type. """
  943.  
  944.     # fixme: This assumes the interface stub is loaded. Not a bad
  945.     # assumption!
  946.     if self._is_a(klass._FNORB_ID):
  947.         # Create a new IOR containing the specified interface type.
  948.         self._lk.acquire()
  949.         result = klass(IOP.IOR(klass._FNORB_ID, self._ior.profiles))
  950.         self._lk.release()
  951.  
  952.     else:
  953.         result = None
  954.  
  955.     return result
  956.         
  957.     #########################################################################
  958.     # Server-side CORBA Object interface.
  959.     #########################################################################
  960.  
  961.     def _is_a(self, *args, **kw):
  962.         """ Operation: IDL:omg.org/CORBA/Object/is_a:1.0 """
  963.  
  964.         # Typecodes for 'in' and 'inout' parameters.
  965.         inputs = [CORBA.TC_string]
  966.  
  967.         # Typecodes for the result, 'inout' and 'out' parameters.
  968.         outputs = [CORBA.TC_boolean]
  969.  
  970.         # Create a request object.
  971.         request = self._create_request("_is_a", inputs, outputs, [])
  972.  
  973.         # Make the request!
  974.         apply(request.invoke, args, kw)
  975.  
  976.         # Return the results.
  977.         return request.results()
  978.  
  979.     def _non_existent(self, *args, **kw):
  980.         """ Operation: IDL:omg.org/CORBA/Object/non_existent:1.0 """
  981.  
  982.         # Typecodes for the result, 'inout' and 'out' parameters.
  983.         outputs = [CORBA.TC_boolean]
  984.  
  985.         # Create a request object.
  986.         request = self._create_request("_non_existent", [], outputs, [])
  987.  
  988.         # Make the request!
  989.         apply(request.invoke, args, kw)
  990.  
  991.         # Return the results.
  992.         return request.results()
  993.  
  994.     def _interface(self, *args, **kw):
  995.         """ Operation: IDL:omg.org/CORBA/Object/_interface:1.0 """
  996.  
  997.         # Typecodes for the result, 'inout' and 'out' parameters.
  998.         outputs = [CORBA.typecode("IDL:omg.org/CORBA/InterfaceDef:1.0")]
  999.  
  1000.         # Create a request object.
  1001.         request = self._create_request("_interface", [], outputs, [])
  1002.  
  1003.         # Make the request!
  1004.         apply(request.invoke, args, kw)
  1005.  
  1006.         # Return the results.
  1007.         return request.results()
  1008.  
  1009.     #########################################################################
  1010.     # Non-CORBA interface.
  1011.     #########################################################################
  1012.  
  1013.     def _fnorb_ior(self):
  1014.     """ Return the IOR of the object reference. """
  1015.  
  1016.     self._lk.acquire()
  1017.     ior = self._ior
  1018.     self._lk.release()
  1019.  
  1020.     return ior
  1021.  
  1022.     def _fnorb_client(self):
  1023.     """ Return the IIOP client that is connected to the remote object. """
  1024.  
  1025.     self._lk.acquire()
  1026.     client = self.__client
  1027.     self._lk.release()
  1028.  
  1029.     return client
  1030.  
  1031.     def _fnorb_forwarded(self):
  1032.     """ Have we received a 'LOCATION_FORWARD' reply? """
  1033.  
  1034.     self._lk.acquire()
  1035.     forwarded = self.__forwarded
  1036.     self._lk.release()
  1037.  
  1038.     return forwarded
  1039.  
  1040.     def _fnorb_forward(self, ior):
  1041.     """ 'Forward' the object reference to the specified IOR. """
  1042.  
  1043.     self._lk.acquire()
  1044.     self.__forwarded = 1
  1045.  
  1046.     # Get a reference to the GIOP Client Manager.
  1047.     gcm = GIOPClientManager.GIOPClientManager_init()
  1048.  
  1049.     # Get a GIOP client that is connected to the forwarded address.
  1050.     self.__client = gcm.get_client(ior)
  1051.     self._lk.release()
  1052.  
  1053.     return
  1054.  
  1055.     def _fnorb_unforward(self):
  1056.     """ 'Unforward' the object back to its original IOR!
  1057.  
  1058.     This method is called if the connection to the forwarded object fails.
  1059.  
  1060.     """
  1061.     self._lk.acquire()
  1062.     self.__forwarded = 0
  1063.  
  1064.     # Get a reference to the GIOP Client Manager.
  1065.     gcm = GIOPClientManager.GIOPClientManager_init()
  1066.  
  1067.     # Get a GIOP client that is connected to the original address.
  1068.     self.__client = gcm.get_client(self._ior)
  1069.     self._lk.release()
  1070.  
  1071.     return
  1072.  
  1073.     def _fnorb_marshal(self, cursor):
  1074.     """ Marshal the object reference onto an octet stream. """
  1075.  
  1076.     self._ior._fnorb_marshal(cursor)
  1077.     return
  1078.  
  1079.     #########################################################################
  1080.     # Convenience methods for getting at the object's IIOP profile!
  1081.     #########################################################################
  1082.  
  1083.     def _fnorb_iiop_profile(self):
  1084.     """ Return the IIOP profile from the object's IOR.
  1085.  
  1086.     This is a convenience/performance function to save DII routines
  1087.     having to scan the IOR every time.
  1088.  
  1089.     """
  1090.     # A NIL object reference doesn't even have any profiles!
  1091.     if self.__is_nil:
  1092.         raise INV_OBJREF() # System exception.
  1093.  
  1094.     return self.__iiop_profile
  1095.  
  1096.     def _fnorb_host(self):
  1097.     """ Return the hostname contained in the object's IIOP profile. """
  1098.  
  1099.     # A NIL object reference doesn't even have any profiles!
  1100.     if self.__is_nil:
  1101.         raise INV_OBJREF() # System exception.
  1102.  
  1103.     return self.__iiop_profile.host
  1104.  
  1105.     def _fnorb_port(self):
  1106.     """ Return the port number contained in the object's IIOP profile. """
  1107.  
  1108.     # A NIL object reference doesn't even have any profiles!
  1109.     if self.__is_nil:
  1110.         raise INV_OBJREF() # System exception.
  1111.  
  1112.     return self.__iiop_profile.port
  1113.  
  1114.     def _fnorb_object_key(self):
  1115.     """ Return the object key contained in the object's IIOP profile. """
  1116.  
  1117.     # A NIL object reference doesn't even have any profiles!
  1118.     if self.__is_nil:
  1119.         raise INV_OBJREF() # System exception.
  1120.  
  1121.     return self.__iiop_profile.object_key
  1122.  
  1123.  
  1124. class LocalObject(Object):
  1125.     """ CORBA Object References for local objects (ie. in *this* ORB). """
  1126.  
  1127.     def __init__(self, ior):
  1128.     """ Constructor.
  1129.  
  1130.     'ior' is the IOR used to construct the object reference.
  1131.  
  1132.     """
  1133.     self._ior = ior
  1134.  
  1135.     # Set the '_FNORB_ID' as for stub classes.
  1136.     self._FNORB_ID = self._ior.type_id
  1137.  
  1138.     # We can only use the object if it lives in an ORB that supports IIOP!
  1139.     # If the object reference does NOT contain an IIOP profile, then this
  1140.     # call will raise an 'INV_OBJREF' exception.
  1141.     self._iiop_profile = ior._fnorb_iiop_profile()
  1142.  
  1143.     # Local object references CANNOT be nil!
  1144.     self.__is_nil = 0
  1145.  
  1146.     # Mutex to make access to the object reference thread-safe.
  1147.     #
  1148.     # This is a 'protected' attribute as it is used by methods in the
  1149.     # base class 'Object'.
  1150.     self._lk = fnorb_thread.allocate_lock()
  1151.  
  1152.     return
  1153.  
  1154.     def __del__(self):
  1155.     """ Destructor.
  1156.  
  1157.     Override the destructor in the base class.
  1158.  
  1159.     """
  1160.     pass
  1161.  
  1162.     def __getattr__(self, name):
  1163.     """ Pass method invocations onto the local implementation. """
  1164.  
  1165.     # Get a reference to the BOA.
  1166.     boa = BOA.BOA_init()
  1167.     
  1168.     # Lookup the implementation.
  1169.     impl = boa._fnorb_get_implementation(self._iiop_profile.object_key)
  1170.  
  1171.     # Lookup the attribute on the implementation.
  1172.     return getattr(impl, name)
  1173.  
  1174.     #########################################################################
  1175.     # Client-side CORBA Object interface.
  1176.     #########################################################################
  1177.  
  1178.     def _create_request(self, operation, inputs, outputs, exceptions, **kw):
  1179.      """ Create a local DII Request. """
  1180.  
  1181.      return apply(LocalRequest,
  1182.               (self, operation, inputs, outputs, exceptions), kw)
  1183.  
  1184.     #########################################################################
  1185.     # Server-side CORBA interface.
  1186.     #########################################################################
  1187.  
  1188.     def _is_a(self, logical_type_id):
  1189.     """ Return true if the object reference is of the specified type. """
  1190.  
  1191.     # Get a reference to the BOA.
  1192.     boa = BOA.BOA_init()
  1193.     
  1194.     # Lookup the implementation.
  1195.     impl = boa._fnorb_get_implementation(self._iiop_profile.object_key)
  1196.  
  1197.     return self.__is_a(impl.__class__, logical_type_id)
  1198.  
  1199.     def _non_existent(self):
  1200.     """ Return true if the object has been destroyed. """
  1201.  
  1202.     # Get a reference to the BOA.
  1203.     boa = BOA.BOA_init()
  1204.     
  1205.     return not boa._fnorb_object_here(self._iiop_profile.object_key)
  1206.  
  1207.     def _interface(self):
  1208.     """ Return the repository object that defines the interface.
  1209.  
  1210.     The ORB must have access to an Interface Repository for this method
  1211.     to succeed.
  1212.  
  1213.     """
  1214.     # Get a reference to the BOA.
  1215.     boa = BOA.BOA_init()
  1216.     
  1217.     # Lookup the implementation.
  1218.     impl = boa._fnorb_get_implementation(self._iiop_profile.object_key)
  1219.  
  1220.     # Get a reference to the ORB that we are living in.
  1221.     orb = ORB_init()
  1222.  
  1223.     # Get a reference to the Interface Repository.
  1224.     ir = orb.resolve_initial_references('InterfaceRepository')
  1225.  
  1226.     # Lookup our interface id to get the interface definition object.
  1227.     return ir.lookup_id(impl._FNORB_ID)
  1228.  
  1229.     #########################################################################
  1230.     # Private interface.
  1231.     #########################################################################
  1232.  
  1233.     def __is_a(self, klass, logical_type_id):
  1234.     """ Return true if the class is an implementation of the type. """
  1235.  
  1236.     if klass._FNORB_ID == logical_type_id:
  1237.         result = 1
  1238.  
  1239.     else:
  1240.         for base in klass.__bases__:
  1241.         if self.__is_a(base, logical_type_id):
  1242.             result = 1
  1243.             break
  1244.  
  1245.         else:
  1246.         result = 0
  1247.  
  1248.     return result
  1249.  
  1250.  
  1251. class Object_skel:
  1252.     """ CORBA Object Skeletons. """
  1253.  
  1254.     # Repository id attribute.
  1255.     _FNORB_ID = 'IDL:omg.org/CORBA/Object:1.0'
  1256.  
  1257.     def __init__(self):
  1258.       """ Constructor.
  1259.  
  1260.     Normally, skeleton implementations are not required to call this
  1261.     constructor as initialisation is forced via '__getattr__'. However, if
  1262.     the implementation overrides '__getattr__' it must call this
  1263.     constructor as part of its own initialisation.
  1264.  
  1265.     """
  1266.  
  1267.       self.__initialise()
  1268.       return
  1269.  
  1270.     def __getattr__(self, name):
  1271.      """ Trap the first attribute access to force initialisation! """
  1272.  
  1273.     # Force initialisation.
  1274.     #
  1275.     # fixme: Is this thread-safe - I think not!!!!!!!!!!
  1276.      if not self.__dict__.has_key('_initialised'):
  1277.          self.__initialise()
  1278.  
  1279.     # Provide the usual 'getattr' semantics!
  1280.      if not self.__dict__.has_key(name):
  1281.          raise AttributeError, name
  1282.  
  1283.      return self.__dict__[name]
  1284.  
  1285.     #########################################################################
  1286.     # Client-side CORBA Object interface.
  1287.     #########################################################################
  1288.  
  1289.     def _is_nil(self):
  1290.     """ True if the object reference is nil, otherwise false.
  1291.  
  1292.     Implementations are never nil!
  1293.  
  1294.     """
  1295.     return 0
  1296.  
  1297.     #########################################################################
  1298.     # Server-side CORBA interface.
  1299.     #########################################################################
  1300.  
  1301.     def _is_a(self, logical_type_id):
  1302.     """ Return true if the object reference is of the specified type. """
  1303.  
  1304.     return self.__is_a(self.__class__, logical_type_id)
  1305.  
  1306.     def _interface(self):
  1307.     """ Return the repository object that defines the interface.
  1308.  
  1309.     The ORB must have access to an Interface Repository for this method
  1310.     to succeed.
  1311.  
  1312.     """
  1313.     # Get a reference to the ORB that we are living in.
  1314.     orb = ORB_init()
  1315.  
  1316.     # Get a reference to the Interface Repository.
  1317.     ir = orb.resolve_initial_references('InterfaceRepository')
  1318.  
  1319.     # Lookup our interface id to get the interface definition object.
  1320.     return ir.lookup_id(self._FNORB_ID)
  1321.  
  1322.     #########################################################################
  1323.     # Skeleton methods for the server-side CORBA interface.
  1324.     #########################################################################
  1325.  
  1326.     def _skel__is_a(self, server_request):
  1327.         """ Operation: IDL:omg.org/CORBA/Object/_is_a:1.0 """
  1328.  
  1329.         # Typecodes for 'in' and 'inout' parameters.
  1330.         inputs = [CORBA.TC_string]
  1331.  
  1332.         # Typecodes for the result, 'inout' and 'out' parameters.
  1333.         outputs = [CORBA.TC_boolean]
  1334.  
  1335.         # Initialise the server request object.
  1336.         server_request.initialise(inputs, outputs, [])
  1337.  
  1338.         # Unmarshal the arguments to the request.
  1339.         arguments = server_request.arguments()
  1340.  
  1341.         # Invoke the implementation.
  1342.         results = apply(self._is_a, arguments)
  1343.  
  1344.         # Create the reply.
  1345.         server_request.results(results)
  1346.  
  1347.         return
  1348.  
  1349.     def _skel__interface(self, server_request):
  1350.         """ Operation: IDL:omg.org/CORBA/Object/_interface:1.0 """
  1351.  
  1352.         # Typecodes for the result, 'inout' and 'out' parameters.
  1353.         outputs = [CORBA.typecode("IDL:omg.org/CORBA/InterfaceDef:1.0")]
  1354.  
  1355.         # Initialise the server request object.
  1356.         server_request.initialise([], outputs, [])
  1357.  
  1358.         # Invoke the implementation.
  1359.         results = apply(self._interface, ())
  1360.  
  1361.         # Create the reply.
  1362.         server_request.results(results)
  1363.  
  1364.         return
  1365.  
  1366.     #########################################################################
  1367.     # Fnorb-specific interface.
  1368.     #########################################################################
  1369.  
  1370.     def _fnorb_ior(self):
  1371.      """ Return the IOR for the current thread. """
  1372.  
  1373.     # Get the object key appropriate for the current thread.
  1374.     object_key = self._fnorb_object_key()
  1375.  
  1376.     # Create an IOR using the object key and the object's interface
  1377.     # repository id.
  1378.     boa = BOA.BOA_init()
  1379.     ior = boa._fnorb_create_ior(object_key, self._FNORB_ID)
  1380.  
  1381.      return ior
  1382.  
  1383.     def _fnorb_object_key(self):
  1384.     """ Return the object key for the current thread. """
  1385.  
  1386.     # Get the object key appropriate for the current thread.
  1387.     self.__lk.acquire()
  1388.     try:
  1389.         object_key = self.__object_keys[fnorb_thread.get_ident()]
  1390.  
  1391.     # fixme: Should we pick *any* of our object keys here?
  1392.     except KeyError:
  1393.         raise "No object key for this thread!"
  1394.     self.__lk.release()
  1395.  
  1396.     return object_key
  1397.  
  1398.     def _fnorb_add_object_key(self, object_key):
  1399.     """ Add the object key to our key table. """
  1400.  
  1401.     self.__lk.acquire()
  1402.     self.__object_keys[fnorb_thread.get_ident()] = object_key
  1403.     self.__lk.release()
  1404.  
  1405.     return
  1406.  
  1407.     def _fnorb_delete_object_key(self):
  1408.     """ Delete the object key for the current thread. """
  1409.  
  1410.     self.__lk.acquire()
  1411.     try:
  1412.         del self.__object_keys[fnorb_thread.get_ident()]
  1413.  
  1414.     except KeyError:
  1415.         pass
  1416.     self.__lk.release()
  1417.  
  1418.     return
  1419.  
  1420.     def _fnorb_marshal(self, cursor):
  1421.     """ Marshal the object reference onto an octet stream. """
  1422.     
  1423.     # Create the appropriate IOR for the current calling context.
  1424.     ior = self._fnorb_ior()
  1425.  
  1426.     # Marshal the IOR onto the octet stream.
  1427.     ior._fnorb_marshal(cursor)
  1428.  
  1429.     return
  1430.  
  1431.     #########################################################################
  1432.     # Private interface.
  1433.     #########################################################################
  1434.  
  1435.     def __initialise(self):
  1436.     """ (Pseudo) Constructor! """
  1437.  
  1438.     # A single implementation instance can be referred to by many
  1439.     # different object references (ie. by many different object keys).
  1440.     # Therefore, to determine the object key for any individual operation
  1441.     # invocation, we store each object key in a dictionary keyed on
  1442.     # thread id. In non-threaded environments, there will obviously only
  1443.     # be at most one entry in the dictionary.
  1444.     self.__object_keys = {} # {ThreadId: ObjectKey}
  1445.  
  1446.     # A mutex to make access to the object key dictionary thread-safe.
  1447.     self.__lk = fnorb_thread.allocate_lock()
  1448.  
  1449.     # A flag to indicate that we have been initialised!
  1450.     self._initialised = 1
  1451.  
  1452.     return
  1453.  
  1454.     def __is_a(self, klass, logical_type_id):
  1455.     """ Return true if the class is an implementation of the type. """
  1456.  
  1457.     # We check for the existence of the '_FNORB_ID' attribute first to
  1458.     # allow implementations to multiply inherit from classes that are
  1459.     # nothing to do with Fnorb.
  1460.     if hasattr(klass, '_FNORB_ID') and klass._FNORB_ID == logical_type_id:
  1461.         result = 1
  1462.  
  1463.     else:
  1464.         for base in klass.__bases__:
  1465.         if self.__is_a(base, logical_type_id):
  1466.             result = 1
  1467.             break
  1468.  
  1469.         else:
  1470.         result = 0
  1471.  
  1472.     return result
  1473.  
  1474.  
  1475. # Standard/built-in modules.
  1476. import new, os, regex, string
  1477.  
  1478. # Fnorb modules.
  1479. import BOA, GIOPClientManager, IOP, TypeManager
  1480.  
  1481. # The following modules are defined in the spec. as being part of the CORBA
  1482. # module.
  1483. from   DII                 import *
  1484. from   DSI                 import *
  1485. from   TypeCode            import *
  1486.  
  1487. # The following modules also defined in the spec. as being part of the CORBA
  1488. # module, but they rely on definitions in the TypeCode module.
  1489. from   Any                 import *
  1490. from   InterfaceRepository import *
  1491.  
  1492. #############################################################################
  1493.