• Static Invocation Interface (SII)

• ORB

• GIOP client

• GIOP server

• Object adapter

C.1.1 Client Side

StaticRequest::invoke()

Transfers the method invocation to the ORB, waits for completion of the method invocation, and gets the results from the ORB

ORB::invoke_async()

Creates an ORBInvokeRec object that represents the method invocation in the ORB; identifies the object adapter to be used and sends it to the method invocation.

IIOPProxy::invoke()

Creates an IIOPProxyInvokeRec object that represents the method invocation in the IIOPProxy; generates a message and sends it to the server.

IIOPProxy::make_conn()

Identifies (or creates if it does not yet exist) a GIOPConn object that represents the network connection to the server.

InetAddress::make_transport()

Creates a new TCPTransport object to connect to the server.

TCPTransport::connect()

Creates a socket and connects to the server.

GIOPCodec::put_invoke_request()

Generates a network message that represents the method invocation.

GIOPCodec::put_args()

Processes the input parameters to the operation.

StaticRequest::get_in_args()

Marshals the input parameters.

StaticAny::marshal()

Marshals one input parameter.

GIOPConn::output()

Sends the network message to the server.

ORB::wait()

Waits until the method invocation is completed. During this time, incoming network messages are received and processed.

Dispatcher::run()

Waits for incoming data on network connections.

Dispatcher::handle_fevents()

Detects incoming data on network connections and calls the relevant connection handler.

GIOPConn::callback()

The GIOP connection’s handler for incoming data.

GIOPConn::do_read()

Reads data from network connection.

GIOPConn::input_ready()

Is called when a GIOP message is complete.

GIOPConn::input_ready_callback()

Is called to notify the IIOP proxy of an incoming message.

IIOPProxy::input_callback()

The callback to notify the IIOP proxy of an incoming message.

IIOPProxy::handle_input()

Checks the message for its type (i.e., whether it is a reply) and invokes the appropriate method for evaluation of the message.

IIOPProxy::handle_invoke_reply()

Decodes the network message and forwards the results.

GIOPCodec::get_invoke_reply1()

Decodes the GIOP header.

GIOPCodec::get_invoke_reply2()

Processes the invocation’s result and other output parameters.

StaticRequest::set_out_args()

Marshals the result and output parameters.

StaticAny::unmarshal()

Marshals one output parameter.

IIOPProxy::exec_invoke_reply()

Sends results to the ORB.

ORB::answer_invoke()

Stores the results of a method invocation in the associated ORBInvokeRec and designates the method invocation as completed so that ORB::wait()

returns to its caller.

ORB::get_invoke_reply()

Fetches results of method invocation from ORB.

C.1.2 Server Side

GIOPConn::do_read()

Reads data from network connection.

GIOPConn::input_ready()

Is called when a GIOP message is complete.

GIOPConn::input_ready_callback()

Is called to notify the IIOP server of an incoming message.

IIOPServer::input_callback()

Callback routine of IIOPServer that is invoked when a new message arrives.

IIOPServer::handle_input()

Checks the type of message and invokes the corresponding method to evaluate the message.

IIOPServer::handle_invoke_request()

Decodes the GIOP message header and forwards parameters.

GIOPCodec::get_invoke_request()

Decodes the message, creates a GIOPRequest object (equivalent to Request object on client side), and creates an IIOPServer-InvokeRec object that represents method invocation on server side.

IIOPServer::exec_invoke_request()

Passes the invocation request to the ORB.

ORB::invoke_async()

Creates an ORBInvokeRec object that represents the method invocation in the ORB; establishes the object adapter to be used and passes it the method invocation.

POA_impl::invoke()

Checks the object reference of the target object and looks for the POA that manages the target object, and transfers the method invocation to this POA instance.

POA_impl::local_invoke()

Executes, delays, or ignores the method invocation depending on the state of the POA manager belonging to the target POA.

POA_impl::perform_invoke()

Looks up the servant belonging to the target object, depending on the POA policies. Usually, the servant is found in the active object map. Generates a Static ServerRequest object and passes it to the servant’s method dispatcher.

POA_Account::invoke()

Calls the dispatch() methods of the skeleton and its base classes, eventually finding the skeleton that implements the invocation that is being called.

POA_Account::dispatch()

Determines the method that is to be invoked, extracts the parameters from the StaticServerRequest, calls the method implementation, and stores the results in the StaticServerRequest.

StaticServerRequest::add_*_arg()

Gives StaticServerRequest references to Static Any objects that are to hold the parameter values.

StaticServerRequest::set_result()

Gives StaticServerRequest references to the StaticAny object that is to hold the result value.

StaticServerRequest::read_args()

Decodes the input parameters of the method invocation and fills the StaticAnys previously registered via add_*_arg()

with the decoded values.

GIOPRequest::get_in_args()

Unmarshals the input parameters.

StaticAny::demarshal()

Unmarshals one input parameter.

POA_Account::deposit()

Invocation of the target method implemented by the user.

StaticServerRequest::write_results()

Encodes the result value and other output parameters by converting the values contained in the StaticAny objects that have been previously registered via add_*_arg() and set_result()

into a byte stream.

GIOPRequest::set_out_args()

Marshals the result and other output parameters.

StaticServerRequest::∼StaticServerRequest()

The StaticServerRequest destructor informs POA that method invocation is completed.

POA_impl::answer_invoke()

The POA informs ORB that the method invocation has completed.

ORB::answer_invoke()

Stores the results of a method invocation in associated ORBInvokeRec.

IIOPServer::notify()

Invokes the correct method for handling a reply message, depending on which kind of request has completed.

IIOPServer::handle_invoke_reply()

Retrieves the status of a method invocation from ORB, generates reply message, and sends it to the client.

ORB::get_invoke_reply()

Gets the invocation’s result from the ORB.

GIOPCodec::put_invoke_reply()

Generates a GIOP reply message.

GIOPConn::output()

Sends the message to the client.

Operations provided by the ORB

This is a convenient combination of invoke_async(), wait(), and get_invoke_ reply(), which blocks until an operation invocation is completed.

ORBRequest represents operation invocation

Object adapters inherit from basic class ObjectAdapter

Operations provided by the ORB

New GIOP mapping

XAddress:

    Address, files include/mico/address.h, include/mico/address_impl.h, orb/address.cc.

XAddressParser:

    Decodes addresses from a given string, and the same for files.

XProfile:

    IOR profiles, files include/mico/ior.h, include/mico/ior_impl.h, orb/ior.cc.

XProfileDecoder:

    Decodes IOR profiles from a given byte stream, and the same for files.

XTransport:

    Client-side transport class, files include/mico/transport.h, include/mico/ transport_impl.h, orb/transport.cc, orb/transport/*.cc.

XTransportServer:

    Server-side transport class, and the same for files.

C.4.1 XAddress

First an address type string (similar to “inet”) that has not yet been used, such as “x”, has to be specified. This string serves as the prefix for addresses in string form. The prefix is followed by arbitrary address information, such as a globally explicit number in “x:42”.

Specifying the address prefix

A class XAddress implementing the following methods is then derived from CORBA::Address.

string stringify () const

Supplies the address in string form, such as “x:42”.

const char *proto () const

Supplies the type of this address, such as “x”.

CORBA::Transport *make_transport () const

Creates a Transport object that matches the type of address.

CORBA::TransportServer *make_transport_server () const

Creates a TransportServer object that matches the type of address.

Creates an IORProfile object that matches the type of address. The parameters provided are the object ID key, its length keylength, any components components that might exist, and the GIOP version version (default value 1.0) to be used. The components consist of a standardized representation of arbitrary information that could be stored in a profile, which can include the name and the version of the ORB that generated the profile.

CORBA::Boolean is_local () const

Then exactly supplies TRUE if the address refers to the same address space in which it is used.

CORBA::Address *clone () const

Creates an exact copy of this.

CORBA::Long compare (const CORBA::Address &addr) const

Compares this with addr and supplies −1 if this < addr, 0 if this = addr, or 1 if this > addr.

CORBA::Boolean operator== (const CORBA::Address &addr) const

Exactly supplies TRUE if this = addr.

CORBA::Boolean operator< (const CORBA::Address &addr) const

Exactly supplies TRUE if this < addr.

C.4.2 XAddressParser

The class XAddressParser must be derived from CORBA::AddressParser and implement the following methods:

Converts an address string (for example, x:42) into an Address object. proto contains the address type (for example, x), and rest contains the rest (for example, 42) of the string.

CORBA::Boolean has_proto (const char *proto) const

Supplies exactly TRUE if the address parser can parse addresses from the type proto (for example, x).

C.4.3 XProfile

In this case too a profile ID that has not yet been used has to be defined (similar to TAG_INTERNET_IOP), such as

const CORBA::IORProfile::ProfileId TAG_X_IOP = 31415;

Then a class XProfile is derived from CORBA::IORProfile and implements the following methods:

void encode (CORBA::DataEncoder &encoder) const

Codes this using encoder in a byte stream.

CORBA::Address *addr () const

Supplies the address of this profile.

ProfileId id () const

Supplies the profile ID of this profile.

ProfileId encode_id () const

Normally supplies the same result of id(). encode_id() only supplies the profile ID of a basic transport mechanism in special cases (such as the SSL transport mechanism that represents a wrapper for an existing transport mechanism like IIOP).

void objectkey (Octet *key, Long keylength)

Sets the object ID to the supplied value. key contains the new ID and keylength its length.

Requests the object ID. The result is a reference to the object ID; keylength is set to the length of the object ID.

CORBA::Boolean reachable ()

Return TRUE if the address contained in the profile can be reached. For example, the address local can only be reached from a process if it was also created in this process. On the other hand, addresses of the type inet can always be reached.

void print (ostream &outputstream) const

Supplies the address in a string form as outputstream.

CORBA::MultiComponent *components ()

Supplies the components contained in the profile.

CORBA::IORProfile *clone () const

Creates an exact copy of this.

Compares this with prof and supplies −1 if this < prof, 0 if this = prof, and 1 if this > prof.

Supplies exactly TRUE if this = prof.

Supplies exactly TRUE if this < prof.

C.4.4 XProfileDecoder

The class XprofileDecoder must be derived from CORBA::ProfileDecoder and implement the following methods:

Uses decoder to convert a byte stream into an IORProfile object. The parameters supplied are the profile ID id and the length of the byte stream length.

CORBA::Boolean has_id (ProfileId id) const

Supplies exactly TRUE if the profile decoder can decode profiles of the type id.

C.4.5 XTransport

The class XTransport must be derived from CORBA::Transport and implement the following methods:

This method registers a read callback callback that is invoked as soon as data can be received and read on a connection or the Transport object is destroyed. disp is the scheduler used (described in detail in Section C.4.7). Callback objects inherit from the following basic class and implement the method callback(). The method callback() is invoked with this as the first parameter of the Transport object and TransportCallback::Read (if data can be read) or TransportCallback::Remove (if the Transport object is being destroyed) as the second parameter.

This method registers a write callback that is invoked in a similar way as reselect() if data can be written or the Transport object is being destroyed.

CORBA::Boolean bind (const CORBA::Address *addr)

Sets the local address of the transport end point to addr.

CORBA::Boolean connect (const CORBA::Address *addr)

Establishes a connection to a remote address.

void close ()

Terminates the connection.

void block (CORBA::Boolean doblock = TRUE)

If doblock is TRUE, then all subsequent read and write operations block until they have been executed completely. Otherwise read and write operations are only executed to the extent that is possible without blocking and an appropriate result code is returned.

CORBA::Boolean isblocking ()

Exactly supplies TRUE in the event that read and write operations are blocking.

CORBA::Boolean isreadable ()

Exactly supplies True if data is available for reading, thus read would not be blocking.

CORBA::Long read (void *buffer, CORBA::Long bufferlen)

At a maximum reads bufferlen bytes from the area referred to by buffer. The result supplied is the number of read bytes or −1 in the case of failure (including EOF).

At a maximum writes bufferlen bytes from the area referred to by buffer. The result supplied is the number of written bytes or −1 in the case of failure.

const CORBA::Address *addr ()

Supplies local address.

const CORBA::Address *peer ()

Supplies the remote address of a connection or NIL if no connection exists.

CORBA::Boolean eof () const

Exactly supplies TRUE if the connection was terminated and all data was read.

CORBA::Boolean bad () const

Exactly supplies TRUE if an error occurred.

string errormsg () const

Supplies a textual description of the last error that occurred.

C.4.6 XTransportServer

The class XTransportServer must be derived from CORBA::TransportServer and implement the following methods:

This method registers an accept callback that, similar to Transport::rselect(), is invoked when a connection request arrives or the TransportServer object is destroyed. Callback objects inherit from the following basic class and implement the method callback(). The method callback() is invoked with this as the first parameter of the TransportServer object and TransportServerCallback::Accept (if a connection request exists) or TransportServerCallback::Remove (if the TransportServer object is being destroyed) as the second parameter.

CORBA::Boolean bind (const CORBA::Address *addr)

Binds the local address of the transport end point to addr. void close ()

Terminates the transport end point. No further connections can be accepted.

void block (CORBA::Boolean doblock = TRUE)

If doblock is TRUE, then all subsequent accept operations block until a connection setup request exists. Otherwise invocations of accept() deliver a NIL if there is no connection setup request.

CORBA::Boolean isblocking ()

Exactly delivers TRUE in the event accept operations are blocking.

CORBA::Transport *accept ()

As soon as a connection setup request exists (i.e., if a client has invoked connect() with the address of this TransportServer object), accept() delivers a Transport object that represents the connection to this client.

const CORBA::Address *addr ()

Supplies the local address.

CORBA::Boolean bad () const

Exactly supplies TRUE if a failure occurs.

string errormsg () const

Supplies a textual description of the last failure that occurred.

C.4.7 Dispatcher

The Transport and TransportServer classes work closely together with the scheduler described in Section 5.3.4. Thus the scheduler is usually used to implement the methods Transport::rselect(), Transport::wselect(), and TransportServer::aselect().

All scheduler implementations inherit from the abstract basic class CORBA:: Dispatcher. This class provides various methods for the registration of callbacks that can be invoked when certain events occur. The possible events are described by the following enumeration:

The individual values of this list signify the following:

The declaration for the class dispatcher can be found in the file include/mico/transport.h and various implementations can be found in the files orb/dispatch.cc, auxdir/x11.cc, auxdir/qtmico.cc, auxdir/tclmico.cc, auxdir/gtkmico.cc, and auxdir/fltkmico.cc in the MICO source tree.

Callback objects inherit from the abstract basic class CORBA::Dispatcher-Callback and implement the method callback(). The method callback () is invoked by the dispatcher when an event occurs with this as the first parameter and the event that occurred as the second parameter:

All implementations of the abstract basic class CORBA::Dispatcher provide the following methods:

Registers a read callback cb that is invoked when data can be read on the file handle fd.

Registers a write callback cb that is invoked when data can be written on the file handle fd.

Registers an exception callback cb that is invoked when an exception occurs on the file handle fd.

Registers a timer callback that is invoked when the time timeout (in milliseconds) has elapsed.

void remove (CORBA::DispatcherCallback *cb, Event event)

Removes a callback cb previously registered for an event.

void run (CORBA::Boolean infinite = TRUE)

Waits for the occurrence of the next event and processes it. If infinite = FALSE, it means that exactly one event is being processed. Otherwise an infinite loop is entered.

void move (CORBA::Dispatcher *disp)

Removes all registered callbacks from this and registers them at dispatcher disp.

CORBA::Boolean idle () const

Supplies exactly TRUE if there are no pending events for any registered callback at the time of invocation.

C.4.8 Initialization

An instance each of XaddressParser and XprofileDecoder must first be created and registered before a new transport mechanism can be used. The easiest way this can be done is through the implementation of registration or deregistration in the constructor or destructor and the creation of a global instance for both classes. Thus:

In addition, the GIOP framework in the client and in the server must be notified of the existence of the new transport mechanism:

CORBA::ORB_var orb = …;

The new transport mechanism can be used if the server is started with the command line option

-ORBIIOPAddr x:42

If an object reference is being exported by the server, it will contain an Xprofile that triggers the client into using the appropriate transport mechanism when invoking methods on this object.

Proxies are based on MICO-specific static interface adapters

Marshaller of an IDL type

Representation of a type code

C++ templates for tools

Skeleton has an operation dispatcher

StaticRequest instance represents operation invocation

dispatch calls up all dispatchers of an interface’s direct parents