/*
* 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.sling.launchpad.base.impl;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Dictionary;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Set;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.felix.framework.Logger;
import org.apache.sling.launchpad.api.StartupHandler;
import org.apache.sling.launchpad.api.StartupListener;
import org.apache.sling.launchpad.api.StartupMode;
import org.apache.sling.launchpad.api.StartupService;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleEvent;
import org.osgi.framework.BundleListener;
import org.osgi.framework.Constants;
import org.osgi.framework.FrameworkEvent;
import org.osgi.framework.FrameworkListener;
import org.osgi.framework.ServiceReference;
import org.osgi.service.startlevel.StartLevel;
import org.osgi.util.tracker.ServiceTracker;
import org.osgi.util.tracker.ServiceTrackerCustomizer;
/**
* The installation listener is listening for
* - framework events
* - events from other services
*
* It notifies listeners about the finish of the startup and
* about an approximate progress.
*
* @see StartupHandler
* @see StartupListener
* @since 2.4.0
*/
@SuppressWarnings("deprecation")
public class DefaultStartupHandler
implements StartupHandler, BundleListener, FrameworkListener, Runnable {
/** Logger. */
private final Logger logger;
/** Marker for finished. */
private final AtomicBoolean finished = new AtomicBoolean(false);
/** Marker if startup should wait */
private final AtomicInteger startupShouldWait = new AtomicInteger(0);
/** The queue for increasing the start level. */
private final BlockingQueue<Boolean> queue = new LinkedBlockingQueue<Boolean>();
/** The start level service. */
private final StartLevel startLevelService;
/** The target start level. */
private final long targetStartLevel;
/** The startup mode. */
private final StartupMode startupMode;
/** Service tracker for startup listeners. */
private final ServiceTracker<StartupListener, StartupListener> listenerTracker;
/** Expected bundle counts. */
private final int expectedBundlesCount;
/** Active bundle set. */
private final Set<String> activeBundles = new HashSet<String>();
/** Bundle Context. */
private final BundleContext bundleContext;
/** Use incremental start level handling. */
private final boolean useIncremental;
/** MBean startup listener. */
private final StartupListener mbeanStartupListener;
/** The started time. */
private final long startedAt;
private volatile Object[] logService;
/**
* Constructor.
* @param context Bundle context
* @param logger Logger
* @param manager The startup manager
*/
public DefaultStartupHandler(final BundleContext context,
final Logger logger,
final StartupManager manager,
final long startedAt) {
this.logger = logger;
this.bundleContext = context;
this.startedAt = startedAt;
this.startupMode = manager.getMode();
this.targetStartLevel = manager.getTargetStartLevel();
StartupListener listener = null;
try {
listener = new MBeanStartupListener();
} catch ( final Exception ignore ) {
// ignore
}
this.mbeanStartupListener = listener;
this.listenerTracker = new ServiceTracker<StartupListener, StartupListener>(context, StartupListener.class,
new ServiceTrackerCustomizer<StartupListener, StartupListener>() {
@Override
public void removedService(final ServiceReference<StartupListener> reference, final StartupListener service) {
context.ungetService(reference);
}
@Override
public void modifiedService(final ServiceReference<StartupListener> reference, final StartupListener service) {
// nothing to do
}
@Override
public StartupListener addingService(final ServiceReference<StartupListener> reference) {
final StartupListener listener = context.getService(reference);
if (listener != null) {
try {
listener.inform(startupMode, finished.get());
} catch (final Throwable t) {
logger.log(Logger.LOG_ERROR, "Error calling StartupListener " + listener, t);
}
}
return listener;
}
});
this.listenerTracker.open();
this.startLevelService = (StartLevel)context.getService(context.getServiceReference(StartLevel.class.getName()));
context.addFrameworkListener(this);
this.useIncremental = this.startupMode != StartupMode.RESTART && manager.isIncrementalStartupEnabled();
if ( !this.useIncremental ) {
final Bundle[] bundles = context.getBundles();
this.expectedBundlesCount = (bundles != null && bundles.length > 0 ? bundles.length : 10);
context.addBundleListener(this);
} else {
this.expectedBundlesCount = 10;
}
this.bundleContext.registerService(StartupHandler.class.getName(), this, null);
this.log(Logger.LOG_INFO, "Started startup handler with target start level="
+ String.valueOf(this.targetStartLevel) + ", and expected bundle count=" + String.valueOf(this.expectedBundlesCount));
final Thread t = new Thread(this);
t.start();
}
/**
* @see org.apache.sling.launchpad.api.StartupHandler#getMode()
*/
@Override
public StartupMode getMode() {
return this.startupMode;
}
/**
* @see org.apache.sling.launchpad.api.StartupHandler#isFinished()
*/
@Override
public boolean isFinished() {
return this.finished.get();
}
/**
* @see java.lang.Runnable#run()
*/
@Override
public void run() {
while ( !this.finished.get() ) {
Boolean doInc = null;
try {
doInc = this.queue.take();
} catch (final InterruptedException e) {
// ignore
}
if ( doInc != null && doInc ) {
// if the installer is idle we first wait
// we have to do this to give the installer or plugins for the installer,
// time to start after the start level has changed
if ( this.startupShouldWait.get() == 0 ) {
this.sleep(2000L);
}
// now we wait until the installer is idle
while ( this.startupShouldWait.get() != 0 ) {
this.sleep(50L);
}
this.incStartLevel();
}
}
}
/**
* Increment the current start level by one
*/
private void incStartLevel() {
final int newLevel = this.startLevelService.getStartLevel() + 1;
this.log(Logger.LOG_DEBUG, "Increasing start level to " + String.valueOf(newLevel));
this.startLevelService.setStartLevel(newLevel);
}
/**
* @see org.apache.sling.launchpad.api.StartupHandler#waitWithStartup(boolean)
*/
@Override
public void waitWithStartup(final boolean flag) {
this.log(Logger.LOG_DEBUG, "Wait with startup " + flag);
if ( flag ) {
this.startupShouldWait.incrementAndGet();
} else {
this.startupShouldWait.decrementAndGet();
}
}
/**
* Sleep a little bit
* @param time Sleeping time
*/
private void sleep(final long time) {
try {
Thread.sleep(time);
} catch ( final InterruptedException e) {
// ignore
}
}
/**
* Put a task in the queue
* @param info Add new boolean information to queue
*/
private void enqueue(final boolean info) {
try {
this.queue.put(info);
} catch (final InterruptedException e) {
// ignore
}
}
/**
* @see org.osgi.framework.FrameworkListener#frameworkEvent(org.osgi.framework.FrameworkEvent)
*/
@Override
public void frameworkEvent(final FrameworkEvent event) {
if ( finished.get() ) {
return;
}
this.log(Logger.LOG_DEBUG, "Received framework event " + event);
if ( !this.useIncremental ) {
// restart
if ( event.getType() == FrameworkEvent.STARTED ) {
this.startupFinished();
}
} else {
// first startup or update
if ( event.getType() == FrameworkEvent.STARTED ) {
this.enqueue(true);
} else if ( event.getType() == FrameworkEvent.STARTLEVEL_CHANGED ) {
if ( this.startLevelService.getStartLevel() >= this.targetStartLevel ) {
this.startupFinished();
} else {
this.enqueue(true);
final int startLevel = this.startLevelService.getStartLevel();
this.log(Logger.LOG_DEBUG, "Startup progress " + String.valueOf(startLevel) + '/' + String.valueOf(targetStartLevel));
final float ratio = (float) startLevel / (float) targetStartLevel;
this.startupProgress(ratio);
}
}
}
}
private void log(final int level, final String msg) {
log(null, level, msg, null);
}
private void log(final int level, final String msg, final Throwable t) {
log(null, level, msg, t);
}
private void log(final ServiceReference<?> sRef, final int level, final String msg, final Throwable t) {
boolean loggedWithService = false;
if ( this.logService == null ) {
final ServiceReference<?> ref = this.bundleContext.getServiceReference("org.osgi.service.log.LogService");
if ( ref != null ) {
final Object ls = this.bundleContext.getService(ref);
if ( ls != null ) {
final Class<?>[] formalParams = {
ServiceReference.class,
Integer.TYPE,
String.class,
Throwable.class
};
try {
final Method logMethod = ls.getClass().getMethod("log", formalParams);
logMethod.setAccessible(true);
logService = new Object[] { ls, logMethod };
} catch (final NoSuchMethodException ex) {
// no need to log
}
}
}
}
if ( this.logService != null ) {
final Object[] params = {sRef, new Integer(level), msg, t};
try {
((Method) this.logService[1]).invoke(this.logService[0], params);
loggedWithService = true;
} catch (final InvocationTargetException ex) {
// no need to log
} catch (final IllegalAccessException ex) {
// no need to log
}
}
if ( !loggedWithService ) {
logger.log(level, msg);
}
}
/**
* Notify finished startup
*/
private void startupFinished() {
this.log(Logger.LOG_INFO, "Startup finished in " + String.valueOf(System.currentTimeMillis() - this.startedAt) + "ms");
this.finished.set(true);
for (final StartupListener listener : this.listenerTracker.getServices(new StartupListener[0])) {
try {
listener.startupFinished(this.startupMode);
} catch (Throwable t) {
this.log(Logger.LOG_ERROR, "Error calling StartupListener " + listener, t);
}
}
if ( this.mbeanStartupListener != null ) {
this.mbeanStartupListener.startupFinished(this.startupMode);
}
// stop the queue
this.enqueue(false);
// clear bundle set
this.activeBundles.clear();
// unregister listeners
if ( !this.useIncremental ) {
this.bundleContext.removeBundleListener(this);
}
this.bundleContext.removeFrameworkListener(this);
// register startup service
final Dictionary<String, Object> serviceProps = new Hashtable<String, Object>();
serviceProps.put(StartupMode.class.getName(), this.startupMode.name());
serviceProps.put(Constants.SERVICE_DESCRIPTION, "Apache Sling Startup Service");
serviceProps.put(Constants.SERVICE_VENDOR, "The Apache Software Foundation");
this.bundleContext.registerService(StartupService.class, new StartupService() {
@Override
public StartupMode getStartupMode() {
return startupMode;
}
}, serviceProps);
}
/**
* Notify startup progress
* @param ratio ratio
*/
private void startupProgress(final float ratio) {
for (final StartupListener listener : this.listenerTracker.getServices(new StartupListener[0])) {
try {
listener.startupProgress(ratio);
} catch (final Throwable t) {
this.log(Logger.LOG_ERROR, "Error calling StartupListener " + listener, t);
}
}
if ( this.mbeanStartupListener != null ) {
this.mbeanStartupListener.startupProgress(ratio);
}
}
/**
* @see org.osgi.framework.BundleListener#bundleChanged(org.osgi.framework.BundleEvent)
*/
@Override
public void bundleChanged(final BundleEvent event) {
if (!finished.get()) {
this.log(Logger.LOG_DEBUG, "Received bundle event " + event);
if (event.getType() == BundleEvent.RESOLVED || event.getType() == BundleEvent.STARTED) {
// Add (if not existing) bundle to active bundles and refresh progress bar
activeBundles.add(event.getBundle().getSymbolicName());
this.log(Logger.LOG_DEBUG, "Startup progress " + String.valueOf(activeBundles.size()) + '/' + String.valueOf(expectedBundlesCount));
final float ratio = (float) activeBundles.size() / (float) expectedBundlesCount;
this.startupProgress(ratio);
} else if (event.getType() == BundleEvent.STOPPED) {
// Only remove bundle from active bundles,
// but do not refresh progress bar, to prevent progress bar from going back
activeBundles.remove(event.getBundle().getSymbolicName());
}
}
}
}