src/main/java/org/apache/sling/launchpad/base/impl/DefaultStartupHandler.java - sling-org-apache-sling-launchpad-base - Git at Google

 /*
  * 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());
             }
         }
     }
 }
	/*
	* 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());
	}
	}
	}
	}