API Reference

`future:evaluate`	Evaluate the invocation to completion
`future:ready`	Checks if the results are ready
`future:results`	Returns the results of the invocation

`interceptor:receivereply`	Client-side invocation reply interception point
`interceptor:receiverequest`	Server-side invocation request interception point
`interceptor:sendreply`	Server-side invocation reply interception point
`interceptor:sendrequest`	Client-side invocation request interception point

`oil.init`	Initialize an ORB (broker)
`oil.main`	Executes the application's main function
`oil.newthread`	Executes a function in a new thread
`oil.readfrom`	Reads the contents of a file.
`oil.sleep`	Suspends the current thread for some time.
`oil.time`	Returns the current time of the system.
`oil.writeto`	Write data to a file.

`orb:deactivate`	Deactivates a distributed object.
`orb:getIR`	Returns the remote repository used to discover interfaces
`orb:getLIR`	Returns the local repository with all known interface information
`orb:getinterceptor`	Returns the current interceptor for invocations
`orb:loadidl`	Loads an IDL definition into the internal Interface Repository
`orb:loadidlfile`	Loads an IDL file into the internal Interface Repository
`orb:narrow`	Narrows an object reference into a more specific interface
`orb:newdecoder`	Creates a new value decoder that unmarshal values from strings
`orb:newencoder`	Creates a new value encoder that marshal values into strings
`orb:newexcept`	Creates a new exception object with the given body
`orb:newproxy`	Creates a proxy of a distributed object
`orb:newservant`	Registers a new servant creating a new distributed object
`orb:pending`	Checks whether there is some request pending
`orb:run`	Process incoming invocation requests continuously
`orb:setIR`	Defines the remote repository used to discover interfaces
`orb:setexcatch`	Defines a exception handling function for proxies
`orb:setexhandler`	Sets the dispatch exception handling function
`orb:setinterceptor`	Defines an interceptor for invocations
`orb:setonerror`	Sets a notification function for uncaught ORB errors
`orb:settimeout`	Defines a timeout for proxy invocations
`orb:shutdown`	stops the processing invocation requests
`orb:step`	Process one single invocation request

`orbcfg.flavor`	ORB assembly specification
`orbcfg.host`	Network address the ORB must listen
`orbcfg.keyprefix`	Prefix of default object IDs
`orbcfg.localrefs`	Indication of how local references are resolved by the ORB
`orbcfg.objectmap`	Map of active object IDs to servants
`orbcfg.port`	Network port number the ORB must listen
`orbcfg.tcpoptions`	Configuration of TCP connections created by the ORB
`orbcfg.valuefactories`	Map of type IDs to the corresponding factory

`proxy.__reference`	Structure with reference information of the remote object
`proxy:__setexcatch`	Defines a exception handling function for the proxy
`proxy:__settimeout`	Defines a timeout for proxy invocations

`reqcli.profile`
`reqcli.profile_data`
`reqcli.profile_tag`

`reqsrv.servant`

`request.forward_reference`
`request.interface`
`request.object_key`
`request.operation`
`request.operation_name`
`request.parameters`
`request.reference`
`request.reply_service_context`
`request.request_id`
`request.response_expected`
`request.results`
`request.service_context`
`request.success`

`servant:__deactivate`	Unregisters the servant from its broker.
`servant.__objkey`	Object key of the distributed object this servant implements
`servant.__servant`	Value registered as servant

`tcpopt.keepalive`
`tcpopt.linger`
`tcpopt.reuseaddr`
`tcpopt.tcp-nodelay`
`tcpopt.timeout`

Future

Object that represents the results of a ongoing and potentially incomplete invocation initiated asynchronously.

... = future:evaluate([timeout])

is a method that blocks until the completion of the invocation (or a timeout) and return the values returned by the operation or raises an error if the invocation could not be performed successfully. Any error raised by the invoked operation on the distributed object is raised by this method. If the asynchronous proxy that produced this future has any exception handler associated that matches an error raised during the operation invocation, the exception handler is called automatically.

Parameter timeout is a number that indicates the minimum time (in seconds) to wait for the completion of the invocation. If the invocation does not complete before this time this operation behaves as the invocation has raised a timeout exception. When absent then no time limit is assumed.

Returned value ... are the returned values of the invoked operation.

completed = future:ready()

is a method that checks whether the results of the invocation are ready or not.

Returned value completed is a boolean that is true when the results of the invocation were received and processed or false if the results are not available yet.

success, ... = future:results([timeout])

is a method that blocks until the completion of the invocation (or a timeout) and returns its results.

Returned value success is a boolean that is true when the invocation were performed successfully or false if there was an error while performing the invocation.

Returned value ... are the returned values of the invoked operation if it was performed successfully, otherwise it is the error raised while performing the invocation.

Invocation Interceptor

interceptor:receivereply(request)

is a method that is invoked whenever the ORB receives the reply of an invocation request sent previously.

Parameter request is a CORBA Client Invocation Request that describes the invocation being intercepted. This is the same table passed to the corresponding interceptor:sendrequest

interceptor:receiverequest(request)

is a method that is invoked whenever the ORB receives an invocation request.

Parameter request is a CORBA Server Invocation Request that describes the invocation being intercepted.

interceptor:sendreply(request)

is a method that is invoked whenever the ORB sends a reply of an invocation request received previously.

Parameter request is a CORBA Server Invocation Request that describes the invocation being intercepted. This is the same table passed to the corresponding interceptor:receiverequest

interceptor:sendrequest(request)

is a method that is invoked whenever the ORB send an invocation request.

Parameter request is a CORBA Client Invocation Request that describes the invocation being intercepted.

OiL Module

orb = oil.init([config])

is a function that initializes an ORB (broker) instance on table config using its fields as configuration options.

Parameter config is a ORB Configuration Table that contains optional configuration parameters of the initialized ORB. The actual configuration options varies accordingly to the ORB flavor. For more information, see section Initializing Brokers. When absent this method returns the same ORB, which is initialized with default configuration options. To create different ORBs with the default configuration, pass a different empty table as this parameter .

Returned value orb is a Object Request Broker that is the same table config now containing an initialized ORB and all values of the configuration options used, including default values adopted. This returned table shall not be modified by the application.

Example:

orb = oil.init{ host="orb.tecgraf.puc-rio.br" }

oil.init{ host="10.223.10.56", port=2089 }:run()

print("Default port chosen:", oil.init().port)

... = oil.main(func, ...)

is a function that executes the application's main function in a new thread if the OiL module loaded provides thread support. This function only returns when the main function and all threads initiated by this function terminates or suspends.

Parameter func is a function that shall be executed and runs the whole application. Ideally, this function is the initial entry point of the application.

Parameter ... are the values to be passed as arguments to the function being executed.

Returned value ... are all the values returned or yielded by the last executed function during this execution. These values might be the values produced by function func itself or some other function executed in another thread that terminated or suspended after the thread running func has completed or suspended.

Example:

oil.main(function() print(oil.getLIR()) oil.run() end)

... = oil.newthread(func, ...)

is a function that creates a new thread to execute a function with the arguments provided. This function immediately starts the execution of the new thread and returns only when the new thread yields or returns. This function returns all the values yielded by the new thread. This function can only be invoked from others threads, including the one executing the application's main function (see oil.main).

Parameter func is a function that shall be executed in a new thread.

Parameter ... are the values to be passed as arguments to the function being executed.

Returned value ... are all the values returned or yielded by the the executed function.

Example:

oil.newthread(broker.run, broker)

contents [, errmsg] = oil.readfrom(filepath, binary)

is a function that reads the entire contents of a file either as text or a binary stream.

Parameter filepath is a string that contains the path to the file to be read.

Parameter binary is a boolean that indicates whether the file should be read as a binary stream.

Returned value contents is a string that contains the entire contents of the file. In case of errors, this returned value is nil.

Returned value errmsg is a string that an message describing the error that occurred. When absent indicates the file was read successfully.

Example:

orb:newproxy(oil.readfrom("object.ref"))

oil.sleep(time)

is a function that suspends the execution of the current thread for a minimum ammount of time. Thus function only return after the time counter of system has passed the specified time.

Parameter time is a number that is the minimum number of seconds the current thread must be suspended.

Example:

oil.sleep(5.5)

time = oil.time()

is a function that returns the current time of the system.

Returned value time is a number that indicates the current time of the system in seconds, counting from an arbitraty fixed moment in the past.

Example:

start = oil.time(); oil.sleep(3); print("slept for ", oil.time()-start, " secs.")

success [, errmsg] = oil.writeto(filepath, data [, mode])

is a function that writes the textual representation of a value to a file.

Parameter filepath is a string that contains the path to the file to be written.

Parameter data is the value which the textual representation (as produced by function tostring (v) from the Standard Libraries) shall be written to the file.

Parameter mode is a string that indicated the mode how the file should be accessed like specified by function io.open (filename [, mode]) from the Standard Libraries. The default value is "w".

Returned value success is a boolean that indicates whether the data was written successfully.

Returned value errmsg is a string that an message describing the error that occurred. When absent indicates the file was read successfully.

Example:

oil.writeto("ir.ior", orb:getLIR())

Object Request Broker

entry [, errmsg] = orb:deactivate(key [, type])

is a method that deactivates a distributed object by removing its servant from the object map of the ORB.

Parameter key is either the key identifying the servant, or the object representing the registered servant (as returned by method orb:newservant). Moreover, this parameter can be the value registered as servant (as passed as parameter servant of method orb:newservant). In this last case, if the value does not provide fields __objkey nor __type, it might be necessary to provide the same interface of the registered servant since the same value might be registered with different interfaces.

Parameter type indicates the type of the distributed object being deactivated when the ORB provide support for this. When absent the ORB tries to infer the type of the registered servant automatically. .

Returned value entry is a table that contains the following fields:

__servant: the value registered as servant.
__objkey: the identifier of the servant previously used to identify the servant in the ORB.
__type: the type information of the distributed object implemented by the servant. For ORBs with support for CORBA this field is the interface of the CORBA object implemented by the servant.

If the ORB was unable to unregister the servant this returned value is nil.

Returned value errmsg describes the error that occurred. When absent indicates the servant was unregistered successfully.

repository = orb:getIR()

is a method that returns the CORBA Interface Repository (IR) used by the ORB to retrieve unknown typing information. Usually this IR is a proxy to a remote object that provides additional typing information that the ORB must retrieve on demmand. This method should not be invoked on ORBs that do not support CORBA.

Returned value repository is a table that implements the CORBA Interface Repository interface as specified by the CORBA standard to provide access to new the CORBA typing information unknown to the ORB.

repository = orb:getLIR()

is a method that returns the internal CORBA Interface Repository used by the ORB. This method should not be invoked on ORBs that do not support CORBA.

Returned value repository is a table that implements the CORBA Interface Repository interface as specified by the CORBA standard to provide access to all the CORBA typing information known to the ORB.

interceptor = orb:getinterceptor([point])

is a method that returns the intereceptor registered to intercept invocation requests made through this ORB.

Parameter point is a string that indicates the interception point, as defined by method orb:setinterceptor When absent indicates this method shall return the interceptor registered in both "server" and "client" interception points, or nil if there are two different interceptors. .

Returned value interceptor is a Invocation Interceptor that was registered in the interception point indicated by parameter point.

... = orb:loadidl(idlspec [, incpaths])

is a method that loads an IDL definition into the internal Interface Repository.

Parameter idlspec is a string that contains an IDL specification of interfaces and other typing information to be loaded into the ORB's internal Interface Repository (see <$orb:getLIR>). This IDL specification will be parsed by the LuaIDL compiler.

Parameter incpaths is a table that contains a sequence of file paths (string) to search for files included using #include directive. When absent the included files are searched only in the default places, which are the current directory and the directory of the file containing the #include directive. .

Returned value ... are values that implement descriptors of the loaded definitions. For more information about IDL descriptors, see Loading IDL

... = orb:loadidlfile(filepath [, incpaths])

is a method that loads an IDL definition from a file into the internal Interface Repository.

Parameter filepath is a string that contains a path to a file containing an IDL specification of interfaces and other typing information to be loaded into the ORB's internal Interface Repository (see <$orb:getLIR>). The contents of this file will be parsed by the LuaIDL compiler.

Returned value ... are values that implement descriptors of the loaded definitions. For more information about IDL descriptors, see Loading IDL

proxy = orb:narrow(proxy [, type])

is a method that narrows an object proxy into a more specific interface. This method is deprecated. Use orb:newproxy instead.

Parameter proxy is a Proxy that points to the distributed object being narrowed.

Parameter type indicates the type of the distributed object of the proxy to be created. It can either be a string with the absolute name or repository ID of an object interface previously loaded into the ORB, or an object describing the type. For more information about representation of object types and interface in a CORBA ORB see Loading IDL When absent the ORB tries to infer the more specific type for the distributed object, potentially trying to contact the object. .

Returned value proxy is a Proxy that represents the referenced distributed object with a narrower interface.

decoder = orb:newdecoder(stream)

is a method that creates a new value decoder that unmarshal values from an encoded stream. For CORBA ORBs, the decoder reads CORBA's CDR encapsulated streams, i.e. includes an indication of the endianess used in value codification.

Parameter stream is a string that contains a stream with marshaled values.

Returned value decoder is a decoder that is a value decoder that can be used to unmarshal values from a marshaled stream.

encoder = orb:newencoder()

is a method that creates a new value encoder that marshal values into an encoded stream. For CORBA ORBs, the encoder writes CORBA's CDR encapsulated streams, i.e. includes an indication of the endianess used in value codification.

Returned value encoder is a encoder that is a value encoder that can be used to marshal values into a string containing a marshaled stream.

exception = orb:newexcept(body)

is a method that creates a new exception object with the given body.

Parameter body is a table that contains the values of the exceptions fields. For ORBs that support typing information, like ORBs with CORBA support, the exception must also contain the type of the exception at field _repid (in CORBA this identification is the repository ID, absolute name, etc.).

Returned value exception is a table that contains the values of the exceptions fields and can be converted to string or concatenated to produce error messages.

proxy = orb:newproxy(reference [, kind [, type]])

is a method that creates an object that works as a proxy of a distributed object indicated by a parameter reference. Every method invoked on the proxy results in an attempt to invoke the same method on the corresponding distributed object.

Parameter reference either a string containing object reference information (CORBA's stringfied IOR or CorbaLoc URI) of the distributed object or another proxy pointing to this object.

Parameter kind is a string that word indicating the kind of the proxy to be created. The possible options are:

"synchronous": Proxy that imitates the behavior of the remote object. Its methods block while the corresponding method of the distributed object is executing and errors raised by the method of the distributed object are raised by the method of the proxy.
"asynchronous": Proxy which methods might return before the completion of the invocation of the distributed object. The methods of this kind of proxy always return a Future.
"protected": Proxy which methods never raise errors and always return a boolean indicating whether the invocation was perfomed successfully (true) or not (false), and also the results of the invocation, which are the returned values if the first value is true, or the error raised otherwise.

The default value is "synchronous".

Parameter type indicates the type of the distributed object of the proxy to be created. It can either be a string with the absolute name or repository ID of an object interface previously loaded into the ORB, or an object describing the type. For more information about representation of object types and interface in a CORBA ORB see Loading IDL When absent the ORB tries to infer a proper type for the distributed object, potentially trying to contact the object. .

Returned value proxy is a Proxy that represents the referenced distributed object.

servant = orb:newservant(object [, key [, type]])

is a method that registers objects in the ORB as servants that implement distributed objects that shall be accessed remotely through the RMI technology supported by the ORB.

Parameter object is a value that will be used to dispatch all requests to the distributed object created as result of this call. Usually, this value supports all the methods, attributes and other features of the distributed object. This value might provide the field __objkey to define the identifier used to register the servant in the ORB. Moreover, if the ORB supports interface definition of distributed objects (e.g. CORBA), this value might provide the field __type to define the interface of the distributed object implemented by this servant.

Parameter key is a string that containing a unique identifier of the distributed object implemented by the servant being registered in the ORB. When absent the ORB creates an automatic key based on the parameter value and the distributed object interface. All automatically generated keys starts with a special prefix defined by the ORB configuration parameter orbcfg.keyprefix. .

Parameter type indicates the interface of the distributed object being created when the ORB provide support for this. For CORBA ORBs this parameter is mandatory. When absent indicates that the ORB does not provide support for definition of the interface of distributed objects. .

Returned value servant is a Servant that represents a value registered as the implementation of a distributed object.

ispending = orb:pending()

is a method that checks whether there is some request pending processing by the ORB at the moment.

Returned value ispending is a boolean that indicates whether there are requests pending processing in the ORB.

orb:run()

is a method that processes all incoming invocation requests continuously until some error occours while receiving the requests or the method orb:shutdown.

orb:setIR(repository)

is a method that sets the CORBA Interface Repository (IR) used by the ORB to retrieve unknown typing information. Usually this IR is a proxy to a remote object that provides additional typing information that the ORB must retrieve on demmand. This method should not be invoked on ORBs that do not support CORBA.

Parameter repository is a table that implements the CORBA Interface Repository interface as specified by the CORBA standard to provide access to new the CORBA typing information unknown to the ORB.

orb:setexcatch(handler [, interface])

is a method that defines the exception handling function for the proxies created by this ORB. Exception handling functions are not cumulative. For example, if there is an exception handling function defined for all proxies and another one only for proxies of a given type, then the later will be used for proxies of that given type. Additionally, exceptions handlers are not inherited through interface hierarchies.

Parameter handler is a function that is invoked to handle exceptions raised on operations invoked using proxies created by this ORB. This function receives the following parameters:

proxy: object proxy that performed the operation.
exception: exception/error raised.
operation: descriptor of the operation that raised the exception.

Parameter interface defines an object interface, like an intefaces described in CORBA IDL. If this parameter is provided, then the exception handling function will be applied only to proxies of that interface. When absent then the handler will be applied to all proxies created by the ORB that do not have a exception handler function defined. .

orb:setexhandler(handler)

is a method that sets a function to be called to manipulate an error raised during a dispatch and produce potentially new error value to be raised.

Parameter handler is a function that executes in the same thread and execution point where the error was raised. This function receives as parameter the value of the original error raised during the dispatch of the servant and shall return the value of the error that must be raised in place of the original value.

orb:setinterceptor(interceptor [, point])

is a method that registers an intereceptor to intercept invocation requests made through this ORB.

Parameter interceptor is a Invocation Interceptor that to be invoked at some invocation interception point.

Parameter point is a string that indicates the interception point of the interceptor. The expected values are:

"server": Interceptor is invoked whenever a request to a local servant is received or replied.
"client": Interceptor is invoked whenever a request to a remote servant is sent or replied.
"corba.server": Interceptor is invoked whenever a CORBA request to a local servant is received or replied. For more information on CORBA interceptors, see Intercepting Invocations
"corba.client": Interceptor is invoked whenever a CORBA request to a remote servant is sent or replied. For more information on CORBA interceptors, see Intercepting Invocations
"corba": Designates both interception points defined by values "corba.client" and "corba.server".

When absent the interception point assumed is both the ones "server" and "client" values. .

orb:setonerror(callback)

is a method that sets a function to be executed whenever the ORB catch an error that it cannot report back to the application.

Parameter callback is called to notify an uncaught error. This function cannot avoid the exception raised nor change the value of the error. It is simply a notification of an error raised. This function receives the following parameters:

error

the value of the uncaught error.

tag

an indication of the context where the error was raised. The possible values are:

connection: while connection establishment from a remote client.
request: while extracting request from remote client.
dispatch: while dispatching a request to the application.
reply: while sending a reply of an invocation back to the client.

orb:settimeout(timeout [, interface])

is a method that defines the timeout for the methods invoked using proxies created by this ORB. Timeouts are not cumulative. For example, if there is a timeout defined for all proxies and another one only for proxies of a given type, then the later will be used for proxies of that given type. Additionally, timeouts are not inherited through interface hierarchies.

Parameter timeout is a number that minimum time (in seconds) the ORB might spend to complete operations invoked using its proxies. Operations may complete before the time defined as the timeout.

Parameter interface defines an object interface, like intefaces described in CORBA IDL. If this parameter is provided, then the timeout will be applied only to proxies of that interface. When absent then the timeout will be applied to all proxies created by the ORB that do not have a timeout defined. .

orb:shutdown()

is a method that stops the execution of method orb:run, so the invocation request processing halts. Any eventual invocation request that have started to be processed will be properly handled by the ORB before this method returns.

success [, errmsg] = orb:step(timeout)

is a method that waits for an invocation request and process it. Only one single invocation request is processed.

Parameter timeout is a number that indicates the minimum time the ORB might wait for a new invocation request before processing it.

Returned value success is a boolean that indicates whether the invocation request was processed successfully.

Returned value errmsg describes the error that occurred. When absent indicates the invocation request was processed successfully.

ORB Configuration Table

orbcfg.flavor

is a string that contains a sequence of names describing how ORB internal components are created and assembled. These names determine the features provided by the ORB, including the underpinning RMI technology. The default value is "cooperative;corba".

orbcfg.host

is a string that contains address the ORB must listen when the ORB supports TCP connections. This address may be an IP address or a host name. Additionally, the value "*" indicates the ORB should listen to all TCP/IP network interfaces available. The default value is "*".

orbcfg.keyprefix

is a string that contains the prefix added to all object IDs automatically generated by the ORB for servants registed as distributed objects without an explicit object ID. Define this prefix to make the ORB to create object IDs that does not collides with the object IDs provided by your application. The default value is "_".

orbcfg.localrefs

is a string that indicates how references to local servants must be resolved by the ORB so they can be delivered to the application. There are three expected values, that indicates that the local references shall be resolved to:

"implementation": the value that implements the local object.
"proxy": a new proxy to the local object.
"servant": the servant object that represents the local object.

The default value is "implementation".

orbcfg.objectmap

is a table that shall be used by the ORB to map the object ID of exported distributed objects to the servant that implements them. This table is used both to store servants registered by the application as well as to retrieve the servant of every invocation request dispatched by the ORB. Therefore, it is possible to provide a table with metamethods that provide servants to the ORB on demand. The default value is {}.

orbcfg.port

is a number that of a network port the ORB must listen when the ORB supports TCP connections. The value 0 indicates the ORB should choose a free ephemeral port automatically. The default value is 0.

orbcfg.tcpoptions

is a TCP Options Table that contains configuration options of the TCP connections created by the ORB when the underlying RMI technology creates such connections. The default value is {}.

orbcfg.valuefactories

is a table that maps strings containing a type ID to the constructor function that shall be called by the ORB to resolve values of that type ID before passing the value to the application. The constructor function receives the raw data extracted from the wire and must adapt it properly so it can be delivered to the application. The default value is {}.

Proxy

Object used to access a distributed object. This object behaves as the distributed object. This means, that any method call performed on the proxy results in the same call on the distributed object. This object also provides the additional fields described below.

proxy.__reference

is a table that contains complete IOR structure (see CORBA::IOP::IOR in CORBA specs.) in case of CORBA ORB, or another data structure in case of other protocols.

success, result = proxy:__setexcatch(handler)

is a method that defines the exception handling function for the proxy.

Parameter handler is a function that is invoked to handle exceptions raised on operations invoked using a proxy. This function receives the following parameters:

proxy: object proxy that performed the operation.
exception: exception/error raised.
operation: descriptor of the operation that raised the exception.

The results produced by this function (returned values or error raised) will become the results of the invocation that raised the exception.

Returned value success is a boolean that Indication that the timeout was changed

Returned value result is the previously defined exceptions handler function in case of success (success == true), or a message describing the error that occurred.

success, result = proxy:__settimeout(timeout)

is a method that defines the timeout for the methods invoked using proxies created by this ORB.

Parameter timeout is a number that minimum time (in seconds) the ORB might spend to complete operations invoked using a proxy. Operations may complete before the time defined as the timeout.

Returned value success is a boolean that Indication that the timeout was changed

Returned value result is the previously defined timeout in case of success (success == true), or a message describing the error that occurred.

CORBA Client Invocation Request

Object that describes an intercepted CORBA invocation request on the client-side. This table provides the same fields of the CORBA Invocation Request.

reqcli.profile: is a table that contains the decoded profile data used to establish a connection with the servant's ORB. If the ORB is not able to establish a connection, this field is nil. The structure of this profile depends on the value of the profile_tag. For IIOP profiles (profile_tag == 0), this table follows the structure of CORBA::IIOP::ProfileBody_1_0.
reqcli.profile_data: is a string that contains the encoded profile data used to establish a connection with the servant's ORB. If the ORB is not able to establish a connection, this field is nil.
reqcli.profile_tag: is a number that is the identification of the kind of the IOR profile used to establish a connection with the servant's ORB. If the ORB is not able to establish a connection, this field is nil.

CORBA Server Invocation Request

Object that describes an intercepted CORBA invocation request on the server-side. This table provides the same fields of the CORBA Invocation Request.

reqsrv.servant: is the value registered as the servant of the invoked object. If the ORB cannot find a suitable target servant then this field is nil.

CORBA Invocation Request

request.forward_reference: is a table that contains a complete IOR structure (see CORBA::IOP::IOR in CORBA specs.) indicating that this request shall be forwarded to this reference. Set this value to forward this request to another reference.
request.interface: is a table that contains the complete description of the interface of the servant being invoked.
request.object_key: is a string that contains the key of the object the request is addressed to. If the ORB is not able to decode an IOR profile, this field is nil.
request.operation: is a table that is an object with the complete description of the operation being invoked. To change the operation being invoked on the remote servant, the application must set a new operation description to this field, which can be obtained from the local Interface Repository (see method orb:getLIR)
request.operation_name: is a string that contains the name of the operation being invoked.
request.parameters: is a table that contains a list of the parameters passed to the operation being invoked.
request.reference: is a table that contains the complete IOR structure (see CORBA::IOP::IOR in CORBA specs.) that identifies the servant the request is sent to.
request.reply_service_context: is a table that maps each service context ID to a service context data to be added to the reply of a cancelled request. If no service context data is provided then this field is nil.
request.request_id: is a number that identifies the pending request over the connection used to communicate with the remote ORB. Note that this identifier is not unique across different connections, and it may be reused by other requests after this one is completed (i.e. replied).
request.response_expected: is a boolean that indicates if the server must send a response for this request.
request.results: is a table that contains either a list of the values to be returned (in case of a successful invocation) or a list with a single value indicating the raised exception or error (in case of a failed invocation). Set this value to provide the result values of a canceled request. If the request have no results yet, this field is nil.
request.service_context: is a table that maps each service context ID to a service context data to be marshaled in the request. If no service context data is provided then this field is nil.
request.success: is a boolean that indicates whether the invocation request resulted in successful results (true) or in an error (false). If the request has not completed yet, this field is nil. The interceptor might set this field with a boolean value to cancel the request.

Servant

Object that represents a value registered as servant that implements a distributed object. This object behaves as simplified proxy of the distributed object. This means, that any method call performed on the servant results in the same call on its implementation object. However, the invocations performed through this object does not go through the ORB, so marshalling and interceptions will not take place. This object also provides the additional fields described below.

servant:__deactivate(): is a method that unregisters the servant from its broker.
servant.__objkey: is a string that Object key of the distributed object this servant implements
servant.__servant: Value registered as servant

TCP Options Table

tcpopt.keepalive: is a boolean that when is true enables the periodic transmission of messages on a connected socket. Should the connected party fail to respond to these messages, the connection is considered broken and processes using the socket are notified. The default value is false.
tcpopt.linger: is a table that controls the action taken when unsent data are queued on a socket and a close is performed. The value is a table with a boolean entry on and a numeric entry for the time interval timeout in seconds. If the on field is set to true, the system will block the process on the close attempt until it is able to transmit the data or until timeout has passed. If on is false and a close is issued, the system will process the close in a manner that allows the process to continue as quickly as possible.
tcpopt.reuseaddr: is a boolean that when is true indicates that the rules used in validating addresses supplied in a call to bind should allow reuse of local addresses. The default value is false.
tcpopt.tcp-nodelay: is a boolean that when is true disables the Nagle's algorithm for the connection. The default value is false.
tcpopt.timeout: is a number that defines the timeout in seconds of the sockets related operations invoked by the ORB. The default value is false.