This section describes the VisiBroker implementation of Portable Interceptors interfaces and classes as defined by the OMG Specification. For a complete description of these interfaces and classes, refer to
OMG Final Adopted Specification, ptc/2001-04-03, Portable Interceptors.
See “Using Portable Interceptors” in the VisiBroker C++ Developer's Guide before using these interfaces.
This class is derived from RequestInfo. It is passed to the client side interceptors point.
Some methods on ClientRequestInfo are not valid at all interception points. The following table shows the validity of each attribute or method. If an attribute is not valid, attempting to access it results in a
BAD_INV_ORDER being raised with a standard minor code of 14.
1 When ClientRequestInfo is passed to send_request(), there is an entry in the list for every argument, whether in, inout, or out. But only the in and inout arguments will be available.
2 If the reply_status() does not return LOCATION_FORWARD, accessing this attribute raises BAD_INV_ORDER with a standard minor code of 14.
|
Include the PortableInterceptor_c.hh file when you use this class.
This method returns the actual object on which the operation will be invoked. If the reply_status() returns
LOCATION_FORWARD, then on subsequent requests,
effective_target() will contain the forwarded IOR, while
target will remain unchanged.
This method returns the profile, in the form of IOP::TaggedProfile, that will be used to send the request. If a location forward has occurred for this operation's object and that object's profile changed accordingly, then this profile will be that located profile.
This method returns the data, in the form of CORBA::Any, that contains the exception to be returned to the client.
If the exception is a user exception which cannot be inserted into a CORBA::Any (for example, it is unknown or the bindings don't provide the
TypeCode), then this attribute will be a
CORBA::Any containing the system exception
UNKNOWN with a standard minor code of 1. However, the
RepositoryId of the exception is available in the
received_exception_id attribute.
This method returns the ID of the received_exception to be returned to the client.
This methods returns the IOP::TaggedComponent with the given ID from the profile selected for this request.
virtual void add_request_service_context(
const IOP::ServiceContext&
_service_context,
CORBA::Boolean
_replace) = 0;
This ClientRequestInterceptor class is used to derive user-defined client side interceptor. A
ClientRequestInterceptor instance is registered with the VisiBroker ORB (go to
“ORBInitializer” on page 222 for more information).
Include the PortableInterceptor_c.hh file when you use this class.
This send_request() interception point allows an interceptor to query request information and modify the service context before the request is sent to the server.
This interception point may raise a system exception. If it does, no other interceptors' send_request() interception points are called. Those interceptors on the Flow Stack are popped and their
receive_exception() interception points are called.
This interception point may also raise a ForwardRequest exception (go to
“ForwardRequest” on page 217 for more information). If an Interception raises this exception, no other interceptors'
send_request methods are called. The remaining interceptors in the Flow Stack are popped and have their
receive_other() interception point called.
This send_poll() interception point allows an interceptor to query information during a Time-Independent Invocation (TII) polling get reply sequence.
This receive_reply() interception point allows an interceptor to query the information on a reply after it is returned from the server and before control is returned to the client.
This interception point may raise a system exception. If it does, no other interceptors' receive_reply() methods are called. The remaining interceptors in the Flow Stack will have their
receive_exception() interception point called.
virtual void receive_exception(ClientRequestInfo_ptr
_ri) = 0;
This receive_exception() interception point is called when an exception occurs. It allows an interceptor to query the exception's information before it is raised to the client.
This interception point may also raise a ForwardRequest exception (go to
“ForwardRequest” on page 217 for more information). If an interceptor raises this exception, no other interceptors'
receive_exception() interception points are called. The remaining interceptors in the Flow Stack are popped and have their
receive_other() interception point called.
This receive_other() interception point allows an interceptor to query the information available when a request results in something other than a normal reply or an exception. For example, a request could result in a retry (for example, a GIOP Reply with a
LOCATION_FORWARD status was received), or on asynchronous calls, the reply does not immediately follow the request, but control will return to the client and an ending interception point will be called.
This interception point may raise a system exception. If it does, no other interceptors' receive_other() interception points are called. The remaining interceptors in the Flow Stack are popped and have their
receive_exception() interception point called.
This interception point may also raise a ForwardRequest exception (go to
“ForwardRequest” on page 217 for more information). If an interceptor raises this exception, successive interceptors'
receive_other() methods are called with the new information provided by the
ForwardRequest exception.
A Codec is obtained from the
CodecFactory. The
CodecFactory is obtained through a call to
ORB::resolve_initial_references("CodecFactory").
Include the IOP_c.hh file when you use this class.
This exception is raised by encode() or
encode_value() when an invalid type is specified for the encoding.
This exception is raised by decode() or
decode_value() when the data in the octet sequence cannot be decoded into a
CORBA::Any.
This exception is raised by decode_value() when the given
TypeCode does not match the given octet sequence.
This method converts the given data in the form of a CORBA::Any into an octet sequence based on the encoding format effective for this
Codec. This octet sequence contains both the
TypeCode and the data of the type.
This operation may raise InvalidTypeForEncoding.
This method decodes the given octet sequence into a CORBA::Any object based on the encoding format effective for this
Codec.
This method raises FormatMismatch if the octet sequence cannot be decoded into a
CORBA::Any.
This method converts the given CORBA::Any object into an octet sequence based on the encoding format effective for this
Codec. Only the data from the
CORBA::Any is encoded, not the
TypeCode.
This operation may raise InvalidTypeForEncoding.
virtual CORBA::Any* decode_value(const CORBA::OctetSequence&
_data,CORBA::TypeCode_ptr
_tc) = 0;
This method decodes the given octet sequence into a CORBA::Any based on the given
TypeCode and the encoding format effective for this
Codec.
This method raises FormatMismatch if the octet sequence cannot be decoded into a
CORBA::Any.
This class is used to obtained a Codec. The
CodecFactory is obtained through a call to
ORB::resolve_initial_references("CodecFactory").
Include the IOP_c.hh file when you use this class.
This exception is raised if CodecFactory cannot create a
Codec. See
create_codec() function below.
This create_codec() method creates a
Codec of the given encoding.
This method raises UnknownEncoding if this factory cannot create a
Codec of the given encoding.
The Current class is merely a slot table, the slots of which are used by each service to transfer their context data between their context and the request's or reply's service context.
Each service which wishes to use Current reserves a slot or slots at initialization time (go to
“virtual CORBA::ULong allocate_slot_id() = 0;” on page 225 for more information) and uses those slots during the processing of requests and replies.
Before an invocation is made, Current is obtained by way of a call to
ORB::resolve_initial_references("PICurrent").
From within the interception points, the data on Current that has moved from the thread scope to the request scope is available by way of the
get_slot() method on the
RequestInfo object. A
Current can still be obtained by way of
resolve_initial_references(), but that is the interceptor's thread scope
Current.
Include the PortableInterceptor_c.hh file when you use this class.
A service can get the slot data it sets in PICurrent by way of the
get_slot() method. The data is in the form of a
CORBA::Any object.
If the given slot has not been set, a CORBA::Any containing a type code with a
TCKind value of
tk_null, no value is returned.
If get_slot() is called on a slot that has not been allocated,
InvalidSlot is raised.
If get_slot() is called from within an ORB initializer,
BAD_INV_ORDER with a minor code of 14 is raised.
|
|
|
|
|
SlotId of the slot from which the data will be returned.
|
virtual void set_slot(CORBA::ULong
_id, const CORBA::Any&
_data);
A service sets data in a slot with set_slot(). The data is in the form of a
CORBA::Any object.
If set_slot() is called on a slot that has not been allocated,
InvalidSlot is raised.
If set_slot() is called from within an ORB initializer (go to
“ORBInitializer” on page 222 for more information)
BAD_INV_ORDER with a minor code of 14 is raised.
|
|
|
|
|
SlotId of the slot from which the data will be set.
|
|
|
data, in the form of a CORBA::Any object, which will be set to the identified slot.
|
This structure defines the encoding format of a Codec. It details the encoding format, such as CDR Encapsulation encoding, and the major and minor versions of that format.
Include the IOP_c.hh file when you use this
struct.
Use this class to hold exceptions information returned from the method exceptions() in the class
RequestInfo. It is an implementation of variable-length array of type
CORBA::TypeCode. The length of
ExceptionList is available at run time.
Include the Dynamic_c.hh file when you use this class.
The ForwardRequest exception is the means by which an interceptor can indicate to the ORB that a retry of the request should occur with the new object given in the exception. This behavior of causing a retry only occurs if the ORB receives a
ForwardRequest from an interceptor. If
ForwardRequest is raised anywhere else, it is passed through the ORB as is normal for a user exception.
If an interceptor raises a ForwardRequest exception in response to a call of an interceptor, no other interceptors are called for that interception point. The remaining interceptors in the Flow Stack will have their appropriate ending interception point called:
receive_other() on the client, or
send_other() on the server. The
reply_status() in the
receive_other() or
send_other() will return
LOCATION_FORWARD.
Include the PortableInterceptor_c.hh file when you use this class.
Include the PortableInterceptor_c.hh file when you use this class.
This method is called during ORB::destroy(). When
ORB::destroy() is called by an application, the VisiBroker ORB:
|
2
|
calls the Interceptor::destroy() method for each interceptor
|
Method invocations from within Interceptor::destroy() on object references for objects implemented on the ORB being destroyed result in undefined behavior. However, method invocations on objects implemented on VisiBroker ORB, other than the one being destroyed, are permitted. (This means that the VisiBroker ORB being destroyed is still capable of acting as a client, but not as a server.)
The IORInfo interface provides the server side ORB service with access to the applicable policies during IOR construction and the ability to add components. The ORB passes an instance of its implementation of this interface as a parameter to
IORInterceptor::establish_components().
If an illegal call is made to an attribute or method in IORInfo, the
BAD_INV_ORDER system exception is raised with a standard minor code value of 14.
Include the PortableInterceptor_c.hh file when you use this class.
An ORB service implementation may determine what server side policy of a particular type is in effect for an IOR being constructed by calling the get_effective_policy() method. When the IOR being constructed is for an object implemented using a POA, all Policy objects passed to the
PortableServer::POA::create_POA() call that created that POA are accessible via
get_effective_policy.
virtual void add_ior_component(const IOP::TaggedComponent&
_a_component) = 0;
This method is called from establish_components() to add a tagged component to the set which will be included when constructing IORs. The components in this set will be included in all profiles.
virtual void add_ior_component_to_profile(const IOP::TaggedComponent&
_a_component, CORBA::ULong
_profile_id) = 0;
This method is called from establish_components() to add a tagged component to the set which will be included when constructing IORs. The components in this set will be included in the specified profile.
This method returns the attribute that provides a means to obtain an object reference template whenever an IOR interceptor is invoked. There is no standard way to directly create an object reference template. The value of adapter_template() returns is the template created for the adapter policies and IOR interceptor calls to
add_component() and
add_component_to_profile(). The value of the
adapter_template() returns is never changed for the lifetime of the object adapter.
This method returns the attribute that provides access to the factory that will be used by the adapter to create object references. current_factory() initially has the same value as the
adapter_template attribute, but this can be changed by setting
current_factory to another factory. All object references created by the object adapter must be created by calling the
make_object() method on
current_factory.
virtual void current_factory(ObjectReferenceFactory_ptr
_current_factory) = 0;
This method sets the current_factory attribute. The value of the
current_factory attribute that is used by the adapter can only be set during the call to the
components_established method.
class IORInfoExt: public PortableInterceptor::IORInfo
Include the PortableInterceptorExt_c.hh file when you use this class.
This is supported through the IORInterceptor and
IORInfo interfaces.
Include the PortableInterceptor_c.hh file when you use this class.
A server side ORB calls the establish_components() method on all registered
IORInterceptor instances when it is assembling the list of components that will be included in the profile(s) of an object reference. This method is not necessarily called for each individual object reference. In the case of the POA, these calls are made each time
POA::create_POA() is called. In other adapters, these calls would typically be made when the adapter is initialized. The adapter template is not available at this stage since information (the components) needed in the adapter template is being constructed.
|
|
|
|
|
IORInfo instance used by the ORB service to query applicable policies and add components to be included in the generated IORs.
|
After all of the establish_components() methods have been called, the
components_established() methods are invoked on all registered IOR interceptors. The adapter template is available at this stage. The
current_factory attribute may be get or set at this stage.
Any exception that occurs in components_established() is returned to the caller of
components_established(). In the case of the POA, this causes the
create_POA call to fail, and an
OBJ_ADAPTER exception with a standard minor code of 6 is returned to the invoker of
create_POA().
|
|
|
|
|
IORInfo instance used by the ORB service to access applicable policies.
|
virtual void adapter_manager_state_changed(CORBA::Long
_id, CORBA::Short
_state) = 0;
Any time the state of an adapter manager changes, the adapter_manager_state_changed() method is invoked on all registered IOR interceptors.
If a state change is reported through adapter_manager_state_changed(), it is not reported through
adapter_state_changed().
|
|
|
|
|
IORInfo instance used by the ORB service to access applicable policies.
|
|
|
|
virtual void adapter_state_changed(const ObjectReferenceTemplateSeq&
_templates, CORBA::Short
_state) = 0;
An interceptor is registered by registering an associated ORBInitializer object which implements the
ORBInitializer class. When an ORB is initializing, it calls each registered
ORBInitializer, passing it an
ORBInitInfo object which is used to register its interceptor.
Include the PortableInterceptor_c.hh file when you use this class.
Calling the post_init() methods is not the final task of ORB initialization. The final task, following the
post_init() calls, is attaching the lists of registered interceptors to the ORB. Therefore, the ORB does not contain the interceptors during calls to
post_init(). If an ORB-mediated call is made from within
post_init(), no request interceptors will be invoked on that call. Likewise, if a method is performed which causes an IOR to be created, no IOR interceptors will be invoked.
This ORBInitInfo class is passed to
ORBInitializer object for registering interceptors.
Include the PortableInterceptor_c.hh file when you use this class.
class DuplicateName : public CORBA_UserException;
class InvalidName: public CORBA_UserException
This exception is raised by register_initial_reference() and
resolve_initial_references().
resolve_initial_references() raises
InvalidName if the name to be resolved is invalid.
This method returns the arguments passed to ORB_init(). They may or may not contain the ORB's arguments.
This method returns the IOP::CodecFactory. The
CodecFactory is normally obtained via a call to
ORB::resolve_initial_references("CodecFactory"), but since the ORB is not yet available and interceptors, particularly when processing service contexts, will require a
Codec, a means of obtaining a
Codec is necessary during ORB initialization.
virtual void register_initial_reference(const char*
_id, CORBA::Object_ptr
_obj) = 0;
If this method is called with an id, "Y", and an object,
YY, then a subsequent call to
register_initial_reference() will return object
YY.
This method is identical to ORB::register_initial_reference(). This same functionality exists here because the ORB, not yet fully initialized, is not yet available but initial references may need to be registered as part of Interceptor registration. The only difference is that the version of this method on the ORB uses PIDL (
CORBA::ORB::ObjectId and
CORBA::ORB::InvalidName) whereas the version in this interface uses IDL defined in this interface; the semantics are identical.
This method is only valid during post_init(). It is identical to
ORB::resolve_initial_references(). This same functionality exists here because the ORB, not yet fully initialized, is not yet available but initial references may be required from the ORB as part of Interceptor registration.
If the name to be resolved is invalid, resolve_initial_references() will raise
InvalidName.
virtual void add_client_request_interceptor(ClientRequestInterceptor_ptr
_interceptor) = 0;
virtual void add_server_request_interceptor(
ServerRequestInterceptor_ptr
_interceptor) = 0;
virtual void add_ior_interceptor(IORInterceptor_ptr
_interceptor) = 0;
A service calls allocate_slot_id to allocate a slot on
PortableInterceptor::Current.
While slot id's can be allocated within an ORB initializer, the slots themselves cannot be initialized. Calling set_slot() or
get_slot() on the
Current within an ORB initializer will raise a
BAD_INV_ORDER with a minor code of 14.
virtual void register_policy_factory(CORBA::ULong
_type, PolicyFactory_ptr
_policy_factory) = 0;
This method registers a PolicyFactory for the given
PolicyType.
If a PolicyFactory already exists for the given
PolicyType,
BAD_INV_ORDER is raised with a standard minor code of 16.
Include the Dynamic_c.hh file when you use this
struct.
This class is used to pass parameters information returned from the method arguments() in the class
RequestInfo. It is an implementation of variable-length array of type
Parameter. The length of
ParameterList is available at run-time.
Include the Dynamic_c.hh file when you use this class.
A portable ORB service implementation registers an instance of the PolicyFactory interface during ORB initialization. The POA is required to preserve any policy which is registered with
ORBInitInfo in this manner.
Include the PortableInterceptor_c.hh file when you use this class.
The ORB calls create_policy() on a registered
PolicyFactory instance when
CORBA::ORB::create_policy() is called for the
PolicyType under which the
PolicyFactory has been registered. The
create_policy() method then returns an instance of the appropriate interface derived from
CORBA::Policy whose value corresponds to the specified
CORBA::Any. If it cannot, it will raise an exception as described for
CORBA::ORB::create_policy().
|
|
|
|
|
A CORBA::PolicyType specifying the type of policy being created.
|
|
|
An CORBA::Any containing data with which to construct the CORBA::Policy.
|
This is the base class from which ClientRequestInfo and
ServerRequestInfo are derived. Each interception point is given an object through which the Interceptor can access request information. client side and server side interception points are concerned with different information, so there are two information objects:
ClientRequestInfo is passed to the client side interception points and
ServerRequestInfo is passed to the server side interception points. But there is information that is common to both, so they both inherit from this common interface:
RequestInfo.
Include the PortableInterceptor_c.hh file when you use this class.
This ID is not the same as the GIOP request_id. If GIOP is the transport mechanism used, then these IDs may very well be the same, but this is not guaranteed nor required.
This method returns a Dynamic::ExceptionList describing the
TypeCodes of the user exceptions that this operation invocation may raise. If there are no user exceptions, this attribute will be a zero length sequence.
This method returns a CORBA::StringSequence describing the contexts that may be passed on this operation invocation. If there are no contexts, this attribute will be a zero length sequence.
This method returns a CORBA::StringSequence containing the contexts being sent on the request.
This method returns the data, in the form of CORBA::Any, that contains the result of the operation invocation. If the operation return type is void, this attribute will be a
CORBA::Any containing a type code with a
TCKind value of
tk_void and no value.
On the client, a reply is not returned when response_expected() is false, so
receive_reply() cannot be called.
receive_other() is called unless an exception occurs, in which case
receive_exception() is called.
This method returns an attribute, defined in the Messaging specification, is pertinent only when response_expected() is false. If
response_expected() is true, the value of
sync_scope() is undefined. It defines how far the request will progress before control is returned to the client. This attribute may have one of the following values:
For SYNC_WITH_SERVER and
SYNC_WITH_TARGET, the server does send an empty reply back to the client before the target is invoked. This reply is not intercepted by server side Interceptors.
|
•
|
Within the receive_reply interception point, this attribute will only be SUCCESSFUL.
|
|
•
|
Within the receive_exception interception point, this attribute will be either SYSTEM_EXCEPTION or USER_EXCEPTION.
|
|
•
|
Within the receive_other interception point, this attribute will be any of: SUCCESSFUL, LOCATION_FORWARD, or TRANSPORT_RETRY. SUCCESSFUL means an asynchronous request returned successfully. LOCATION_FORWARD means that a reply came back with LOCATION_FORWARD as its status. TRANSPORT_RETRY means that the transport mechanism indicated a retry - a GIOP reply with a status of NEEDS_ADDRESSING_MODE, for instance.
|
|
•
|
Within the send_reply interception point, this attribute will only be SUCCESSFUL.
|
|
•
|
Within the send_exception interception point, this attribute will be either SYSTEM_EXCEPTION or USER_EXCEPTION.
|
|
•
|
Within the send_other interception point, this attribute will be any of: SUCCESSFUL, or LOCATION_FORWARD. SUCCESSFUL means an asynchronous request returned successfully. LOCATION_FORWARD means that a reply came back with LOCATION_FORWARD as its status.
|
If the reply_status() returns
LOCATION_FORWARD, then this method returns an object to which the request will be forwarded. It is indeterminate whether a forwarded request will actually occur.
This method returns the data, in the form of a CORBA::Any, from the given slot of the
PortableInterceptor::Current that is in the scope of the request.
If the given slot has not been set, then a CORBA::Any containing a type code with a
TCKind value of
tk_null is returned.
Go to “Current” on page 215 for an explanation of slots and the
PortableInterceptor::Current.
|
|
|
|
|
SlotId of the slot which is to be returned.
|
This class is derived from RequestInfo. It is passed to server side interception points.
Some methods on ServerRequestInfo are not valid at all interception points. The table below shows the validity of each attribute or method. If it is not valid, attempting to access it will result in a
BAD_INV_ORDER being raised with a standard minor code of 14.
1When ServerRequestInfo is passed to receive_request(), there is an entry in the list for every argument, whether in, inout, or out. But only the in and inout arguments will be available.
2If the reply_status() does not returns LOCATION_FORWARD, accessing this attribute will raise BAD_INV_ORDER with a standard minor code of 14.
3If the servant locator caused a location forward, or raised an exception, this attribute / method may not be available in this interception point. NO_RESOURCES with a standard minor code of 1 will be raised if it is not available.
4The method is not available in this interception point because the necessary information requires access to the target object's servant, which may no longer be available to the ORB. For example, if the object's adapter is a POA that uses a ServantLocator, then the ORB invokes the interception point after it calls ServantLocator::postinvoke().
|
Include the PortableInterceptor_c.hh file when you use this class.
This method returns data, in the form CORBA::Any, that contains the exception to be returned to the client.
If the exception is a user exception which cannot be inserted into a CORBA::Any (e.g., it is unknown or the bindings don't provide the
TypeCode), then this attribute will be an
CORBA::Any containing the system exception
UNKNOWN with a standard minor code of 1.
This method returns the value that was passed into the ORB::init call using the
-ORBServerId argument when the ORB was created.
In Java, this is accomplished using the -ORBid argument in the
ORB.init call that created the ORB containing the object adapter that created this template. What happens if the same
ORBid is used on multiple
ORB::init() calls in the same server is currently undefined.
This method returns the opaque object_id, in the form of CORBA::OctetSequence, that describes the target of the operation invocation.
This method returns the RepositoryID for the most derived interface of the servant.
This method returns the policy in effect for this operation for the given policy type. The returned CORBA::Policy object will only be a policy whose type was registered via
register_policy_factory().
If a policy for the given type was not registered via register_policy_factory, this method will raise
INV_POLICY with a standard minor code of 3.
|
|
|
|
|
The CORBA::PolicyType which specifies the policy to be returned.
|
virtual void set_slot(CORBA::ULong
_id, const CORBA::Any&
_data) = 0;
This method allows an Interceptor to set a slot in the PortableInterceptor::Current that is in the scope of the request. If data already exists in that slot, it will be overwritten.
Go to “Current” on page 215 for an explanation of slots and
PortableInterceptor::Current.
virtual void add_reply_service_context(const IOP::ServiceContext&
_service_context,CORBA::Boolean
_replace) = 0;
This ServerRequestInterceptor class is used to derive user-defined server side interceptor. A
ServerRequestInterceptor instance is registered with the ORB (go to
“ORBInitializer” on page 222 for more information).
Include the PortableInterceptor_c.hh file when you use this class.
virtual void receive_request_service_contexts(
ServerRequestInfo_ptr
_ri) = 0;
At this receive_request_service_contexts() interception point, Interceptors must get their service context information from the incoming request and transfer it to
PortableInterceptor::Current's slots.
This interception point may raise a system exception. If it does, no other Interceptors' receive_request_service_contexts() interception points are called. Those Interceptors on the Flow Stack are popped and their
send_exception() interception points are called.
This interception point may also raise a ForwardRequest exception (go to
“ForwardRequest” on page 217 for more information). If an Interceptor raises this exception, no other Interceptors'
receive_request_service_contexts() methods are called. Those Interceptors on the Flow Stack are popped and their
send_other interception points are called.
|
|
|
|
|
This is the ServerRequestInfo instance to be used by Interceptor.
|
virtual void receive_request(ServerRequestInfo_ptr
_ri) = 0;
This receive_request() interception point allows an Interceptor to query request information after all the information, including method parameters, are available. This interception point will execute in the same thread as the target invocation.
In the DSI model, since the parameters are first available when the user code calls arguments(),
receive_request() is called from within
arguments(). It is possible that
arguments() is not called in the DSI model. The target may call
set_exception() before calling
arguments(). The ORB will guarantee that
receive_request() is called once, either through
arguments() or through
set_exception(). If it is called through
set_exception(), requesting the
arguments() will result in
NO_RESOURCES being raised with a standard minor code of 1.
This interception point may raise a system exception. If it does, no other Interceptors' receive_request() methods are called. Those Interceptors on the Flow Stack are popped and their
send_exception interception points are called.
This interception point may also raise a ForwardRequest exception (go to
“ForwardRequest” on page 217 for more information). If an Interceptor raises this exception, no other Interceptors'
receive_request() methods are called. Those Interceptors on the Flow Stack are popped and their
send_other() interception points are called.
|
|
|
|
|
This is the ServerRequestInfo instance to be used by Interceptor.
|
This send_reply() interception point allows an Interceptor to query reply information and modify the reply service context after the target operation has been invoked and before the reply is returned to the client. This interception point will execute in the same thread as the target invocation.
This interception point may raise a system exception. If it does, no other Interceptors' send_reply() interception points are called. The remaining Interceptors in the Flow Stack will have their
send_exception() interception point called.
|
|
|
|
|
This is the ServerRequestInfo instance to be used by Interceptor.
|
This send_exception() interception point is called when an exception occurs. It allows an Interceptor to query the exception information and modify the reply service context before the exception is raised to the client. This interception point will execute in the same thread as the target invocation.
This interception point may also raise a ForwardRequest exception (go to
“ForwardRequest” on page 217 for more information). If an Interceptor raises this exception, no other Interceptors'
send_exception() interception points are called. The remaining Interceptors in the Flow Stack will have their
send_other interception points called.
This send_other() interception point allows an Interceptor to query the information available when a request results in something other than a normal reply or an exception. For example, a request could result in a retry (e.g., a GIOP Reply with a
LOCATION_FORWARD status was received). This interception point will execute in the same thread as the target invocation.
This interception point may raise a system exception. If it does, no other Interceptors' send_other() methods are called. The remaining Interceptors in the Flow Stack will have their
send_exception interception points called.