use of alma.acs.classloading.AcsComponentClassLoader in project ACS by ACS-Community.
the class AcsContainer method activate_component.
/////////////////////////////////////////////////////////////
// Implementation of ContainerOperations#activate_component
/////////////////////////////////////////////////////////////
/**
* Activates a component so that it's ready to receive functional calls
* after returning from this method. Called by the ACS Manager.
* <p>
* From MACI IDL:
* <i>
* Activate a component whose type (class) and name (instance) are given.
* In the process of activation, component's code-base is loaded into memory if it is not there already.
* The code-base resides in an executable file (usually a dynamic-link library or a shared library -- DLL).
* On platforms that do not automatically load dependent executables (e.g., VxWorks),
* the container identifies the dependencies by querying the executable and loads them automatically.
* Once the code is loaded, it is asked to construct a servant of a given type.
* The servant is then initialized with the Configuration Database (CDB) and Persistance Database (PDB) data.
* The servant is attached to the component, and a reference to it is returned.
* </i>
* <p>
* @param componentHandle handle of the component that is being activated. This handle is used
* by the component when it will present itself to the Manager.
* The component is expected to remember this handle for its entire life-time.
* @param execution_id
* @param compName name of the component to instantiate (instance name, comes from CDB)
* @param exe component helper implementation class; must be a subclass of
* {@link alma.acs.container.ComponentHelper}.
* @param type the type of the component to instantiate (Corba IR id).
* @return Returns the reference to the object that has just been activated.
* If the component could not the activated, a nil reference is returned.
*
* @see si.ijs.maci.ContainerOperations#activate_component(int, String, String, String)
*/
public ComponentInfo activate_component(int componentHandle, long execution_id, String compName, String exe, String type) throws CannotActivateComponentEx {
// reject the call if container is shutting down
if (shuttingDown.get()) {
String msg = "activate_component() rejected because of container shutdown.";
m_logger.fine(msg);
AcsJCannotActivateComponentEx ex = new AcsJCannotActivateComponentEx();
ex.setCURL(compName);
ex.setDetailedReason(msg);
throw ex.toCannotActivateComponentEx();
}
ComponentInfo componentInfo = null;
StopWatch activationWatch = new StopWatch(m_logger);
// to make component activations stick out in the log list
m_logger.finer("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
m_logger.fine("activate_component: handle=" + componentHandle + " name=" + compName + " helperClass=" + exe + " type=" + type);
// if the container is still starting up, then hold the request until the container is ready
boolean contInitWaitSuccess = false;
try {
contInitWaitSuccess = containerStartOrbThreadGate.await(30, TimeUnit.SECONDS);
} catch (InterruptedException ex1) {
// just leave contInitWaitSuccess == false
}
if (!contInitWaitSuccess) {
String msg = "Activation of component " + compName + " timed out after 30 s waiting for the container to finish its initialization.";
m_logger.warning(msg);
AcsJCannotActivateComponentEx ex = new AcsJCannotActivateComponentEx();
ex.setCURL(compName);
ex.setDetailedReason(msg);
throw ex.toCannotActivateComponentEx();
}
ComponentAdapter compAdapter = null;
try {
synchronized (m_activeComponentMap) {
ComponentAdapter existingCompAdapter = getExistingComponent(componentHandle, compName, type);
if (existingCompAdapter != null) {
return existingCompAdapter.getComponentInfo();
} else if (!m_activeComponentMap.reserveComponent(componentHandle)) {
AcsJContainerEx ex = new AcsJContainerEx();
ex.setContextInfo("Component with handle '" + componentHandle + "' is already being activated by this container. Manager should have prevented double activation.");
throw ex;
}
}
ClassLoader compCL = null;
// the property 'acs.components.classpath.jardirs' is set by the script acsStartContainer
// to a list of all relevant 'lib/ACScomponents/' directories
String compJarDirs = System.getProperty(AcsComponentClassLoader.PROPERTY_JARDIRS);
if (compJarDirs != null) {
compCL = new AcsComponentClassLoader(Thread.currentThread().getContextClassLoader(), m_logger, compName);
} else {
// fallback: load component impl classes in the global class loader
compCL = Thread.currentThread().getContextClassLoader();
}
// Create component helper using component classloader.
// Note that the base class alma.acs.container.ComponentHelper will still be loaded by the container CL,
// although the current subclassing design is a bit dirtier than it could be in the sense that a mean
// component could deploy modified container classes (e.g. in method getInterfaceTranslator).
// Nothing big to worry about though...
ComponentHelper compHelper = createComponentHelper(compName, exe, compCL);
// Creates component implementation and connects it with the Corba-generated POATie object.
// Objects for container interception ("tight container") and for automatic xml binding class
// de-/serialization are chained up and inserted here. End-to-end they have to translate between the
// operations interface derived from corba IDL and the component's declared internalInterface.
StopWatch compStopWatch = new StopWatch();
ComponentLifecycle compImpl = compHelper.getComponentImpl();
LOG_CompAct_Instance_OK.log(m_logger, compName, compStopWatch.getLapTimeMillis());
//m_logger.finest(compName + " component impl created, with classloader " + compImpl.getClass().getClassLoader().getClass().getName());
Class<? extends ACSComponentOperations> operationsIFClass = compHelper.getOperationsInterface();
Constructor<? extends Servant> poaTieCtor = compHelper.getPOATieClass().getConstructor(new Class[] { operationsIFClass });
Object operationsIFImpl = null;
// translations for some methods only...
if (operationsIFClass.isInstance(compImpl)) {
m_logger.finer("component " + compName + " implements operations interface directly; no dynamic translator proxy used.");
operationsIFImpl = compImpl;
} else {
m_logger.finer("creating dynamic proxy to map corba interface calls to component " + compName + ".");
operationsIFImpl = compHelper.getInterfaceTranslator();
if (!Proxy.isProxyClass(operationsIFImpl.getClass()) && !(operationsIFImpl instanceof ExternalInterfaceTranslator))
m_logger.log(AcsLogLevel.NOTICE, "interface translator proxy for component " + compName + " isn't " + "the default one, and doesn't expose the default as one either. This may cause problem when invoking " + "xml-aware offshoot getters");
}
// make it a tight container (one that intercepts functional method calls)
String[] methodsExcludedFromInvocationLogging = compHelper.getComponentMethodsExcludedFromInvocationLogging();
Object poaDelegate = ContainerSealant.createContainerSealant(operationsIFClass, operationsIFImpl, compName, false, m_logger, compCL, methodsExcludedFromInvocationLogging);
// construct the POATie skeleton with operationsIFImpl as the delegate object
Servant servant = null;
try {
servant = poaTieCtor.newInstance(new Object[] { poaDelegate });
} catch (Throwable thr) {
AcsJContainerEx ex = new AcsJContainerEx(thr);
ex.setContextInfo("failed to instantiate the servant object for component " + compName + " of type " + compImpl.getClass().getName());
throw ex;
}
//
// administrate the new component
//
compAdapter = new ComponentAdapter(compName, type, exe, componentHandle, m_containerName, compImpl, m_managerProxy, sharedCdbRef, compCL, m_logger, m_acsCorba);
// to support automatic offshoot translation for xml-binded offshoots, we need to pass the dynamic adaptor
if (!operationsIFClass.isInstance(compImpl)) {
// if an external interface translator was given by the user, get the default interface translator
if (operationsIFImpl instanceof ExternalInterfaceTranslator)
operationsIFImpl = ((ExternalInterfaceTranslator) operationsIFImpl).getDefaultInterfaceTranslator();
compAdapter.setComponentXmlTranslatorProxy(operationsIFImpl);
}
// for future offshoots created by this component we must pass on the no-auto-logging info
compAdapter.setMethodsExcludedFromInvocationLogging(methodsExcludedFromInvocationLogging);
compStopWatch.reset();
compAdapter.activateComponent(servant);
LOG_CompAct_Corba_OK.log(m_logger, compName, compStopWatch.getLapTimeMillis());
// now it's time to turn off ORB logging if the new component is requesting this
if (compHelper.requiresOrbCentralLogSuppression()) {
ClientLogManager.getAcsLogManager().suppressCorbaRemoteLogging();
}
// even though the component is now an activated Corba object already,
// it won't be called yet since the maciManager will only pass around
// access information after we've returned from this activate_component method.
// Therefore it's not too late to call initialize and execute, which are
// guaranteed to be called before incoming functional calls must be expected.
// At the moment we have to call these two methods one after the other;
// if the Manager supports new calling semantics, we could separate the two
// as described in ComponentLifecycle
m_logger.fine("about to initialize component " + compName);
compStopWatch.reset();
compAdapter.initializeComponent();
compAdapter.executeComponent();
LOG_CompAct_Init_OK.log(m_logger, compName, compStopWatch.getLapTimeMillis());
// we've deferred storing the component in the map until after it's been initialized successfully
m_activeComponentMap.put(componentHandle, compAdapter);
long activTime = activationWatch.getLapTimeMillis();
m_logger.info("component " + compName + " activated and initialized in " + activTime + " ms.");
componentInfo = compAdapter.getComponentInfo();
} catch (Throwable thr) {
m_logger.log(Level.SEVERE, "Failed to activate component " + compName + ", problem was: ", thr);
if (compAdapter != null) {
try {
compAdapter.deactivateComponent();
} catch (Exception ex) {
m_logger.log(Level.FINE, ex.getMessage(), ex);
}
}
m_activeComponentMap.remove(componentHandle);
AcsJCannotActivateComponentEx ex = new AcsJCannotActivateComponentEx(thr);
throw ex.toCannotActivateComponentEx();
} finally {
// to make (possibly nested) component activations stick out in the log list
m_logger.finer(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
}
return componentInfo;
}
use of alma.acs.classloading.AcsComponentClassLoader in project ACS by ACS-Community.
the class ComponentAdapter method deactivateComponent.
/**
* Deactivates a component.
* <ol>
* <li>First the component's POA manager is put into inactive state, so that all incoming calls to this component are rejected.
* However, we wait for currently executing calls to finish, with a timeout as described below.
* <ul>
* <li>Rejection applies to requests already received and queued by the ORB (but that have not started executing),
* as well as to requests that clients will send in the future.
* <li>Note that entering into the inactive state may take forever if the component hangs in a functional call.
* <li>Therefore we use a timeout to proceed in such cases where POA manager deactivation does not happen in time.
* This bears the risk of undesirable behavior caused by calling the {@link ComponentLifecycle#cleanUp() cleanUp}
* method while other threads still perform functional calls on the component.
* </ul>
* <li>Second the component itself is deactivated:
* <ul>
* <li>The lifecycle method {@link ComponentLifecycle#cleanUp() cleanUp} is called, currently without enforcing a timeout.
* <li>TODO: use a timeout, unless we decide that a client-side timeout for releaseComponent is good enough.
* </ul>
* <li>Third the component is disconnected from CORBA ("etherealized" from the POA).
* <ul>
* <li>Note that also etherealization may take forever if the component hangs in a call.
* <li>Therefore we use a timeout to proceed with deactivation in such cases where etherealization does not happen in time.
* <li>Currently a component that failed to etherealize in time can stay active as long as the container is alive.
* TODO: check if using the "container sealant" we can identify and stop the active ORB threads.
* </ul>
* </ol>
* This method logs errors as FINER if they also cause an exception, and as WARNING if they cannot lead to an exception
* because other more important error conditions are present.
*
* @throws ComponentDeactivationUncleanEx, ComponentDeactivationFailedEx
*/
void deactivateComponent() throws AcsJComponentDeactivationUncleanEx, AcsJComponentDeactivationFailedEx {
if (m_containerLogger.isLoggable(Level.FINER)) {
m_containerLogger.finer("About to deactivate component " + m_compInstanceName + " with handle " + getHandle());
}
AcsJComponentDeactivationUncleanEx deactivationUncleanEx = null;
AcsJComponentDeactivationFailedEx deactivationFailedEx = null;
try {
// (1) try to reject calls by sending poa manager to inactive state
// TODO: make the timeout configurable
int deactivateTimeoutMillis = 10000;
boolean isInactive = acsCorba.deactivateComponentPOAManager(m_componentPOA, m_compInstanceName, deactivateTimeoutMillis);
if (isInactive && m_containerLogger.isLoggable(Level.FINER)) {
m_containerLogger.finer("Now rejecting any calls to component '" + m_compInstanceName + "'. Will call cleanUp() next.");
} else if (!isInactive) {
String msg = "Component '" + m_compInstanceName + "' failed to reject calls within " + deactivateTimeoutMillis + " ms, probably because of pending calls. Will call cleanUp() anyway.";
m_containerLogger.warning(msg);
deactivationUncleanEx = new AcsJComponentDeactivationUncleanEx();
deactivationUncleanEx.setCURL(m_compInstanceName);
deactivationUncleanEx.setReason(msg);
// do not yet throw deactivationUncleanEx as we need to go through the other steps first
}
// (2) call the lifecycle method cleanUp and also clean container services and other support classes
ClassLoader contCL = Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(m_componentClassLoader);
try {
// TODO: also use a timeout for cleanUp
m_component.cleanUp();
} catch (Throwable thr) {
// AcsJComponentCleanUpEx is declared, but any other ex will be wrapped by AcsJComponentDeactivationUncleanEx as well
m_containerLogger.log(Level.FINE, "Failure in cleanUp() method of component " + m_compInstanceName, thr);
// this would override a previous ex from POA deactivation
deactivationUncleanEx = new AcsJComponentDeactivationUncleanEx(thr);
deactivationUncleanEx.setCURL(m_compInstanceName);
// do not yet throw deactivationUncleanEx as we need to nonetheless destroy the POA
} finally {
Thread.currentThread().setContextClassLoader(contCL);
try {
m_componentStateManager.setStateByContainer(ComponentStates.COMPSTATE_DEFUNCT);
} catch (ComponentLifecycleException ex) {
if (deactivationUncleanEx == null) {
// an ex from cleanUp would be more important
deactivationUncleanEx = new AcsJComponentDeactivationUncleanEx(ex);
deactivationUncleanEx.setCURL(m_compInstanceName);
} else {
m_containerLogger.log(Level.WARNING, "Failed to set component state DEFUNCT on " + m_compInstanceName, ex);
}
}
m_containerServices.cleanUp();
m_threadFactory.cleanUp();
}
// (3) destroy the component POA
// since we already tried to discard requests using the poa manager before,
// the additional timeout can be kept small. If calls are pending, we fail.
int etherealizeTimeoutMillis = 1000;
boolean isEtherealized = acsCorba.destroyComponentPOA(m_componentPOA, compServantManager, etherealizeTimeoutMillis);
if (isEtherealized && m_containerLogger.isLoggable(Level.FINER)) {
m_containerLogger.finer("Component '" + m_compInstanceName + "' is etherealized.");
} else if (!isEtherealized) {
m_containerLogger.warning("Component '" + m_compInstanceName + "' failed to be etherealized in " + etherealizeTimeoutMillis + " ms, probably because of pending calls.");
deactivationFailedEx = new AcsJComponentDeactivationFailedEx();
deactivationFailedEx.setCURL(m_compInstanceName);
deactivationFailedEx.setReason("Component POA etherialization timed out after " + etherealizeTimeoutMillis + " ms.");
// @TODO: distinguish the cases better
deactivationFailedEx.setIsPermanentFailure(true);
// do not yet throw deactivationFailedEx as we need to nonetheless close the classloader
}
// (4) "close" m_componentClassLoader (otherwise JVM native mem leak, see COMP-4929)
if (m_componentClassLoader instanceof AcsComponentClassLoader) {
try {
((AcsComponentClassLoader) m_componentClassLoader).close();
} catch (IOException ex) {
m_containerLogger.log(Level.WARNING, "Failed to close component class loader", ex);
}
}
} catch (RuntimeException ex) {
if (deactivationFailedEx == null) {
// exception from POA destruction has precedence
deactivationFailedEx = new AcsJComponentDeactivationFailedEx(ex);
deactivationFailedEx.setCURL(m_compInstanceName);
deactivationFailedEx.setReason("Unexpected exception caught during component deactivation.");
} else {
m_containerLogger.log(Level.WARNING, "Unexpected exception caught during deactivation of component " + m_compInstanceName, ex);
}
}
if (deactivationFailedEx != null) {
if (m_containerLogger.isLoggable(Level.FINER)) {
m_containerLogger.log(Level.FINER, "Deactivation of component " + m_compInstanceName + " failed. " + "Will throw AcsJComponentDeactivationFailedEx", deactivationFailedEx);
}
throw deactivationFailedEx;
}
if (deactivationUncleanEx != null) {
if (m_containerLogger.isLoggable(Level.FINER)) {
m_containerLogger.log(Level.FINER, "Deactivation of component " + m_compInstanceName + " finished with problems. " + "Will throw AcsJComponentDeactivationUncleanEx", deactivationUncleanEx);
}
throw deactivationUncleanEx;
}
if (m_containerLogger.isLoggable(Level.FINER)) {
m_containerLogger.finer("Done deactivating component " + m_compInstanceName + " with handle " + getHandle());
}
}
Aggregations