/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.felix.scr.impl;
import java.io.PrintStream;
import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.apache.felix.scr.impl.config.ScrConfiguration;
import org.apache.felix.scr.impl.runtime.ServiceComponentRuntimeImpl;
import org.apache.felix.utils.extender.AbstractExtender;
import org.apache.felix.utils.extender.Extension;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
import org.osgi.framework.ServiceRegistration;
import org.osgi.service.component.ComponentConstants;
import org.osgi.service.component.runtime.ServiceComponentRuntime;
import org.osgi.service.log.LogService;
import org.osgi.util.tracker.ServiceTracker;
/**
* This activator is used to cover requirement described in section 112.8.1 @@ -27,14
* 37,202 @@ in active bundles.
*
*/
public class Activator extends AbstractExtender
{
// name of the LogService class (this is a string to not create a reference to the class)
static final String LOGSERVICE_CLASS = "org.osgi.service.log.LogService";
// name of the PackageAdmin class (this is a string to not create a reference to the class)
static final String PACKAGEADMIN_CLASS = "org.osgi.service.packageadmin.PackageAdmin";
// Our configuration from bundle context properties and Config Admin
private static ScrConfiguration m_configuration;
// this bundle's context
private static BundleContext m_context;
// this bundle
private static Bundle m_bundle;
// the log service to log messages to
private static volatile ServiceTracker<LogService, LogService> m_logService;
// the package admin service (see BindMethod.getParameterClass)
private static volatile ServiceTracker<?, ?> m_packageAdmin;
// map of BundleComponentActivator instances per Bundle indexed by Bundle id
private Map<Long, BundleComponentActivator> m_componentBundles;
// registry of managed component
private ComponentRegistry m_componentRegistry;
// thread acting upon configurations
private ComponentActorThread m_componentActor;
private ServiceRegistration<ServiceComponentRuntime> m_runtime_reg;
private ScrCommand m_scrCommand;
public Activator() {
m_configuration = new ScrConfiguration( this );
setSynchronous(true);
}
/**
* Registers this instance as a (synchronous) bundle listener and loads the
* components of already registered bundles.
*
* @param context The <code>BundleContext</code> of the SCR implementation
* bundle.
*/
public void start( BundleContext context ) throws Exception
{
m_context = context;
m_bundle = context.getBundle();
// require the log service
m_logService = new ServiceTracker<LogService, LogService>( m_context, LOGSERVICE_CLASS, null );
m_logService.open();
// get the configuration
m_configuration.start( m_context ); //this will call restart, which calls super.start.
}
public void restart( boolean globalExtender )
{
BundleContext context;
if ( globalExtender )
{
context = m_context.getBundle( 0 ).getBundleContext();
}
else
{
context = m_context;
}
if ( m_packageAdmin != null )
{
log( LogService.LOG_INFO, m_bundle, "Stopping to restart with new globalExtender setting: " + globalExtender, null );
//this really is a restart, not the initial start
try
{
super.stop(context);
}
catch ( Exception e )
{
log( LogService.LOG_ERROR, m_bundle, "Exception stopping during restart", e );
}
}
try
{
log( LogService.LOG_INFO, m_bundle, "Starting with globalExtender setting: " + globalExtender, null );
super.start( context );
}
catch ( Exception e )
{
log( LogService.LOG_ERROR, m_bundle, "Exception starting during restart", e );
}
}
protected void doStart() throws Exception {
// prepare component registry
m_componentBundles = new HashMap<Long, BundleComponentActivator>();
m_componentRegistry = new ComponentRegistry( m_context );
ServiceComponentRuntime runtime = new ServiceComponentRuntimeImpl(m_context, m_componentRegistry);
m_runtime_reg = m_context.registerService(ServiceComponentRuntime.class, runtime, null);
// log SCR startup
log( LogService.LOG_INFO, m_bundle, " Version = {0}",
new Object[] {m_bundle.getHeaders().get( Constants.BUNDLE_VERSION )}, null );
// create and start the component actor
m_componentActor = new ComponentActorThread();
Thread t = new Thread(m_componentActor, "SCR Component Actor");
t.setDaemon( true );
t.start();
super.doStart();
m_scrCommand = ScrCommand.register(m_context, runtime, m_configuration);
m_configuration.setScrCommand( m_scrCommand );
}
public void stop(BundleContext context) throws Exception
{
super.stop(context);
m_configuration.stop();
m_configuration = null;
}
/**
* Unregisters this instance as a bundle listener and unloads all components
* which have been registered during the active life time of the SCR
* implementation bundle.
*/
public void doStop() throws Exception
{
// stop tracking
super.doStop();
if (m_scrCommand != null)
{
m_scrCommand.unregister();
m_scrCommand = null;
}
if (m_runtime_reg != null)
{
m_runtime_reg.unregister();
m_runtime_reg = null;
}
// dispose component registry
m_componentRegistry.dispose();
// terminate the actor thread
if ( m_componentActor != null )
{
m_componentActor.terminate();
m_componentActor = null;
}
// close the LogService tracker now
if ( m_logService != null )
{
m_logService.close();
m_logService = null;
}
// close the PackageAdmin tracker now
if ( m_packageAdmin != null )
{
m_packageAdmin.close();
m_packageAdmin = null;
}
// remove the reference to the component context
m_context = null;
}
//---------- Component Management -----------------------------------------
@Override
protected Extension doCreateExtension(final Bundle bundle) throws Exception
{
return new ScrExtension(bundle);
}
protected class ScrExtension implements Extension {
private final Bundle bundle;
private final CountDownLatch started;
public ScrExtension(Bundle bundle) {
this.bundle = bundle;
this.started = new CountDownLatch(1);
}
public void start() {
try {
loadComponents( ScrExtension.this.bundle );
} finally {
started.countDown();
}
}
public void destroy() {
try {
this.started.await(m_configuration.stopTimeout(), TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
log( LogService.LOG_WARNING, m_bundle, "The wait for bundle {0}/{1} being started before destruction has been interrupted.",
new Object[] {bundle.getSymbolicName(), bundle.getBundleId()}, e );
}
disposeComponents( this.bundle );
}
}
/**
* Loads the components of the given bundle. If the bundle has no
* <i>Service-Component</i> header, this method has no effect. The
* fragments of a bundle are not checked for the header (112.4.1).
* <p>
* This method calls the {@link Bundle#getBundleContext()} method to find
* the <code>BundleContext</code> of the bundle. If the context cannot be
* found, this method does not load components for the bundle.
*/
private void loadComponents( Bundle bundle )
{
if ( bundle.getHeaders().get( "Service-Component" ) == null )
{
// no components in the bundle, abandon
return;
}
// there should be components, load them with a bundle context
BundleContext context = bundle.getBundleContext();
if ( context == null )
{
log( LogService.LOG_ERROR, m_bundle, "Cannot get BundleContext of bundle {0}/{1}",
new Object[] {bundle.getSymbolicName(), bundle.getBundleId()}, null );
return;
}
// FELIX-1666 method is called for the LAZY_ACTIVATION event and
// the started event. Both events cause this method to be called;
// so we have to make sure to not load components twice
// FELIX-2231 Mark bundle loaded early to prevent concurrent loading
// if LAZY_ACTIVATION and STARTED event are fired at the same time
final boolean loaded;
final Long bundleId = bundle.getBundleId();
synchronized ( m_componentBundles )
{
if ( m_componentBundles.containsKey( bundleId ) )
{
loaded = true;
}
else
{
m_componentBundles.put( bundleId, null );
loaded = false;
}
}
// terminate if already loaded (or currently being loaded)
if ( loaded )
{
log( LogService.LOG_DEBUG, m_bundle, "Components for bundle {0}/{1} already loaded. Nothing to do.",
new Object[] {bundle.getSymbolicName(), bundle.getBundleId()}, null );
return;
}
try
{
BundleComponentActivator ga = new BundleComponentActivator( m_componentRegistry, m_componentActor, context,
m_configuration );
ga.initialEnable();
// replace bundle activator in the map
synchronized ( m_componentBundles )
{
m_componentBundles.put( bundleId, ga );
}
}
catch ( Exception e )
{
// remove the bundle id from the bundles map to ensure it is
// not marked as being loaded
synchronized ( m_componentBundles )
{
m_componentBundles.remove( bundleId );
}
if ( e instanceof IllegalStateException && bundle.getState() != Bundle.ACTIVE )
{
log(
LogService.LOG_DEBUG,
m_bundle,
"Bundle {0}/{1} has been stopped while trying to activate its components. Trying again when the bundles gets started again.",
new Object[] {bundle.getSymbolicName(), bundle.getBundleId()},
e );
}
else
{
log( LogService.LOG_ERROR, m_bundle, "Error while loading components of bundle {0}/{1}",
new Object[] {bundle.getSymbolicName(), bundle.getBundleId()}, e );
}
}
}
/**
* Unloads components of the given bundle. If no components have been loaded
* for the bundle, this method has no effect.
*/
private void disposeComponents( Bundle bundle )
{
final Object ga;
synchronized ( m_componentBundles )
{
ga = m_componentBundles.remove( bundle.getBundleId() );
}
if ( ga != null )
{
try
{
int reason = isStopping()
? ComponentConstants.DEACTIVATION_REASON_DISPOSED
: ComponentConstants.DEACTIVATION_REASON_BUNDLE_STOPPED;
( ( BundleComponentActivator ) ga ).dispose( reason );
}
catch ( Exception e )
{
log( LogService.LOG_ERROR, m_bundle, "Error while disposing components of bundle {0}/{1}",
new Object[] {bundle.getSymbolicName(), bundle.getBundleId()}, e );
}
}
}
@Override
protected void debug(Bundle bundle, String msg) {
final String message = MessageFormat.format( msg + " bundle: {0}/{1}", bundle.getSymbolicName(), bundle.getBundleId() );
log( LogService.LOG_DEBUG, bundle, message, null );
}
@Override
protected void warn(Bundle bundle, String msg, Throwable t) {
final String message = MessageFormat.format( msg + " bundle: {0}/{1}", bundle.getSymbolicName(), bundle.getBundleId() );
log( LogService.LOG_WARNING, bundle, message, t );
}
@Override
protected void error(String msg, Throwable t) {
log( LogService.LOG_DEBUG, m_bundle, msg, t );
}
public static void log( int level, Bundle bundle, String pattern, Object[] arguments, Throwable ex )
{
if ( isLogEnabled( level ) )
{
final String message = MessageFormat.format( pattern, arguments );
log( level, bundle, message, ex );
}
}
/**
* Returns <code>true</code> if logging for the given level is enabled.
*/
public static boolean isLogEnabled( int level )
{
return m_configuration == null || m_configuration.getLogLevel() >= level;
}
/**
* Method to actually emit the log message. If the LogService is available,
* the message will be logged through the LogService. Otherwise the message
* is logged to stdout (or stderr in case of LOG_ERROR level messages),
*
* @param level The log level to log the message at
* @param message The message to log
* @param ex An optional <code>Throwable</code> whose stack trace is written,
* or <code>null</code> to not log a stack trace.
*/
public static void log( int level, Bundle bundle, String message, Throwable ex )
{
if ( isLogEnabled( level ) )
{
ServiceTracker<LogService, LogService> t = m_logService;
LogService logger = ( t != null ) ? t.getService() : null;
if ( logger == null )
{
// output depending on level
PrintStream out = ( level == LogService.LOG_ERROR ) ? System.err : System.out;
// level as a string
StringBuffer buf = new StringBuffer();
switch ( level )
{
case ( LogService.LOG_DEBUG ):
buf.append( "DEBUG: " );
break;
case ( LogService.LOG_INFO ):
buf.append( "INFO : " );
break;
case ( LogService.LOG_WARNING ):
buf.append( "WARN : " );
break;
case ( LogService.LOG_ERROR ):
buf.append( "ERROR: " );
break;
default:
buf.append( "UNK : " );
break;
}
// bundle information
if ( bundle != null )
{
buf.append( bundle.getSymbolicName() );
buf.append( " (" );
buf.append( bundle.getBundleId() );
buf.append( "): " );
}
// the message
buf.append( message );
// keep the message and the stacktrace together
synchronized ( out)
{
out.println( buf );
if ( ex != null )
{
ex.printStackTrace( out );
}
}
}
else
{
logger.log( level, message, ex );
}
}
}
public static Object getPackageAdmin()
{
if ( m_packageAdmin == null )
{
synchronized ( Activator.class )
{
if ( m_packageAdmin == null )
{
m_packageAdmin = new ServiceTracker( m_context, PACKAGEADMIN_CLASS, null );
m_packageAdmin.open();
}
}
}
return m_packageAdmin.getService();
}
}