home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / fnb101.zip / Lib / site-packages / Fnorb / orb / GIOPServer.py < prev    next >
Text File  |  1999-06-28  |  11KB  |  355 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/GIOPServer.py,v $
  31. # Version:      @(#)$RCSfile: GIOPServer.py,v $ $Revision: 1.11 $
  32. #
  33. #############################################################################
  34. """ GIOPServer class. """
  35.  
  36.  
  37. # Fnorb modules.
  38. import fnorb_thread, CORBA, GIOP, GIOPServerWorker, OctetStream, Util
  39.  
  40.  
  41. class GIOPServer:
  42.     """ GIOPServer class. """
  43.  
  44.     def __init__(self, connection):
  45.     """ Constructor.
  46.  
  47.     'connection' is a connection to a remote ORB.
  48.  
  49.     """
  50.     # Get the object adapter used by the ORB.
  51.     #
  52.     # fixme: We get a reference to the object adapter here for the sake
  53.     # of efficiency, but is this dynamic enough?
  54.     #
  55.     # fixme: Should this be passed as a parameter to the constructor?
  56.     self.__oa = CORBA.ORB_init()._fnorb_object_adapter()
  57.  
  58.     # Get a reference to the factory for GIOP server workers.
  59.     cwf = GIOPServerWorker.GIOPServerWorkerFactory_init()
  60.  
  61.     # Create a new GIOP server worker (the concrete type of which will
  62.     # be determined by the threading model).
  63.     self.__worker = cwf.create_worker(self, connection)
  64.  
  65.     # Flag set when our worker is closed.
  66.     self.__closed = 0
  67.  
  68.     # A mutex to make access to the server thread-safe.
  69.     self.__lk = fnorb_thread.allocate_lock()
  70.  
  71.     return
  72.  
  73.     def pseudo__del__(self):
  74.     """ Pseudo destructor to remove circular references. """
  75.  
  76.     self.__lk.acquire()
  77.  
  78.     # Remove the (circular) reference to our worker.
  79.     del self.__worker
  80.  
  81.     # All done!
  82.     self.__closed = 1
  83.  
  84.     self.__lk.release()
  85.  
  86.     return
  87.  
  88.     #########################################################################
  89.     # GIOPServer interface.
  90.     #########################################################################
  91.  
  92.     def process_giop_message(self, message):
  93.     """ Process a GIOP message.
  94.  
  95.     This method is called by our worker when it has received a GIOP
  96.     message.
  97.  
  98.     """
  99.     # Get a cursor for the message.
  100.     cursor = message.cursor()
  101.  
  102.     # Get the GIOP message header.
  103.     giop_header = message.header()
  104.  
  105.     # Make sure that the header has the right magic and that we are talking
  106.     # the same version of GIOP.
  107.     if giop_header.magic != Util.MAGIC \
  108.        or giop_header.GIOP_version.major != Util.GIOP_VERSION_MAJOR \
  109.        or giop_header.GIOP_version.minor != Util.GIOP_VERSION_MINOR:
  110.         self.__message_error()
  111.  
  112.     # Handle each GIOP message type.
  113.     elif giop_header.message_type == GIOP.Request.value():
  114.         # Unmarshal the GIOP request header.
  115.         tc = CORBA.typecode('IDL:omg.org/GIOP/RequestHeader:1.0')
  116.         request_header = tc._fnorb_unmarshal_value(cursor)
  117.  
  118.         # Pass the message to the active OA to invoke the operation on the
  119.         # appropriate object implementation. The OA will call one of
  120.         # our callback methods iff there is a reply to send.
  121.         self.__oa._fnorb_request((self, request_header, cursor))
  122.         
  123.     elif giop_header.message_type == GIOP.CancelRequest.value():
  124.         # fixme: We just ignore these at the moment!
  125.         pass
  126.  
  127.     elif giop_header.message_type == GIOP.LocateRequest.value():
  128.         # Unmarshal the GIOP locate request header.
  129.         tc = CORBA.typecode('IDL:omg.org/GIOP/LocateRequestHeader:1.0')
  130.         request_header = tc._fnorb_unmarshal_value(cursor)
  131.  
  132.         # See if the object is here!
  133.         if self.__oa._fnorb_object_here(request_header.object_key):
  134.         status = GIOP.OBJECT_HERE
  135.         else:
  136.         status = GIOP.UNKNOWN_OBJECT
  137.  
  138.         # Create and send the locate reply.
  139.         self.__locate_reply(request_header, status)
  140.  
  141.     elif giop_header.message_type == GIOP.MessageError.value():
  142.         # What can we do here?  Just ignore the message!
  143.         pass
  144.  
  145.     # Some crappy message or other ;^)
  146.     else:
  147.         self.__message_error()
  148.     
  149.     return
  150.  
  151.     def close_connection(self):
  152.     """ Close down the connection.
  153.  
  154.     Currently, Fnorb does not close down servers, so this is not used.
  155.  
  156.     """
  157.      # Send the close connection message.
  158.      self.__close_connection()
  159.  
  160.     # In multi-thread mode, if the client has disconnected then the worker
  161.     # will be 'None'.
  162.     worker = self.__get_worker()
  163.     if worker is not None:
  164.         worker.close_connection()
  165.  
  166.     return
  167.     
  168.     #########################################################################
  169.     # Object adapter callback interface.
  170.     #########################################################################
  171.  
  172.     def reply(self, request_header, server_request):
  173.     """ Create and send a successful reply message. """
  174.  
  175.     # Start the reply.
  176.     reply = OctetStream.GIOPMessage(type=GIOP.Reply)
  177.     cursor = reply.cursor()
  178.  
  179.     # Create the reply header.
  180.     reply_header = GIOP.ReplyHeader(request_header.service_context,
  181.                     request_header.request_id,
  182.                     GIOP.NO_EXCEPTION)
  183.  
  184.     # Marshal it onto the octet stream.
  185.     tc = CORBA.typecode('IDL:omg.org/GIOP/ReplyHeader:1.0')
  186.     tc._fnorb_marshal_value(cursor, reply_header)
  187.  
  188.     # Marshal the results onto the octet stream.
  189.     self.__marshal_results(cursor,
  190.                    server_request.outputs(),
  191.                    server_request._fnorb_results())
  192.     # Send it!
  193.     self.__send(reply)
  194.  
  195.     return
  196.  
  197.     def user_exception(self, request_header, server_request):
  198.     """ Create and send a user exception reply message. """
  199.  
  200.     # Start the reply.
  201.     reply = OctetStream.GIOPMessage(type=GIOP.Reply)
  202.     cursor = reply.cursor()
  203.  
  204.     # Create the reply header.
  205.     reply_header = GIOP.ReplyHeader(request_header.service_context,
  206.                     request_header.request_id,
  207.                     GIOP.USER_EXCEPTION)
  208.  
  209.     # Marshal it onto the octet stream.
  210.     tc = CORBA.typecode('IDL:omg.org/GIOP/ReplyHeader:1.0')
  211.     tc._fnorb_marshal_value(cursor, reply_header)
  212.  
  213.     # Get the exception that was raised in response to the server request.
  214.     ex = server_request._fnorb_exception()
  215.  
  216.     # Try to find a matching exception.
  217.     for typecode in server_request.exceptions():
  218.         if ex._FNORB_ID == typecode.id():
  219.         break
  220.  
  221.     # If there is no matching exception then raise an 'UNKNOWN' system
  222.     # exception.
  223.     else:
  224.         raise CORBA.UNKNOWN() # System exception.
  225.  
  226.     # Marshal the repository id of the exception followed by its members.
  227.     cursor.marshal('s', typecode.id())
  228.     typecode._fnorb_marshal_value(cursor, ex)
  229.  
  230.     # Send it.
  231.     self.__send(reply)
  232.  
  233.     return
  234.     
  235.     def system_exception(self, request_header, ex):
  236.     """ Create and send a system exception reply message. """
  237.  
  238.     # Create an octet stream and get a cursor for it.
  239.     reply = OctetStream.GIOPMessage(type=GIOP.Reply)
  240.     cursor = reply.cursor()
  241.  
  242.     # Create the reply header.
  243.     reply_header = GIOP.ReplyHeader(request_header.service_context,
  244.                     request_header.request_id,
  245.                     GIOP.SYSTEM_EXCEPTION)
  246.  
  247.     # Marshal it onto the octet stream.
  248.     tc = CORBA.typecode('IDL:omg.org/GIOP/ReplyHeader:1.0')
  249.     tc._fnorb_marshal_value(cursor, reply_header)
  250.  
  251.     # Marshal the system exception onto the octet stream.
  252.     cursor.marshal('s', "IDL:omg.org/CORBA/%s:1.0" % ex.__class__.__name__)
  253.     ex._fnorb_marshal(cursor)
  254.  
  255.     # Send it.
  256.     self.__send(reply)
  257.  
  258.     return
  259.  
  260.     #########################################################################
  261.     # Private interface.
  262.     #########################################################################
  263.  
  264.     def __get_worker(self):
  265.     """ Get our GIOP server worker. """
  266.  
  267.     self.__lk.acquire()
  268.     try:
  269.         if self.__closed:
  270.         worker = None
  271.  
  272.         else:
  273.         worker = self.__worker
  274.  
  275.     finally:
  276.         self.__lk.release()
  277.  
  278.       return worker
  279.  
  280.     def __send(self, message):
  281.     """ Send a GIOP message via our worker. """
  282.  
  283.     # In multi-thread mode, if the client has disconnected before we have
  284.     # had a chance to send the reply, then the worker will be 'None'.
  285.     worker = self.__get_worker()
  286.     if worker is not None:
  287.         worker.send(message)
  288.  
  289.     return
  290.  
  291.     def __marshal_results(self, cursor, typecodes, results):
  292.     """ Marshal the results of a request onto an octet stream. """
  293.  
  294.     no_of_outputs = len(typecodes)
  295.  
  296.     # If there are no outputs then do nothing ;^)
  297.     if no_of_outputs == 0:
  298.         pass
  299.  
  300.     # If there is exactly 1 result from the request then 'results'
  301.     # contains a single value.
  302.     elif no_of_outputs == 1:
  303.         # Marshal the first and only output!
  304.         typecodes[0]._fnorb_marshal_value(cursor, results)
  305.  
  306.     # Otherwise, 'results' is a tuple containing all of the results.
  307.     else:
  308.         i = 0
  309.         for typecode in typecodes:
  310.         typecode._fnorb_marshal_value(cursor, results[i])
  311.         i = i + 1
  312.  
  313.     return
  314.  
  315.     def __locate_reply(self, request_header, status):
  316.     """ Create and send a locate reply. """
  317.  
  318.     # Start the reply.
  319.     message = OctetStream.GIOPMessage(type=GIOP.LocateReply)
  320.     cursor = message.cursor()
  321.  
  322.     # Create the locate reply header and marshal it onto the octet stream.
  323.     reply_header = GIOP.LocateReplyHeader(request_header.request_id,status)
  324.     tc = CORBA.typecode('IDL:omg.org/GIOP/LocateReplyHeader:1.0')
  325.     tc._fnorb_marshal_value(cursor, reply_header)
  326.  
  327.     # Send it!
  328.     self.__send(message)
  329.  
  330.     return
  331.  
  332.     def __message_error(self):
  333.     """ Create and send a 'MessageError' message. """
  334.  
  335.     # Create the 'MessageError' message.
  336.     message = OctetStream.GIOPMessage(type=GIOP.MessageError)
  337.  
  338.     # Send it!
  339.     self.__send(message)
  340.  
  341.     return
  342.  
  343.     def __close_connection(self):
  344.     """ Create and send a close connection message. """
  345.  
  346.     # Create the 'CloseConnection' message.
  347.     message = OctetStream.GIOPMessage(type=GIOP.CloseConnection)
  348.  
  349.     # Send it!
  350.     self.__send(message)
  351.  
  352.     return
  353.  
  354. #############################################################################
  355.