package org.jacorb.poa;
/*
* JacORB - a free Java ORB
*
* Copyright (C) 1997-2004 Gerald Brose.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
import java.util.Enumeration;
import java.util.Hashtable;
import org.jacorb.config.*;
import org.slf4j.Logger;
import org.jacorb.orb.dsi.ServerRequest;
import org.jacorb.poa.except.ApplicationError;
import org.jacorb.poa.except.POAInternalError;
import org.jacorb.poa.except.ParentIsHolding;
import org.jacorb.poa.except.ResourceLimitReachedException;
import org.jacorb.poa.util.ByteArrayKey;
import org.jacorb.poa.util.IdUtil;
import org.jacorb.poa.util.POAUtil;
import org.jacorb.ssl.SSLPolicy;
import org.jacorb.ssl.SSLPolicyValue;
import org.jacorb.ssl.SSL_POLICY_TYPE;
import org.jacorb.util.ObjectUtil;
import org.omg.BiDirPolicy.BIDIRECTIONAL_POLICY_TYPE;
import org.omg.BiDirPolicy.BidirectionalPolicy;
import org.omg.CORBA.BAD_PARAM;
import org.omg.PortableServer.AdapterActivator;
import org.omg.PortableServer.ID_ASSIGNMENT_POLICY_ID;
import org.omg.PortableServer.ID_UNIQUENESS_POLICY_ID;
import org.omg.PortableServer.IMPLICIT_ACTIVATION_POLICY_ID;
import org.omg.PortableServer.IdAssignmentPolicy;
import org.omg.PortableServer.IdAssignmentPolicyValue;
import org.omg.PortableServer.IdUniquenessPolicy;
import org.omg.PortableServer.IdUniquenessPolicyValue;
import org.omg.PortableServer.ImplicitActivationPolicy;
import org.omg.PortableServer.ImplicitActivationPolicyValue;
import org.omg.PortableServer.LIFESPAN_POLICY_ID;
import org.omg.PortableServer.LifespanPolicy;
import org.omg.PortableServer.LifespanPolicyValue;
import org.omg.PortableServer.REQUEST_PROCESSING_POLICY_ID;
import org.omg.PortableServer.RequestProcessingPolicy;
import org.omg.PortableServer.RequestProcessingPolicyValue;
import org.omg.PortableServer.SERVANT_RETENTION_POLICY_ID;
import org.omg.PortableServer.Servant;
import org.omg.PortableServer.ServantActivator;
import org.omg.PortableServer.ServantManager;
import org.omg.PortableServer.ServantRetentionPolicy;
import org.omg.PortableServer.ServantRetentionPolicyValue;
import org.omg.PortableServer.THREAD_POLICY_ID;
import org.omg.PortableServer.ThreadPolicy;
import org.omg.PortableServer.ThreadPolicyValue;
import org.omg.PortableServer._POALocalBase;
import org.omg.PortableServer.POAManagerPackage.State;
import org.omg.PortableServer.POAPackage.AdapterAlreadyExists;
import org.omg.PortableServer.POAPackage.AdapterNonExistent;
import org.omg.PortableServer.POAPackage.InvalidPolicy;
import org.omg.PortableServer.POAPackage.NoServant;
import org.omg.PortableServer.POAPackage.ObjectAlreadyActive;
import org.omg.PortableServer.POAPackage.ObjectNotActive;
import org.omg.PortableServer.POAPackage.ServantAlreadyActive;
import org.omg.PortableServer.POAPackage.ServantNotActive;
import org.omg.PortableServer.POAPackage.WrongAdapter;
import org.omg.PortableServer.POAPackage.WrongPolicy;
/**
* The main POA class, an implementation of
* <code>org.omg.PortableServer.POA</code>
*
* @author Reimo Tiedemann, FU Berlin
* @version $Id: POA.java,v 1.69.2.2 2012-02-08 15:41:35 nick.cross Exp $
*/
public class POA
extends _POALocalBase
implements Configurable
{
// my orb instance
private final org.jacorb.orb.ORB orb;
/** the configuration object for this POA instance */
private org.jacorb.config.Configuration configuration = null;
/** the POA logger instance */
private Logger logger = null;
private byte[] implName = null;
/** used to hold the POA name for logging */
private final String logPrefix;
// for listening POA Events
private POAListener poaListener;
// for monitoring
private POAMonitor monitor;
private final POAManager poaManager;
private final POA parent;
private final String name;
private String qualifiedName;
// name -> child POA's
private final Hashtable childs = new Hashtable();
Servant defaultServant;
ServantManager servantManager;
private AdapterActivator adapterActivator;
private AOM aom;
// thread for handle Requests
private RequestController requestController;
// poa identity and a counter for oid generation
private byte[] poaId;
private byte[] watermark;
private long objectIdCount;
/* policies */
// default: ORB_CTRL_MODEL
protected ThreadPolicy threadPolicy;
// default: TRANSIENT
protected LifespanPolicy lifespanPolicy;
// default: UNIQUE_ID
protected IdUniquenessPolicy idUniquenessPolicy;
// default: SYSTEM_ID
protected IdAssignmentPolicy idAssignmentPolicy;
// default: RETAIN
protected ServantRetentionPolicy servantRetentionPolicy;
// default: USE_ACTIVE_OBJECT_MAP_ONLY
protected RequestProcessingPolicy requestProcessingPolicy;
// default: NO_IMPLICIT_ACTIVATION
protected ImplicitActivationPolicy implicitActivationPolicy;
// default: NORMAL
protected BidirectionalPolicy bidirectionalPolicy;
// default: SSL_NOT_REQUIRED
protected SSLPolicy sslPolicy;
private final Hashtable all_policies;
/** key: , value: CORBA.Object */
private final Hashtable createdReferences;
// stores the etherealize_objects value from the first call of destroy
private boolean etherealize;
// synchronisation stuff
private int shutdownState = POAConstants.NOT_CALLED;
private final java.lang.Object poaCreationLog = new java.lang.Object();
private final java.lang.Object poaDestructionLog = new java.lang.Object();
private final java.lang.Object unknownAdapterLog = new java.lang.Object();
private boolean unknownAdapterCalled;
private boolean configured = false;
private POA(org.jacorb.orb.ORB _orb,
String _name,
POA _parent,
POAManager _poaManager,
org.omg.CORBA.Policy[] policies)
{
super();
orb = _orb;
name = _name;
parent = _parent;
poaManager = _poaManager;
logPrefix = "POA " + name;
all_policies = new Hashtable();
createdReferences = new Hashtable();
if (policies != null)
{
for (int i=0; i<policies.length; i++)
{
all_policies.put(ObjectUtil.newInteger( policies[i].policy_type() ),
policies[i]);
switch (policies[i].policy_type())
{
case THREAD_POLICY_ID.value :
threadPolicy =
(org.omg.PortableServer.ThreadPolicy) policies[i];
break;
case LIFESPAN_POLICY_ID.value :
lifespanPolicy =
(org.omg.PortableServer.LifespanPolicy) policies[i];
break;
case ID_UNIQUENESS_POLICY_ID.value :
idUniquenessPolicy =
(org.omg.PortableServer.IdUniquenessPolicy) policies[i];
break;
case ID_ASSIGNMENT_POLICY_ID.value :
idAssignmentPolicy =
(org.omg.PortableServer.IdAssignmentPolicy) policies[i];
break;
case SERVANT_RETENTION_POLICY_ID.value :
servantRetentionPolicy =
(org.omg.PortableServer.ServantRetentionPolicy) policies[i];
break;
case REQUEST_PROCESSING_POLICY_ID.value :
requestProcessingPolicy =
(org.omg.PortableServer.RequestProcessingPolicy) policies[i];
break;
case IMPLICIT_ACTIVATION_POLICY_ID.value :
implicitActivationPolicy =
(org.omg.PortableServer.ImplicitActivationPolicy) policies[i];
break;
case BIDIRECTIONAL_POLICY_TYPE.value :
bidirectionalPolicy =
(org.omg.BiDirPolicy.BidirectionalPolicy) policies[i];
break;
case SSL_POLICY_TYPE.value :
sslPolicy = (SSLPolicy) policies[i];
break;
}
}
}
//check if BiDir policy tell us to use BiDirGIOP (for the
//whole ORB)
if( bidirectionalPolicy != null )
{
org.jacorb.orb.giop.BiDirPolicy bdp =
(org.jacorb.orb.giop.BiDirPolicy) bidirectionalPolicy;
if( bdp.useBiDirGIOP() )
{
_orb.turnOnBiDirGIOP();
}
}
}
public void configure(Configuration myConfiguration)
throws ConfigurationException
{
this.configuration = (org.jacorb.config.Configuration)myConfiguration;
logger = configuration.getLogger("jacorb.poa");
String tmp =
configuration.getAttribute("jacorb.implname", "");
if (tmp.length() > 0)
{
implName = tmp.getBytes();
}
watermark = generateWatermark();
aom = isRetain() ? new AOM( isUniqueId(), logger) : null;
// GB: modified
requestController = new RequestController(this, orb, aom, orb.newRPPoolManager(isSingleThreadModel()));
requestController.configure(configuration);
poaManager.registerPOA(this);
monitor = new POAMonitorLightImpl();
monitor.init( this, aom,
requestController.getRequestQueue(),
requestController.getPoolManager(),
"POA " + name );
monitor.openMonitor();
if (poaListener != null)
{
poaListener.poaCreated(this);
}
monitor.configure(configuration);
if (logger.isDebugEnabled())
{
logger.debug("POA " + name + " ready");
}
configured = true;
}
/**
* Everybody who is interested in poa events can use this method
* to register an event listener. The poa will pass the register calls
* to the right components
*/
public void _addPOAEventListener(EventListener listener)
{
checkIsConfigured();
if (listener instanceof POAListener)
{
addPOAListener((POAListener)listener);
}
if (listener instanceof AOMListener && aom != null)
{
aom.addAOMListener((AOMListener)listener);
}
if (listener instanceof RequestQueueListener)
{
requestController.getRequestQueue().addRequestQueueListener((RequestQueueListener)listener);
}
if (listener instanceof RPPoolManagerListener)
{
requestController.getPoolManager().addRPPoolManagerListener((RPPoolManagerListener)listener);
}
}
/**
* Called from Delegate. To ensure thread safety we use the AOM::incarnate method
* when activating a servant with the ServantActivator.
*/
public Servant _incarnateServant(byte[] oid, ServantActivator sa)
throws org.omg.PortableServer.ForwardRequest
{
return aom.incarnate(oid, sa, this);
}
/**
* called from orb, returns a registered child poa,
* if no child poa exists a adapter activator will used
* to create a new poa unter this name
*/
public org.jacorb.poa.POA _getChildPOA( String adapter_name )
throws ParentIsHolding
{
checkIsConfigured();
checkDestructionApparent();
POA child = (POA) childs.get(adapter_name);
if (child == null || child.isDestructionApparent())
{
if (adapterActivator == null)
{
if (isHolding())
{
throw new ParentIsHolding();
}
throw new org.omg.CORBA.OBJECT_NOT_EXIST("no adapter activator exists for " +
adapter_name);
}
if (isDiscarding())
{
throw new org.omg.CORBA.TRANSIENT("a parent poa is in discarding state");
}
if (isInactive())
{
throw new org.omg.CORBA.OBJ_ADAPTER("a parent poa is in inactive state");
}
/* poa should be active */
boolean successful = false;
if (isSingleThreadModel())
{
/* all invocations an adapter activator are serialized
if the single thread model is in use */
synchronized (unknownAdapterLog)
{
while (unknownAdapterCalled)
{
try
{
unknownAdapterLog.wait();
}
catch (InterruptedException e)
{
}
}
unknownAdapterCalled = true;
try
{
successful =
the_activator().unknown_adapter(this, POAUtil.unmaskStr(adapter_name));
}
finally
{
unknownAdapterCalled = false;
unknownAdapterLog.notifyAll();
}
}
}
else
{
/* ORB_CTRL_MODEL */
successful = the_activator().unknown_adapter(this, POAUtil.unmaskStr(adapter_name));
}
/* unknown_adapter doesn't return until the
poa is created and initialized */
if (successful)
{
child = (POA) childs.get(adapter_name);
if (child == null)
{
throw new POAInternalError("error: unknown_adapter returns true, but the child poa doesn't extist");
}
}
else
{
throw new org.omg.CORBA.OBJECT_NOT_EXIST("poa activation is failed");
}
}
return child;
}
/**
* returns the complete poa name
*/
public String _getQualifiedName()
{
if (qualifiedName == null)
{
if (parent == null)
{
qualifiedName = "";
}
else if (parent.the_parent() == null)
{
qualifiedName = name;
}
else
{
qualifiedName = parent._getQualifiedName() +
POAConstants.OBJECT_KEY_SEPARATOR + name;
}
}
return qualifiedName;
}
/**
* called from orb for handing over a request
*/
public void _invoke(ServerRequest request)
throws WrongAdapter
{
checkIsConfigured();
synchronized(poaDestructionLog)
{
checkDestructionApparent ();
// if the request is for this poa check whether the object
// key is generated from him
if (request.remainingPOAName() == null)
{
if (!previouslyGeneratedObjectKey(request.objectKey()))
{
if (logger.isWarnEnabled())
{
logger.warn(logPrefix +
" rid: " + request.requestId() +
" opname: " + request.operation() +
" _invoke: object key not previously generated!");
if (logger.isDebugEnabled())
{
logger.debug(logPrefix +
" ObjectKey : " + org.jacorb.orb.util.CorbaLoc.parseKey(request.objectKey()) +
" to POA Id : " + org.jacorb.orb.util.CorbaLoc.parseKey(getPOAId()) + " mismatch.");
}
}
throw new WrongAdapter();
}
if (isSystemId() && !previouslyGeneratedObjectId(request.objectId()) )
{
if (logger.isWarnEnabled())
{
logger.warn(logPrefix +
" rid: " + request.requestId() +
" opname: " + request.operation() +
" _invoke: object id not previously generated!");
if (logger.isDebugEnabled())
{
logger.debug(logPrefix +
" ObjectId : " + org.jacorb.orb.util.CorbaLoc.parseKey(request.objectId()) +
" to POA watermark : " + org.jacorb.orb.util.CorbaLoc.parseKey(watermark) + " mismatch.");
}
}
throw new WrongAdapter();
}
}
try
{
// pass the request to the request controller the
// operation returns immediately after the request is
// queued
if (logger.isDebugEnabled())
{
logger.debug(logPrefix +
" rid: " + request.requestId() +
" opname: " + request.operation() +
" _invoke: queuing request");
}
requestController.queueRequest(request);
}
catch (ResourceLimitReachedException e)
{
if (logger.isDebugEnabled())
{
logger.debug("Caught " + e + " when queueing " + request.operation());
}
throw new org.omg.CORBA.TRANSIENT("resource limit reached");
}
}
}
/**
* called from orb to obtain the RootPOA
*/
static public POA _POA_init(org.jacorb.orb.ORB orb)
{
POAManager poaMgr = new POAManager(orb);
/* the only policy value that differs from default */
org.omg.CORBA.Policy [] policies= null;
policies = new org.omg.CORBA.Policy[1];
policies[0] =
new org.jacorb.poa.policy.ImplicitActivationPolicy(ImplicitActivationPolicyValue.IMPLICIT_ACTIVATION);
POA rootPOA =
new POA(orb, POAConstants.ROOT_POA_NAME, null, poaMgr, policies);
return rootPOA;
}
/**
* Unregister an event listener. The poa will pass the
* unregister calls to the right components
*/
public void _removePOAEventListener(EventListener listener)
{
if (listener instanceof POAListener)
{
removePOAListener((POAListener)listener);
}
if (listener instanceof AOMListener && aom != null)
{
aom.removeAOMListener((AOMListener)listener);
}
if (listener instanceof RequestQueueListener)
{
requestController.getRequestQueue().removeRequestQueueListener((RequestQueueListener)listener);
}
if (listener instanceof RPPoolManagerListener)
{
requestController.getPoolManager().removeRPPoolManagerListener((RPPoolManagerListener)listener);
}
}
public byte[] activate_object(Servant servant)
throws ServantAlreadyActive, WrongPolicy
{
checkIsConfigured();
checkDestructionApparent ();
if (!isRetain() || !isSystemId())
{
throw new WrongPolicy();
}
byte[] objectId = generateObjectId();
try
{
aom.add(objectId, servant);
orb.set_delegate( servant );
}
catch (ObjectAlreadyActive e)
{
throw new POAInternalError("error: object already active (activate_object)");
}
return objectId;
}
public void activate_object_with_id( byte[] oid, Servant servant )
throws ServantAlreadyActive, ObjectAlreadyActive, WrongPolicy
{
checkIsConfigured();
checkDestructionApparent ();
if( oid == null )
{
throw new org.omg.CORBA.BAD_PARAM( "Cannot activate_object_with_id with null ID." );
}
if ( !isRetain() )
{
throw new WrongPolicy();
}
if ( isSystemId() && !previouslyGeneratedObjectId(oid) )
{
if (logger.isWarnEnabled())
{
logger.warn(logPrefix + "oid: " + POAUtil.convert(oid) +
" - activate_object_with_id: oid not previously generated!");
}
throw new org.omg.CORBA.BAD_PARAM();
}
aom.add( oid, servant );
orb.set_delegate( servant );
}
protected synchronized void addPOAListener( POAListener listener )
{
poaListener = EventMulticaster.add(poaListener, listener);
}
protected void changeToActive()
{
if (poaListener != null)
{
poaListener.poaStateChanged(this, POAConstants.ACTIVE);
}
monitor.changeState("changed to active...");
// notify everybody who is waiting for request completion
requestController.resetPreviousCompletionCall();
// continue the request dispatching
requestController.continueToWork();
monitor.changeState("active");
}
protected void changeToDiscarding() {
if (poaListener != null)
{
poaListener.poaStateChanged(this, POAConstants.DISCARDING);
}
monitor.changeState("changed to discarding ...");
// notify everybody who is waiting for request completion
requestController.resetPreviousCompletionCall();
// continue the request dispatching
requestController.continueToWork();
// wait for completion of all active requests
requestController.waitForCompletion();
monitor.changeState("discarding");
}
protected void changeToHolding()
{
if (poaListener != null)
{
poaListener.poaStateChanged(this, POAConstants.HOLDING);
}
monitor.changeState("changed to holding ...");
// notify everybody who is waiting for request completion
requestController.resetPreviousCompletionCall();
// wait for completion of all active requests
requestController.waitForCompletion();
monitor.changeState("holding");
}
protected void changeToInactive(boolean etherealize_objects)
{
if (poaListener != null)
{
poaListener.poaStateChanged(this, POAConstants.INACTIVE);
}
monitor.changeState("changed to inactive ...");
// notify everybody who is waiting for request completion
requestController.resetPreviousCompletionCall();
// continue the request dispatching
requestController.continueToWork();
// wait for completion of all active requests
requestController.waitForCompletion();
/* etherialize all active objects */
if (etherealize && isRetain() && useServantManager())
{
if (logger.isInfoEnabled())
{
logger.info(logPrefix + "etherialize all servants ...");
}
aom.removeAll((ServantActivator) servantManager, this, true);
if (logger.isInfoEnabled())
{
logger.info(logPrefix + "etherialize all servants ...");
}
if (monitor != null)
{
monitor.changeState("inactive (etherialization completed)");
}
}
else
{
if (monitor != null)
{
monitor.changeState("inactive (no etherialization)");
}
}
}
public IdAssignmentPolicy create_id_assignment_policy (IdAssignmentPolicyValue value)
{
checkDestructionApparent ();
return new org.jacorb.poa.policy.IdAssignmentPolicy (value);
}
public IdUniquenessPolicy create_id_uniqueness_policy (IdUniquenessPolicyValue value)
{
checkDestructionApparent ();
return new org.jacorb.poa.policy.IdUniquenessPolicy (value);
}
public ImplicitActivationPolicy create_implicit_activation_policy
(ImplicitActivationPolicyValue value)
{
checkDestructionApparent ();
return new org.jacorb.poa.policy.ImplicitActivationPolicy (value);
}
public LifespanPolicy create_lifespan_policy (LifespanPolicyValue value)
{
checkDestructionApparent ();
return new org.jacorb.poa.policy.LifespanPolicy (value);
}
/**
* additionally raises an org.omg.CORBA.BAD_INV_ORDER exception if the poa
* goes shutdown and this method will called (not spec.)
*/
public org.omg.PortableServer.POA create_POA( String adapter_name,
org.omg.PortableServer.POAManager a_POAManager,
org.omg.CORBA.Policy[] policies)
throws AdapterAlreadyExists, InvalidPolicy
{
checkIsConfigured();
checkDestructionApparent();
String poa_name = POAUtil.maskStr(adapter_name);
/* this implementation works only with a instance of org.jacorb.poa.POAManager */
if (a_POAManager != null &&
!(a_POAManager instanceof org.jacorb.poa.POAManager))
{
throw new ApplicationError("error: the POAManager is incompatible with type \"jacorb.poa.POAManager\"!" );
}
org.omg.CORBA.Policy[] policyList = null;
if (policies != null)
{
// check the policy list for inconstancies
short index = verifyPolicyList(policies);
if (index != -1)
{
if (logger.isDebugEnabled())
{
logger.debug("Policy list invalid at index " + index);
}
throw new InvalidPolicy(index);
}
// copy the policy list
policyList = new org.omg.CORBA.Policy[policies.length];
for (int i=0; i<policies.length; i++)
{
policyList[i] = policies[i].copy();
}
}
POA child;
synchronized (poaCreationLog)
{
child = (POA)childs.get(poa_name);
if (child != null &&
!child.isDestructionApparent())
{
throw new AdapterAlreadyExists();
}
// wait for completion of a concurrent destruction process
if (child != null)
{
POA aChild;
while ((aChild = (POA)childs.get(poa_name)) != null)
{
try
{
poaCreationLog.wait(); // notification is in unregisterChild
}
catch (InterruptedException e)
{
}
// someone else has won the race
if (child != aChild)
{
throw new AdapterAlreadyExists();
}
}
}
if (isShutdownInProgress())
{
throw new org.omg.CORBA.BAD_INV_ORDER();
}
POAManager aPOAManager =
a_POAManager == null ? new POAManager(orb) : (POAManager) a_POAManager;
child =
new POA(orb, poa_name, this, aPOAManager, policyList);
try
{
child.configure(configuration);
}
catch (ConfigurationException e)
{
throw new org.omg.CORBA.INTERNAL(e.toString());
}
// notify a poa listener
try
{
if (poaListener != null)
{
poaListener.poaCreated(child);
}
}
catch (org.omg.CORBA.INTERNAL e)
{
aPOAManager.poaCreationFailed = true;
throw e;
}
// register the child poa
childs.put(poa_name, child);
}
return child;
}
/**
* The specified repository id, which may be a null string, will become the
* type_id of the generated object reference
*/
public org.omg.CORBA.Object create_reference (String intf_rep_id)
throws WrongPolicy
{
checkIsConfigured();
checkDestructionApparent();
if (!isSystemId())
{
throw new WrongPolicy();
}
return getReference (generateObjectId (), intf_rep_id, false);
}
/**
* The specified repository id, which may be a null string, will become the
* type_id of the generated object reference
*/
public org.omg.CORBA.Object create_reference_with_id(byte[] oid,
String intf_rep_id)
throws WrongPolicy
{
checkIsConfigured();
checkDestructionApparent();
if (isSystemId() && !previouslyGeneratedObjectId (oid))
{
if (logger.isWarnEnabled())
{
logger.warn(logPrefix + "oid: " + POAUtil.convert(oid) +
"create_reference_with_id : object key not previously generated!");
}
throw new org.omg.CORBA.BAD_PARAM ();
}
return getReference (oid, intf_rep_id, false);
}
public RequestProcessingPolicy create_request_processing_policy(RequestProcessingPolicyValue value)
{
checkDestructionApparent();
return new org.jacorb.poa.policy.RequestProcessingPolicy (value);
}
public ServantRetentionPolicy create_servant_retention_policy(ServantRetentionPolicyValue value)
{
checkDestructionApparent();
return new org.jacorb.poa.policy.ServantRetentionPolicy(value);
}
public ThreadPolicy create_thread_policy(ThreadPolicyValue value)
{
checkDestructionApparent();
return new org.jacorb.poa.policy.ThreadPolicy(value);
}
/**
* The operation does not wait for requests or etherealization to complete
* and always returns immediately (after deactivating the oid?)
*/
public synchronized void deactivate_object(byte[] oid)
throws ObjectNotActive, WrongPolicy
{
checkIsConfigured();
if (!isRetain())
{
throw new WrongPolicy();
}
aom.remove(
oid,
requestController,
useServantManager() ? (ServantActivator)servantManager : null,
this,
false
);
createdReferences.remove( new ByteArrayKey(oid));
}
public void destroy( boolean etherealize_objects,
boolean wait_for_completion )
{
checkIsConfigured();
if (wait_for_completion && isInInvocationContext())
{
throw new org.omg.CORBA.BAD_INV_ORDER();
}
/* synchronized with creationLog */
/* child poa creations are impossible now */
makeShutdownInProgress(etherealize_objects);
// Destroy all childs first
// Clone the collection to prevent concurrent modification problems.
Enumeration en = ((Hashtable)childs.clone()).elements();
while (en.hasMoreElements())
{
POA child = (POA) en.nextElement();
child.destroy(etherealize, wait_for_completion);
}
Thread thread = new Thread()
{
public void run()
{
/* The apparent destruction of the POA
occurs only after all executing
requests in the POA have completed,
but before any calls to etherealize
are made. */
requestController.waitForShutdown();
/* poa behaves as if he is in the
holding state now and blocks until
all active request have comleted */
makeDestructionApparent();
/* unregister poa from the POAManager,
any calls on the poa are impossible
now especially you cannot activate
or deactivate objects (raises a
OBJ_NOT_EXIST exception), but you
have a race condition with
currently running object
(de)activation processes */
makeDestructionComplete();
}
};
thread.setName("POADestructor");
thread.start();
if (wait_for_completion)
{
try
{
thread.join();
} catch (InterruptedException e) {}
}
}
private byte[] extractWatermark(byte[] id)
{
if( id.length < watermark.length )
{
return new byte[0];
}
return IdUtil.extract(id, id.length-watermark.length, watermark.length);
}
/**
* If the intended child poa is not found and activate_it is TRUE,
* it is possible for another thread to create the same poa with
* create_POA at the same time in a race condition. Applications
* should be prepared to deal with failures from the manual
* (create_POA) or automatic (findPOA or unknown_adapter from
* AdapterActivator) POA creation. Another possible situation is
* that the poa returned goes shutdown but the orb will notice
* this situation if he will proceed with request processing.
*/
public org.omg.PortableServer.POA find_POA( String adapter_name,
boolean activate_it)
throws AdapterNonExistent
{
checkDestructionApparent();
String poa_name = POAUtil.maskStr(adapter_name);
POA child = (POA)childs.get(poa_name);
if (child == null || child.isDestructionApparent())
{
boolean successful = false;
if (activate_it && the_activator() != null) {
/* all invocations an adapter activator are serialized
if the single thread model is in use */
if (isSingleThreadModel()) {
synchronized (unknownAdapterLog) {
while (unknownAdapterCalled) {
try {
unknownAdapterLog.wait();
} catch (InterruptedException e) {
}
}
unknownAdapterCalled = true;
try
{
successful =
the_activator().unknown_adapter(this, adapter_name);
}
finally {
unknownAdapterCalled = false;
unknownAdapterLog.notifyAll();
}
}
} else { /* ORB_CTRL_MODEL */
successful = the_activator().unknown_adapter(this, adapter_name);
}
}
/* unknown_adapter returns not until the poa is created and initialized */
if (successful)
{
child = (POA) childs.get(poa_name);
if (child == null)
{
throw new POAInternalError("error: unknown_adapter returns true, but the child poa does'n extist");
}
}
else
{
throw new AdapterNonExistent();
}
}
return child;
}
/**
* <code>generateObjectId</code> creates a new ObjectId for an object.
*
* @return a <code>byte[]</code> value.
*/
private synchronized byte[] generateObjectId()
{
if (isPersistent())
{
return IdUtil.concat(IdUtil.createId(4), watermark);
}
// Synchonize as the increment is not an atomic operation.
return IdUtil.concat(IdUtil.toId(objectIdCount++), watermark);
}
private byte[] generateWatermark()
{
if (watermark == null)
{
if (isPersistent())
{
watermark = IdUtil.toId(new String(getPOAId()).hashCode());
}
else
{
watermark = IdUtil.createId(4);
}
}
return watermark;
}
public Servant get_servant()
throws NoServant, WrongPolicy
{
checkIsConfigured();
checkDestructionApparent();
if (!isUseDefaultServant())
{
throw new WrongPolicy();
}
if (defaultServant == null)
{
throw new NoServant();
}
return defaultServant;
}
public org.omg.PortableServer.ServantManager get_servant_manager()
throws WrongPolicy
{
checkIsConfigured();
checkDestructionApparent();
if (!isUseServantManager())
{
throw new WrongPolicy();
}
return servantManager;
}
private void checkIsConfigured()
{
if (!configured)
{
throw new IllegalStateException("POA: not configured!");
}
}
protected POAMonitor getMonitor()
{
return monitor;
}
protected org.jacorb.orb.ORB getORB()
{
return orb;
}
public byte[] getPOAId()
{
if (poaId == null)
{
final byte[] impl_name = getImplName();
int in_length = impl_name.length;
byte[] poa_name = _getQualifiedName().getBytes();
int pn_length = poa_name.length;
int offset = 0;
if (pn_length == 0)
{
poaId = new byte[in_length];
System.arraycopy (impl_name, 0, poaId, 0, in_length);
}
else
{
poaId = new byte[in_length + pn_length + 1];
System.arraycopy (impl_name, 0, poaId, 0, in_length);
offset += in_length;
poaId[offset] = POAConstants.OBJECT_KEY_SEP_BYTE;
offset++;
System.arraycopy (poa_name, 0, poaId, offset, pn_length);
}
}
return poaId;
}
private byte[] getImplName()
{
final byte[] impl;
// If we are using a transient object then we must place some random information
// in the IOR so that it is unique.
if ( ( ! isPersistent() ) || implName == null)
{
impl = orb.getServerId();
if (logger.isInfoEnabled())
{
if (isPersistent() )
{
logger.info
("Impl name not set; using server ID: " + (new String (impl)));
}
else
{
logger.info
(
"Using server ID (" +
(new String (impl)) +
") for transient POA"
);
}
}
}
else
{
impl = implName;
}
return POAUtil.maskId(impl);
}
protected org.omg.CORBA.Object getReference
(byte[] oid, String intf_rep_id, boolean cache)
{
byte[] object_id = POAUtil.maskId (oid);
int pid_length = getPOAId().length;
int oid_length = object_id.length;
byte [] object_key = new byte[pid_length + oid_length + 1];
int offset = 0;
System.arraycopy (getPOAId(), 0, object_key, offset, pid_length);
offset += pid_length;
object_key[offset] = POAConstants.OBJECT_KEY_SEP_BYTE;
offset++;
System.arraycopy (object_id, 0, object_key, offset, oid_length);
ByteArrayKey key = new ByteArrayKey (oid);
org.omg.CORBA.Object result =
(org.omg.CORBA.Object) createdReferences.get (key);
if (result == null)
{
result = orb.getReference
(this, object_key, intf_rep_id, !isPersistent());
if (cache)
{
createdReferences.put (key, result);
}
if ( poaListener != null )
{
poaListener.referenceCreated( result );
}
}
return result;
}
protected RequestController getRequestController()
{
return requestController;
}
protected State getState()
{
return poaManager.get_state();
}
public org.omg.CORBA.Object id_to_reference (byte[] oid)
throws ObjectNotActive, WrongPolicy
{
checkDestructionApparent ();
if ( !isRetain() )
{
throw new WrongPolicy();
}
final Servant servant = aom.getServant(oid);
// objectId is not active
if (servant == null)
{
throw new ObjectNotActive();
}
/* If the object with the specified ObjectId currently active,
a reference encapsulating the information used to activate
the object is returned. */
return getReference (oid, servant._all_interfaces (this, oid)[0], true);
}
public Servant id_to_servant(byte[] oid)
throws ObjectNotActive, WrongPolicy
{
checkDestructionApparent ();
if (!isRetain() && !isUseDefaultServant())
{
throw new WrongPolicy();
}
// servant is active
if (isRetain())
{
final Servant servant = aom.getServant(oid);
if (servant != null)
{
return servant;
}
}
if (useDefaultServant()) {
return defaultServant;
}
throw new ObjectNotActive();
}
protected boolean isActive()
{
return poaManager.get_state().value() ==
org.omg.PortableServer.POAManagerPackage.State._ACTIVE ? true : false;
}
protected void checkDestructionApparent()
{
if (isDestructionApparent())
{
throw new org.omg.CORBA.OBJECT_NOT_EXIST ("POA destroyed");
}
}
protected static void checkNotLocal(org.omg.CORBA.Object obj)
throws WrongAdapter
{
if (obj instanceof org.omg.CORBA.LocalObject)
{
throw new WrongAdapter ("Local object");
}
}
protected boolean isDestructionApparent()
{
return shutdownState >= POAConstants.DESTRUCTION_APPARENT;
}
/**
* <code>isDestructionComplete</code> returns whether the POA has been
* completely destroyed (including finishing outstanding requests). This
* is public not protected as it is called from orb/Delegate.
*
* @return a <code>boolean</code> value.
*/
public boolean isDestructionComplete()
{
return shutdownState >= POAConstants.DESTRUCTION_COMPLETE;
}
protected boolean isDiscarding()
{
return poaManager.get_state().value() ==
org.omg.PortableServer.POAManagerPackage.State._DISCARDING ? true : false;
}
protected boolean isHolding()
{
return poaManager.get_state().value() ==
org.omg.PortableServer.POAManagerPackage.State._HOLDING ? true : false;
}
protected boolean isImplicitActivation()
{
return implicitActivationPolicy != null &&
implicitActivationPolicy.value() == ImplicitActivationPolicyValue.IMPLICIT_ACTIVATION;
}
protected boolean isInactive()
{
return poaManager.get_state().value() ==
org.omg.PortableServer.POAManagerPackage.State._INACTIVE ? true : false;
}
/**
* returns true if the current thread is in the context of
* executing a request from some POA belonging to the same ORB as
* this POA */
private boolean isInInvocationContext()
{
try
{
if (orb.getPOACurrent().getORB() == orb)
{
return true;
}
}
catch (org.omg.PortableServer.CurrentPackage.NoContext e)
{
}
return false;
}
/**
* returns true if the current thread is in the context of executing
* a request on the specified servant from this POA,
* if the specified servant is null, it returns true if the current
* thread is in an invocation context from this POA.
*/
private boolean isInInvocationContext(Servant servant)
{
try
{
if( orb.getPOACurrent().get_POA() == this &&
(servant == null || orb.getPOACurrent().getServant() == servant))
{
return true;
}
}
catch (org.omg.PortableServer.CurrentPackage.NoContext e)
{
}
return false;
}
protected boolean isMultipleId()
{
return idUniquenessPolicy != null &&
idUniquenessPolicy.value() == IdUniquenessPolicyValue.MULTIPLE_ID;
}
public boolean isPersistent()
{
return lifespanPolicy != null &&
lifespanPolicy.value() == LifespanPolicyValue.PERSISTENT;
}
/**
* also called from Delegate
*/
public boolean isRetain()
{
return servantRetentionPolicy == null ||
servantRetentionPolicy.value() == ServantRetentionPolicyValue.RETAIN;
}
protected boolean isShutdownInProgress()
{
return shutdownState >= POAConstants.SHUTDOWN_IN_PROGRESS;
}
protected boolean isSingleThreadModel()
{
return threadPolicy != null &&
threadPolicy.value() == ThreadPolicyValue.SINGLE_THREAD_MODEL;
}
public boolean isSystemId()
{
return idAssignmentPolicy == null ||
idAssignmentPolicy.value() == IdAssignmentPolicyValue.SYSTEM_ID;
}
protected boolean isUniqueId()
{
return idUniquenessPolicy == null ||
idUniquenessPolicy.value() == IdUniquenessPolicyValue.UNIQUE_ID;
}
/**
*/
protected boolean isUseDefaultServant()
{
return requestProcessingPolicy != null &&
requestProcessingPolicy.value() == RequestProcessingPolicyValue.USE_DEFAULT_SERVANT;
}
public boolean isUseServantManager()
{
return requestProcessingPolicy != null &&
requestProcessingPolicy.value() == RequestProcessingPolicyValue.USE_SERVANT_MANAGER;
}
public boolean isSSLRequired()
{
return sslPolicy != null &&
sslPolicy.value() == SSLPolicyValue.SSL_REQUIRED;
}
/**
* Any calls on the poa are impossible now, especially you cannot
* activate or deactivate objects (raises a OBJ_NOT_EXIST
* exception). The poa will unregistered with the POAManager.
* After destruction has become apparent, the POA may be
* re-created via either the AdapterActivator or a call to
* create_POA
*/
private void makeDestructionApparent()
{
synchronized (poaDestructionLog)
{
if (shutdownState < POAConstants.DESTRUCTION_APPARENT)
{
/* do */
poaManager.unregisterPOA(this);
/* set */
shutdownState = POAConstants.DESTRUCTION_APPARENT;
/* announce */
if (poaListener != null)
{
poaListener.poaStateChanged(this, POAConstants.DESTROYED);
}
if (logger.isDebugEnabled())
{
logger.debug(logPrefix + "destruction is apparent");
}
monitor.changeState("destruction is apparent ...");
}
}
}
/**
* After destruction has become complete, a poa creation process
* under the same poa name can continue now.
*/
private void makeDestructionComplete()
{
if (shutdownState < POAConstants.DESTRUCTION_COMPLETE)
{
/* do */
/* clear up the queue */
if (logger.isDebugEnabled())
{
logger.debug(logPrefix + "clear up the queue ...");
}
requestController.clearUpQueue(new org.omg.CORBA.OBJECT_NOT_EXIST("adapter destroyed"));
if (logger.isDebugEnabled())
{
logger.debug(logPrefix + "... done");
}
/* etherialize all active objects */
if (etherealize && isRetain() && useServantManager())
{
if (logger.isDebugEnabled())
{
logger.debug(logPrefix + "etherialize all servants ...");
}
aom.removeAll((ServantActivator) servantManager, this, true);
if (logger.isDebugEnabled())
{
logger.debug(logPrefix + "... done");
}
}
if (logger.isDebugEnabled())
{
logger.debug(logPrefix + "remove all processors from the pool ...");
}
requestController.clearUpPool();
if (logger.isDebugEnabled())
{
logger.debug(logPrefix + "... done");
}
/* stop the request controller */
if (logger.isDebugEnabled())
{
logger.debug(logPrefix + "stop the request controller ...");
}
requestController.end();
if (logger.isDebugEnabled())
{
logger.debug(logPrefix + "... done");
}
/* set */
shutdownState = POAConstants.DESTRUCTION_COMPLETE;
if (parent != null)
{
// I am not the RootPOA
// unregister the poa with the parent and
// notify a concurrent creation process
parent.unregisterChild(name);
}
/* annouce */
if (logger.isInfoEnabled())
{
logger.info(logPrefix + " destroyed");
}
monitor.changeState("destroyed");
/* clear tables */
createdReferences.clear();
all_policies.clear();
}
}
/**
* The etherealize_objects parameter from the destroy method will
* saved in the field etherealize because the etherealize_objects
* parameter applies only the first call of destroy. Subsequent
* calls use the field etherealize. Any calls to create_POA are
* impossible now (receives a BAD_INV_ORDER exception).
*/
private void makeShutdownInProgress(boolean etherealize_objects)
{
synchronized (poaCreationLog)
{
if (shutdownState < POAConstants.SHUTDOWN_IN_PROGRESS)
{
/* do */
etherealize = etherealize_objects;
/* set */
shutdownState = POAConstants.SHUTDOWN_IN_PROGRESS;
/* annouce */
if (logger.isDebugEnabled())
{
logger.debug(logPrefix + "shutdown is in progress");
}
monitor.changeState("shutdown is in progress ...");
}
}
}
public boolean previouslyGeneratedObjectId(byte[] oid)
{
return IdUtil.equals(watermark, extractWatermark(oid));
}
public boolean previouslyGeneratedObjectKey(byte[] object_key)
{
return IdUtil.equals(object_key, getPOAId(), getPOAId().length);
}
public byte[] reference_to_id (org.omg.CORBA.Object reference)
throws WrongAdapter, WrongPolicy
{
checkDestructionApparent ();
checkNotLocal (reference);
byte[] objectId = POAUtil.extractOID(reference);
/* not spec (isSystemId) */
if (isSystemId() && !previouslyGeneratedObjectId(objectId))
{
if (logger.isWarnEnabled())
{
logger.warn(logPrefix + "oid: " + POAUtil.convert(objectId) +
"reference_to_id: oid not previously generated!");
}
throw new WrongAdapter();
}
return objectId;
}
public Servant reference_to_servant(org.omg.CORBA.Object reference)
throws ObjectNotActive, WrongAdapter, WrongPolicy
{
if (reference == null)
{
throw new BAD_PARAM("reference may not be null");
}
checkDestructionApparent();
checkNotLocal(reference);
if (!isRetain() && !isUseDefaultServant())
{
throw new WrongPolicy();
}
byte[] objectId = POAUtil.extractOID(reference);
/* not spec (isSystemId) */
if (isSystemId() && !previouslyGeneratedObjectId(objectId))
{
if (logger.isWarnEnabled())
{
logger.warn(logPrefix + "oid: " + POAUtil.convert(objectId) +
"reference_to_servant: oid not previously generated!");
}
throw new WrongAdapter();
}
ByteArrayKey oid = new ByteArrayKey (objectId);
if ( ( aom != null && aom.isDeactivating (oid) )
|| requestController.isDeactivating (oid))
{
if (logger.isWarnEnabled())
{
logger.warn(logPrefix + "oid: " + POAUtil.convert(objectId) +
"cannot process request, because object is already in the deactivation process");
}
throw new ObjectNotActive();
}
Servant servant = null;
/* is active servant */
if (isRetain() && (servant = aom.getServant(objectId)) != null)
{
return servant;
}
else if (useDefaultServant())
{
return defaultServant;
}
throw new ObjectNotActive();
}
protected synchronized void removePOAListener(POAListener listener)
{
poaListener = EventMulticaster.remove(poaListener, listener);
}
public byte[] servant_to_id(Servant servant)
throws ServantNotActive, WrongPolicy
{
checkDestructionApparent ();
if ((!isUseDefaultServant()) &&
(!isRetain() || !isUniqueId()) &&
(!isRetain() || !isImplicitActivation()))
{
throw new WrongPolicy();
}
byte[] objectId = null;
if (isRetain())
{
if (isUniqueId())
{
objectId = aom.getObjectId(servant);
if (objectId != null)
{
return objectId;
}
}
if ( isImplicitActivation() &&
( isMultipleId() || !aom.contains(servant)) )
{
objectId = generateObjectId();
/* activate the servant using the generated objectId and the
intfRepId associated with the servant */
try
{
aom.add(objectId, servant);
}
catch (ObjectAlreadyActive e)
{
throw new POAInternalError("error: object already active (servant_to_id)");
}
catch (ServantAlreadyActive e)
{
/* it's ok, a nother one was faster with
activation (only occurs if unique_id is set) */
objectId = aom.getObjectId(servant);
}
orb.set_delegate(servant);
return objectId;
}
}
if (isUseDefaultServant() && servant == defaultServant &&
isInInvocationContext(servant))
{
/* objectId associated with the current invocation */
try
{
objectId = orb.getPOACurrent().get_object_id();
}
catch (org.omg.PortableServer.CurrentPackage.NoContext e)
{
throw new POAInternalError("error: not in invocation context (servant_to_id)");
}
return objectId;
}
throw new ServantNotActive();
}
/**
*/
public org.omg.CORBA.Object servant_to_reference(Servant servant)
throws ServantNotActive, WrongPolicy
{
checkDestructionApparent ();
boolean isInInvocationContext = isInInvocationContext(servant);
if ( (!isRetain() || !isUniqueId()) &&
(!isRetain() || !isImplicitActivation()) &&
!isInInvocationContext )
{
throw new WrongPolicy();
}
byte[] objectId = null;
if (isInInvocationContext)
{
/* reference = Reference associated with the current invocation */
try
{
objectId = orb.getPOACurrent().get_object_id();
}
catch (org.omg.PortableServer.CurrentPackage.NoContext e)
{
throw new POAInternalError("error: not in invocation context (servant_to_reference)");
}
return getReference(objectId,
servant._all_interfaces(this, objectId)[0],
true);
}
if (isRetain())
{
if (isUniqueId())
{
/* the object reference encapsulating the information
used to activate the servant is returned */
objectId = aom.getObjectId(servant);
if (objectId != null)
{
return getReference(objectId, servant._all_interfaces(this, objectId)[0], true);
}
}
if (isImplicitActivation() && (isMultipleId() || !aom.contains(servant)) )
{
objectId = generateObjectId();
/* activate the servant using a generated objectId and
the intfRepId associated with the servant
and a corresponding object reference is returned */
try
{
aom.add(objectId, servant);
}
catch (ObjectAlreadyActive e)
{
throw new POAInternalError("error: object already active (servant_to_reference)");
}
catch (ServantAlreadyActive e)
{
/* it's ok, another one was faster with activation
(only occurs if unique_id is set) */
objectId = aom.getObjectId(servant);
}
orb.set_delegate(servant);
return getReference(objectId,
servant._all_interfaces(this, objectId)[0],
true);
}
}
throw new ServantNotActive();
}
public void set_servant(Servant _defaultServant)
throws WrongPolicy
{
checkDestructionApparent();
if (!isUseDefaultServant())
{
throw new WrongPolicy();
}
defaultServant = _defaultServant;
if (defaultServant != null)
{
orb.set_delegate(defaultServant); // set the orb
}
}
/**
* this method makes a additional check: if the POA has the RETAIN
* policy and _servantManager is not a instance of
* ServantActivator or if the POA has the NON_RETAIN policy and
* _servantManager is not a instance of ServantLocator this method
* raises also the WrongPolicy Exception (not spec.)
*/
public void set_servant_manager(org.omg.PortableServer.ServantManager servant_manager)
throws WrongPolicy
{
checkDestructionApparent ();
if (!isUseServantManager())
{
throw new WrongPolicy();
}
if (servantManager != null)
{
throw new org.omg.CORBA.BAD_INV_ORDER();
}
/* not spec. */
if( isRetain() &&
!(servant_manager instanceof org.omg.PortableServer.ServantActivator))
{
throw new WrongPolicy();
}
if (!isRetain() &&
!(servant_manager instanceof org.omg.PortableServer.ServantLocator))
{
throw new WrongPolicy();
}
servantManager = servant_manager;
}
protected void setMonitor(POAMonitor _monitor)
{
monitor = _monitor;
}
/**
* it is system-dependent whether the root POA initially has an adapter
* activator. a newly created POA has not an adapter activator (null)
*/
public org.omg.PortableServer.AdapterActivator the_activator()
{
checkDestructionApparent ();
return adapterActivator;
}
public void the_activator(org.omg.PortableServer.AdapterActivator adapter_activator)
{
checkDestructionApparent();
adapterActivator = adapter_activator;
}
public String the_name()
{
checkDestructionApparent();
return POAUtil.unmaskStr(name);
}
public org.omg.PortableServer.POA the_parent()
{
checkDestructionApparent();
return parent;
}
public org.omg.PortableServer.POA[] the_children()
{
checkDestructionApparent();
int i = 0;
Enumeration enumeration;
org.omg.PortableServer.POA[] children;
synchronized (poaCreationLog)
{
children = new org.omg.PortableServer.POA[childs.size()];
enumeration = childs.elements();
while (enumeration.hasMoreElements())
{
children[i] = (org.omg.PortableServer.POA) enumeration.nextElement();
i++;
}
}
return children;
}
public org.omg.PortableServer.POAManager the_POAManager()
{
checkDestructionApparent();
return poaManager;
}
/**
* notified the completion of a child destruction
*/
protected void unregisterChild(String name)
{
synchronized (poaCreationLog)
{
childs.remove(name);
poaCreationLog.notifyAll();
}
}
/**
* called from Delegate
*/
public boolean useDefaultServant()
{
return isUseDefaultServant() && defaultServant != null;
}
protected boolean useServantManager()
{
return isUseServantManager() && servantManager != null;
}
/**
* If any of the policies specified are not valid, or if conflicting
* policies are specified, or if any of the specified policies require
* prior administrative action that has not been performed, or if the
* policy type is unknown, this method returns the index in the policy list
* of the first offending policy object. By the creation of a new POA object
* this lead to an InvalidPolicy exception being raised containing this index.
*
* If everything's fine, this method returns -1;
*/
private short verifyPolicyList(org.omg.CORBA.Policy[] policies)
{
org.omg.CORBA.Policy policy;
org.omg.CORBA.Policy policy2;
for (short i = 0; i < policies.length; i++)
{
switch (policies[i].policy_type())
{
case THREAD_POLICY_ID.value :
/* no dependencies */
break;
case LIFESPAN_POLICY_ID.value :
// PERSISTENT -> ImplName is set
if (((LifespanPolicy) policies[i]).value() ==
LifespanPolicyValue.PERSISTENT)
{
if ( implName == null )
{
logger.error("Cannot create a persistent poa. The implname property has not been set.");
return i;
}
}
/* no dependencies */
break;
case ID_UNIQUENESS_POLICY_ID.value :
/* no dependencies */
/* if you set NON_RETAIN the poa doesn't take any
notice of the IdUniquenesPolicyValue */
break;
case ID_ASSIGNMENT_POLICY_ID.value :
// SYSTEM_ID -> no dependencies USER_ID ->
// NO_IMPLICIT_ACTIVATION, but an error will detected
// if we have considered the IMPLICIT_ACTIVATION
// policy
break;
case SERVANT_RETENTION_POLICY_ID.value :
// RETAIN -> no dependencies
// NON_RETAIN -> (USE_DEFAULT_SERVANT || USE_SERVANT_MANAGER)
if (((ServantRetentionPolicy) policies[i]).value() ==
ServantRetentionPolicyValue.NON_RETAIN) {
policy =
POAUtil.getPolicy(policies, REQUEST_PROCESSING_POLICY_ID.value);
if (policy == null)
{
return i; // default (USE_ACTIVE_OBJECT_MAP_ONLY) is forbidden
}
if ( ((RequestProcessingPolicy) policy).value() !=
RequestProcessingPolicyValue.USE_DEFAULT_SERVANT &&
((RequestProcessingPolicy) policy).value() !=
RequestProcessingPolicyValue.USE_SERVANT_MANAGER)
{
return i;
}
// NON_RETAIN -> NO_IMPLICIT_ACTIVATION, but an error will
// be detected if we have considered the IMPLICIT_ACTIVATION policy
}
break;
case REQUEST_PROCESSING_POLICY_ID.value :
// USE_SERVANT_MANAGER -> no dependencies
// USE_ACTIVE_OBJECT_MAP_ONLY -> RETAIN
if (((RequestProcessingPolicy) policies[i]).value() ==
RequestProcessingPolicyValue.USE_ACTIVE_OBJECT_MAP_ONLY)
{
policy = POAUtil.getPolicy( policies,
SERVANT_RETENTION_POLICY_ID.value);
if (policy != null)
{
if (((ServantRetentionPolicy) policy).value() !=
ServantRetentionPolicyValue.RETAIN)
{
return i;
}
}
// else: do nothing, because default (RETAIN) is ok
// USE_DEFAULT_SERVANT -> (MULTIPLE_ID || NON_RETAIN) /* not spec. (NON_RETAIN) */
}
else if (((RequestProcessingPolicy) policies[i]).value() == RequestProcessingPolicyValue.USE_DEFAULT_SERVANT)
{
policy =
POAUtil.getPolicy(policies, ID_UNIQUENESS_POLICY_ID.value);
policy2 =
POAUtil.getPolicy(policies, SERVANT_RETENTION_POLICY_ID.value);
if (policy == null && policy2 == null)
{
return i; // default (UNIQUE_ID && RETAIN) is forbidden
}
else if (policy != null && policy2 == null)
{
if (((IdUniquenessPolicy) policy).value() !=
IdUniquenessPolicyValue.MULTIPLE_ID )
{
return i;
}
}
else if (policy == null && policy2 != null)
{
if (((ServantRetentionPolicy) policy2).value() !=
ServantRetentionPolicyValue.NON_RETAIN )
{
return i;
}
}
else if (policy != null && policy2 != null)
{
if (((IdUniquenessPolicy) policy).value() !=
IdUniquenessPolicyValue.MULTIPLE_ID &&
((ServantRetentionPolicy) policy2).value() !=
ServantRetentionPolicyValue.NON_RETAIN )
{
return i;
}
}
}
break;
case IMPLICIT_ACTIVATION_POLICY_ID.value :
{
// NO_IMPLICIT_ACTIVATION -> no dependencies
// IMPLICIT_ACTIVATION -> (SYSTEM_ID && RETAIN)
if (((ImplicitActivationPolicy) policies[i]).value() ==
ImplicitActivationPolicyValue.IMPLICIT_ACTIVATION)
{
policy = POAUtil.getPolicy(policies,
SERVANT_RETENTION_POLICY_ID.value);
if (policy != null)
{
if (((ServantRetentionPolicy) policy).value() !=
ServantRetentionPolicyValue.RETAIN)
{
return i;
}
}
// else: do nothing, because default (RETAIN) is ok
policy = POAUtil.getPolicy(policies, ID_ASSIGNMENT_POLICY_ID.value);
if (policy != null)
{
if (((IdAssignmentPolicy) policy).value() !=
IdAssignmentPolicyValue.SYSTEM_ID)
{
return i;
}
}
// else: do nothing, because default (SYSTEM_ID) is ok
}
break;
}
case BIDIRECTIONAL_POLICY_TYPE.value :
// nothing to do
break;
//ignore unknown policies
// // unknown policy type -> return i
// default :
// return i;
}
}
return -1;
}
public org.omg.CORBA.Policy getPolicy(int type)
{
return (org.omg.CORBA.Policy) all_policies.get(ObjectUtil.newInteger(type));
}
public void addLocalRequest()
{
requestController.addLocalRequest();
}
public void removeLocalRequest()
{
requestController.removeLocalRequest();
}
public int getNumberOfObjects()
{
return aom.size ();
}
}