/*
* Copyright (c) 2000, 2003, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.corba.se.impl.interceptors;
import org.omg.CORBA.BAD_PARAM;
import org.omg.CORBA.BAD_INV_ORDER;
import org.omg.CORBA.CompletionStatus;
import org.omg.CORBA.NO_IMPLEMENT;
import org.omg.CORBA.OBJECT_NOT_EXIST;
import org.omg.CORBA.LocalObject;
import org.omg.CORBA.Policy;
import org.omg.CORBA.PolicyError;
import org.omg.IOP.CodecFactory;
import org.omg.PortableInterceptor.ORBInitInfo;
import org.omg.PortableInterceptor.ClientRequestInterceptor;
import org.omg.PortableInterceptor.IORInterceptor;
import org.omg.PortableInterceptor.PolicyFactory;
import org.omg.PortableInterceptor.ServerRequestInterceptor;
import org.omg.PortableInterceptor.ORBInitInfoPackage.DuplicateName;
import org.omg.PortableInterceptor.ORBInitInfoPackage.InvalidName;
import com.sun.corba.se.spi.orb.ORB;
import com.sun.corba.se.spi.legacy.interceptor.ORBInitInfoExt ;
import com.sun.corba.se.spi.logging.CORBALogDomains;
import com.sun.corba.se.impl.orbutil.ORBUtility;
import com.sun.corba.se.impl.logging.InterceptorsSystemException;
import com.sun.corba.se.impl.logging.ORBUtilSystemException;
import com.sun.corba.se.impl.logging.OMGSystemException;
/**
* ORBInitInfoImpl is the implementation of the ORBInitInfo class to be
* passed to ORBInitializers, as described in orbos/99-12-02.
*/
public final class ORBInitInfoImpl
extends org.omg.CORBA.LocalObject
implements ORBInitInfo, ORBInitInfoExt
{
// The ORB we are initializing
private ORB orb;
private InterceptorsSystemException wrapper ;
private ORBUtilSystemException orbutilWrapper ;
private OMGSystemException omgWrapper ;
// The arguments passed to ORB_init
private String[] args;
// The ID of the ORB being initialized
private String orbId;
// The CodecFactory
private CodecFactory codecFactory;
// The current stage of initialization
private int stage = STAGE_PRE_INIT;
// The pre-initialization stage (pre_init() being called)
public static final int STAGE_PRE_INIT = 0;
// The post-initialization stage (post_init() being called)
public static final int STAGE_POST_INIT = 1;
// Reject all calls - this object should no longer be around.
public static final int STAGE_CLOSED = 2;
// The description for the OBJECT_NOT_EXIST exception in STAGE_CLOSED
private static final String MESSAGE_ORBINITINFO_INVALID =
"ORBInitInfo object is only valid during ORB_init";
/**
* Creates a new ORBInitInfoImpl object (scoped to package)
*
* @param args The arguments passed to ORB_init.
*/
ORBInitInfoImpl( ORB orb, String[] args,
String orbId, CodecFactory codecFactory )
{
this.orb = orb;
wrapper = InterceptorsSystemException.get( orb,
CORBALogDomains.RPC_PROTOCOL ) ;
orbutilWrapper = ORBUtilSystemException.get( orb,
CORBALogDomains.RPC_PROTOCOL ) ;
omgWrapper = OMGSystemException.get( orb,
CORBALogDomains.RPC_PROTOCOL ) ;
this.args = args;
this.orbId = orbId;
this.codecFactory = codecFactory;
}
/** Return the ORB behind this ORBInitInfo. This is defined in the
* ORBInitInfoExt interface.
*/
public ORB getORB()
{
return orb ;
}
/**
* Sets the current stage we are in. This limits access to certain
* functionality.
*/
void setStage( int stage ) {
this.stage = stage;
}
/**
* Throws an exception if the current stage is STAGE_CLOSED.
* This is called before any method is invoked to ensure that
* no method invocations are attempted after all calls to post_init()
* are completed.
*/
private void checkStage() {
if( stage == STAGE_CLOSED ) {
throw wrapper.orbinitinfoInvalid() ;
}
}
/*
*******************************************************************
* The following are implementations of the ORBInitInfo operations.
*******************************************************************/
/**
* This attribute contains the arguments passed to ORB_init. They may
* or may not contain the ORB's arguments
*/
public String[] arguments () {
checkStage();
return args;
}
/**
* This attribute is the ID of the ORB being initialized
*/
public String orb_id () {
checkStage();
return orbId;
}
/**
* This attribute is 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 intialization.
*/
public CodecFactory codec_factory () {
checkStage();
return codecFactory;
}
/**
* See orbos/99-12-02, Chapter 11, Dynamic Initial References on page
* 11-81. This operation is identical to ORB::register_initial_reference
* described there. 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.
* <p>
* This method may not be called during post_init.
*/
public void register_initial_reference( String id,
org.omg.CORBA.Object obj )
throws InvalidName
{
checkStage();
if( id == null ) nullParam();
// As per CORBA 3.0 section 21.8.1,
// if null is passed as the obj parameter,
// throw BAD_PARAM with minor code OMGSystemException.RIR_WITH_NULL_OBJECT.
// Though the spec is talking about IDL null, we will address both
// Java null and IDL null:
// Note: Local Objects can never be nil!
if( obj == null ) {
throw omgWrapper.rirWithNullObject() ;
}
// This check was made to determine that the objref is a
// non-local objref that is fully
// initialized: this was called only for its side-effects of
// possibly throwing exceptions. However, registering
// local objects should be permitted!
// XXX/Revisit?
// IOR ior = ORBUtility.getIOR( obj ) ;
// Delegate to ORB. If ORB version throws InvalidName, convert to
// equivalent Portable Interceptors InvalidName.
try {
orb.register_initial_reference( id, obj );
} catch( org.omg.CORBA.ORBPackage.InvalidName e ) {
InvalidName exc = new InvalidName( e.getMessage() );
exc.initCause( e ) ;
throw exc ;
}
}
/**
* This operation 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.
* <p>
* (incorporates changes from errata in orbos/00-01-01)
* <p>
* This method may not be called during pre_init.
*/
public org.omg.CORBA.Object resolve_initial_references (String id)
throws InvalidName
{
checkStage();
if( id == null ) nullParam();
if( stage == STAGE_PRE_INIT ) {
// Initializer is not allowed to invoke this method during
// this stage.
// _REVISIT_ Spec issue: What exception should really be
// thrown here?
throw wrapper.rirInvalidPreInit() ;
}
org.omg.CORBA.Object objRef = null;
try {
objRef = orb.resolve_initial_references( id );
}
catch( org.omg.CORBA.ORBPackage.InvalidName e ) {
// Convert PIDL to IDL exception:
throw new InvalidName();
}
return objRef;
}
// New method from CORBA 3.1
public void add_client_request_interceptor_with_policy (
ClientRequestInterceptor interceptor, Policy[] policies )
throws DuplicateName
{
// XXX ignore policies for now
add_client_request_interceptor( interceptor ) ;
}
/**
* This operation is used to add a client-side request Interceptor to
* the list of client-side request Interceptors.
* <p>
* If a client-side request Interceptor has already been registered
* with this Interceptor's name, DuplicateName is raised.
*/
public void add_client_request_interceptor (
ClientRequestInterceptor interceptor)
throws DuplicateName
{
checkStage();
if( interceptor == null ) nullParam();
orb.getPIHandler().register_interceptor( interceptor,
InterceptorList.INTERCEPTOR_TYPE_CLIENT );
}
// New method from CORBA 3.1
public void add_server_request_interceptor_with_policy (
ServerRequestInterceptor interceptor, Policy[] policies )
throws DuplicateName, PolicyError
{
// XXX ignore policies for now
add_server_request_interceptor( interceptor ) ;
}
/**
* This operation is used to add a server-side request Interceptor to
* the list of server-side request Interceptors.
* <p>
* If a server-side request Interceptor has already been registered
* with this Interceptor's name, DuplicateName is raised.
*/
public void add_server_request_interceptor (
ServerRequestInterceptor interceptor)
throws DuplicateName
{
checkStage();
if( interceptor == null ) nullParam();
orb.getPIHandler().register_interceptor( interceptor,
InterceptorList.INTERCEPTOR_TYPE_SERVER );
}
// New method from CORBA 3.1
public void add_ior_interceptor_with_policy (
IORInterceptor interceptor, Policy[] policies )
throws DuplicateName, PolicyError
{
// XXX ignore policies for now
add_ior_interceptor( interceptor ) ;
}
/**
* This operation is used to add an IOR Interceptor to
* the list of IOR Interceptors.
* <p>
* If an IOR Interceptor has already been registered
* with this Interceptor's name, DuplicateName is raised.
*/
public void add_ior_interceptor (
IORInterceptor interceptor )
throws DuplicateName
{
checkStage();
if( interceptor == null ) nullParam();
orb.getPIHandler().register_interceptor( interceptor,
InterceptorList.INTERCEPTOR_TYPE_IOR );
}
/**
* A service calls allocate_slot_id to allocate a slot on
* PortableInterceptor::Current.
*
* @return The index to the slot which has been allocated.
*/
public int allocate_slot_id () {
checkStage();
return ((PICurrent)orb.getPIHandler().getPICurrent()).allocateSlotId( );
}
/**
* Register a PolicyFactory for the given PolicyType.
* <p>
* If a PolicyFactory already exists for the given PolicyType,
* BAD_INV_ORDER is raised with a minor code of TBD_BIO+2.
*/
public void register_policy_factory( int type,
PolicyFactory policy_factory )
{
checkStage();
if( policy_factory == null ) nullParam();
orb.getPIHandler().registerPolicyFactory( type, policy_factory );
}
/**
* Called when an invalid null parameter was passed. Throws a
* BAD_PARAM with a minor code of 1
*/
private void nullParam()
throws BAD_PARAM
{
throw orbutilWrapper.nullParam() ;
}
}