/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 2011-2013 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*/
package com.sun.enterprise.glassfish.bootstrap.osgi;
import com.sun.enterprise.glassfish.bootstrap.Util;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleException;
import org.osgi.framework.ServiceReference;
import org.osgi.framework.launch.Framework;
import org.osgi.framework.launch.FrameworkFactory;
import org.osgi.service.packageadmin.PackageAdmin;
import org.osgi.service.startlevel.StartLevel;
import java.io.*;
import java.lang.reflect.Constructor;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import com.sun.enterprise.glassfish.bootstrap.LogFacade;
/**
* Goes through a list of URIs and installs bundles from those locations.
* It installs the bundles in the same order as they appear in the configuration.
* <p/>
* This class is also responsible for updating or uninstalling bundles during
* subsequent restart if jars have been updated or deleted.
* <p/>
* It can also be passed a list of URIs of bundles to be started automatically.
* The list of bundles to be started must be a subset of list of bundles to be
* installed. The autostart bundles can also be configured with start level.
* It can be configured to start bundles persistently or transiently.
* <p/>
* This being a provisioning service itself can't expect too many other services to be available.
* So, it relies on core framework services only.
* <p/>
* Several operations of this class can be customized via a {@link Customizer} object. Please refer to
* {@link DefaultCustomizer} for the default policy.
*
* @author sanjeeb.sahoo@oracle.com
*/
public class BundleProvisioner {
/*
* Implementation Note: Since bundle installation order can affect OSGi packager resolver, this class
* honors the order specified by user.
*/
/**
* This interface allows us to customize various aspects of this class.
* e.g., what should be used as location string while installing bundles,
* what should be installed from a given directory, etc.
*/
interface Customizer {
/**
* @param jar jar to be installed as bundle
* @return Location that should be used while installing this jar as a bundle
*/
String makeLocation(Jar jar);
/**
* Is this jar managed by us?
*
* @param jar
* @return
*/
boolean isManaged(Jar jar);
/**
* Return list of locations from where bundles are installed.
*
* @return
*/
List<URI> getAutoInstallLocations();
/**
* Return list of locations from where bundles are started. This must be a subset of what is returned by
* {@link #getAutoInstallLocations()}
*
* @return
*/
List<URI> getAutoStartLocations();
/**
* Options used in Bundle.start().
*
* @return
*/
int getStartOptions();
/**
* @param jar
* @return start level of this bundle. -1 if not known
*/
Integer getStartLevel(Jar jar);
}
private static Logger logger = LogFacade.BOOTSTRAP_LOGGER;
private BundleContext bundleContext;
private boolean systemBundleUpdationRequired;
private Map<URI, Jar> currentManagedBundles = new HashMap<URI, Jar>();
private int noOfUninstalledBundles;
private int noOfUpdatedBundles;
private int noOfInstalledBundles;
private Customizer customizer;
private StartLevel sl;
private PackageAdmin pa;
public BundleProvisioner(BundleContext bundleContext, Properties config) {
this(bundleContext, new DefaultCustomizer(config));
}
public BundleProvisioner(BundleContext bundleContext, Customizer customizer) {
this.bundleContext = bundleContext;
this.customizer = customizer;
final ServiceReference reference =
getBundleContext().getServiceReference(StartLevel.class.getName());
sl = StartLevel.class.cast(
getBundleContext().getService(reference));
}
public BundleContext getBundleContext() {
return bundleContext;
}
public void setBundleContext(BundleContext bundleContext) {
this.bundleContext = bundleContext;
}
/**
* This method goes collects list of bundles that have been installed
* from the watched directory in previous run of the program,
* compares them with the current set of jar files,
* uninstalls old bundles, updates modified bundles, installs new bundles.
* It returns list of bundle ids provisioned by this provisoner.
*/
public List<Long> installBundles() {
initCurrentManagedBundles();
final Collection<Jar> current = getBundleJars();
List<Jar> discovered = discoverJars();
// Find out all the new, deleted and common bundles.
// new = discovered - current
List<Jar> newBundles = new ArrayList<Jar>(discovered);
newBundles.removeAll(current);
// deleted = current - discovered
List<Jar> deletedBundles = new ArrayList<Jar>(current);
deletedBundles.removeAll(discovered);
// existing = intersection of current & discovered
List<Jar> existingBundles = new ArrayList<Jar>(discovered);
// We remove discovered ones from current, so that we are left
// with a collection of Jars made from files so that we can compare
// them with bundles.
existingBundles.retainAll(current);
// We do the operations in the following order:
// uninstall, update, install, refresh & start.
uninstall(deletedBundles);
update(existingBundles);
install(newBundles);
List<Long> ids = new ArrayList<Long>();
for (Jar j : currentManagedBundles.values()) {
ids.add(j.getBundleId());
}
return ids;
}
/**
* Go through the list of auto start bundles and start them.
*/
public void startBundles() {
for (URI uri : getAutoStartLocations()) {
Bundle bundle = getBundle(new Jar(uri));
if (bundle == null) {
logger.log(Level.WARNING, LogFacade.CANT_START_BUNDLE, new Object[]{uri});
continue;
} else {
startBundle(bundle);
}
}
}
/**
* Start a bundle using given policy
*
* @param bundle
*/
private void startBundle(Bundle bundle) {
if (!isFragment(bundle)) {
try {
bundle.start(customizer.getStartOptions());
logger.logp(Level.FINE, "BundleProvisioner", "startBundle", "Started bundle = {0}",
new Object[]{bundle});
} catch (BundleException e) {
LogFacade.log(logger,
Level.WARNING,
LogFacade.BUNDLE_START_FAILED,
e,
bundle);
}
}
}
/**
* This method goes through all the currently installed bundles
* and returns information about those bundles whose location
* refers to locations as we have been configured to manage.
*/
private void initCurrentManagedBundles() {
Bundle[] bundles = getBundleContext().getBundles();
for (Bundle bundle : bundles) {
try {
final long id = bundle.getBundleId();
if (id == 0) {
// We can't manage system bundle
continue;
}
Jar jar = new Jar(bundle);
if (customizer.isManaged(jar)) {
addBundle(jar);
}
}
catch (URISyntaxException e) {
// Ignore and continue.
// This can never happen for bundles that have been installed
// by FileInstall, as we always use proper filepath as location.
}
}
}
/**
* @return list of URIs configured to be installed everytime
*/
private List<URI> getAutoInstallLocations() {
return customizer.getAutoInstallLocations();
}
/**
* @return list of URIs configured to be started everytime
*/
private List<URI> getAutoStartLocations() {
return customizer.getAutoStartLocations();
}
private Integer getStartLevel(Jar jar) {
return customizer.getStartLevel(jar);
}
/**
* Goes through the list of URIs configured via the config properties and converst them into
* bundle Jar objects. It delegates to the customizer to discover the bundle jars.
*
* @return
*/
private List<Jar> discoverJars() {
List<Jar> jars = new ArrayList<Jar>();
for (URI uri : getAutoInstallLocations()) {
jars.add(new Jar(uri));
}
return jars;
}
protected int uninstall(List<Jar> bundles) {
for (Jar jar : bundles) {
Bundle bundle = getBundle(jar);
if (bundle == null) {
// this is highly unlikely, but can't be ruled out.
logger.log(Level.WARNING, LogFacade.BUNDLE_ALREADY_UNINSTALED, new Object[]{jar.getPath()});
continue;
}
try {
if (isFrameworkExtensionBundle(bundle)) {
setSystemBundleUpdationRequired(true);
}
bundle.uninstall();
noOfUninstalledBundles++;
removeBundle(jar);
logger.log(Level.INFO, LogFacade.UNINSTALLED_BUNDLE, new Object[]{bundle.getBundleId(), jar.getPath()});
} catch (Exception e) {
LogFacade.log(logger,
Level.WARNING,
LogFacade.BUNDLE_UNINSTALL_FAILED,
e,
jar.getPath());
}
}
return noOfUninstalledBundles;
}
private int update(Collection<Jar> jars) {
for (Jar jar : jars) {
final Jar existingJar = getBundleJar(jar);
if (jar.isNewer(existingJar)) {
Bundle bundle = getBundle(existingJar);
if (bundle == null) {
// this is highly unlikely, but can't be ruled out.
logger.log(Level.WARNING, LogFacade.CANT_UPDATE_ALREADY_INSTALLED, new Object[]{existingJar.getPath()});
continue;
}
try {
if (isFrameworkExtensionBundle(bundle)) {
setSystemBundleUpdationRequired(true);
}
bundle.update();
noOfUpdatedBundles++;
logger.log(Level.INFO, LogFacade.BUNDLE_UPDATED, new Object[]{bundle.getBundleId(), jar.getPath()});
} catch (Exception e) {
LogFacade.log(logger,
Level.WARNING,
LogFacade.UPDATE_FAILED,
e,
jar.getPath());
}
}
}
return noOfUpdatedBundles;
}
private Collection<Jar> getBundleJars() {
return currentManagedBundles.values();
}
private Jar getBundleJar(Jar jar) {
return currentManagedBundles.get(jar.getURI());
}
private void addBundle(Jar jar) throws URISyntaxException {
currentManagedBundles.put(jar.getURI(), jar);
}
private void removeBundle(Jar jar) throws URISyntaxException {
currentManagedBundles.remove(jar.getURI());
}
/**
* Return a bundle corresponding to this jar object.
* It first searches using BundleContext as opposed to {@link #currentManagedBundles} so that it can give
* more accurate results if bundles have been uninstalled without our knowledge.
*
* @param jar
* @return
*/
private Bundle getBundle(Jar jar) {
long bundleId = jar.getBundleId();
if (bundleId < 0) {
final Jar jar1 = currentManagedBundles.get(jar.getURI());
if (jar1 != null) {
bundleId = jar1.getBundleId();
}
}
return getBundleContext().getBundle(bundleId);
}
/**
* Is the supplied bundle a framework extension bundle?
*
* @param bundle
* @return
*/
private boolean isFrameworkExtensionBundle(Bundle bundle) {
if (isFragment(bundle)) {
// Since Fragment-Host can use a framework specific symbolic name of the system bundle, we can't
// assume that user has used "system.bundle." So, we check for the directive "extension:=framework"
final String fragmentHost = (String) bundle.getHeaders().get(org.osgi.framework.Constants.FRAGMENT_HOST);
final String separator = ";";
for (String s : fragmentHost.split(separator)) {
int idx = s.indexOf(":=");
if (idx != -1) {
String directiveName = s.substring(0, idx).trim();
if (directiveName.equals("extension") && s.substring(idx + 2).trim().equals("framework")) {
logger.logp(Level.FINE, "BundleProvisioner", "isSystemBundleFragment",
"{0} is a framework extension bundle", new Object[]{bundle});
return true;
}
}
}
}
return false;
}
/**
* Is this a fragment bundle?
*
* @param bundle
* @return
*/
private boolean isFragment(Bundle bundle) {
final ServiceReference reference =
getBundleContext().getServiceReference(PackageAdmin.class.getName());
PackageAdmin pa = PackageAdmin.class.cast(
getBundleContext().getService(reference));
return (pa.getBundleType(bundle) == PackageAdmin.BUNDLE_TYPE_FRAGMENT);
}
private int install(Collection<Jar> jars) {
for (Jar jar : jars) {
try {
final InputStream is = jar.getURI().toURL().openStream();
try {
Bundle b = getBundleContext().installBundle(makeLocation(jar), is);
Integer startLevel = getStartLevel(jar);
if (startLevel != null) { // if specified, set it
getStartLevelService().setBundleStartLevel(b, startLevel);
}
noOfInstalledBundles++;
addBundle(new Jar(b));
logger.logp(Level.FINE, "BundleProvisioner", "install",
"Installed bundle {0} from {1} ",
new Object[]{b.getBundleId(), jar.getURI()});
} finally {
try {
is.close();
} catch (IOException e) {
}
}
} catch (Exception e) {
LogFacade.log(logger,
Level.WARNING,
LogFacade.INSTALL_FAILED,
e,
jar.getURI());
}
}
return noOfInstalledBundles;
}
private StartLevel getStartLevelService() {
return sl;
}
private String makeLocation(Jar jar) {
return customizer.makeLocation(jar);
}
/**
* Refresh packages
*/
public void refresh() {
final ServiceReference reference =
getBundleContext().getServiceReference(PackageAdmin.class.getName());
PackageAdmin pa = PackageAdmin.class.cast(
getBundleContext().getService(reference));
pa.refreshPackages(null); // null to refresh any bundle that's obsolete
getBundleContext().ungetService(reference);
}
/**
* @return true if anything changed since last time framework was initialized
*/
public boolean hasAnyThingChanged() {
return getNoOfInstalledBundles() + getNoOfUninstalledBundles() + getNoOfUpdatedBundles() > 0;
}
/**
* @return true if system bundle needs to be updated because of bundles getting updated or deleted or installed.
*/
public boolean isSystemBundleUpdationRequired() {
return systemBundleUpdationRequired;
}
protected void setSystemBundleUpdationRequired(boolean systemBundleUpdationRequired) {
this.systemBundleUpdationRequired = systemBundleUpdationRequired;
}
/**
* @return no of bundles uninstalled
*/
public int getNoOfUninstalledBundles() {
return noOfUninstalledBundles;
}
/**
* @return no of bundles updated
*/
public int getNoOfUpdatedBundles() {
return noOfUpdatedBundles;
}
/**
* @return no of bundles installed
*/
public int getNoOfInstalledBundles() {
return noOfInstalledBundles;
}
public Customizer getCustomizer() {
return customizer;
}
/**
* This is default implementation of {@link Customizer} which uses the URI of the Jar as location.
* The default customizer uses following configuration properties:
* <p/>
* glassfish.osgi.auto.install:
* <p/>
* This contains white space delimited list of absolute URIs to be installed.
* If a URI represents a directory location, then it will be treated as if all the jar files from that
* directory location (non-recursive) were specified instead.
* Bundles will be installed in the same order they are specified.
* <p/>
* <p/>
* glassfish.osgi.auto.start:
* This contains white space delimited list of absolute URIs to be started.
* If a URI represents a directory location, then it will be treated as if all the jar files from that
* directory location (non-recursive) were specified instead. Although bundles will be started in the order
* they are specified in this list, their eventual activation order depends on start level and/or activation policy.
* <p/>
* <p/>
* glassfish.osgi.auto.start.level.N, where N is > 0
* This contains list of bundle URIs to be started at start level N.
* <p/>
* <p/>
* glassfish.osgi.auto.start.option:
* This specifies the options used to start bundles. It is an integer and must confirm to the format accepted by
* {@link Bundle#start(int)} method. The default is to use {@link Bundle#START_ACTIVATION_POLICY}. It also means
* bundles will be started persistently by default. To start transiently, one has to specify explicitly.
*
* @author sanjeeb.sahoo@oracle.com
*/
public static class DefaultCustomizer implements Customizer {
private Properties config;
/**
* Maps URI to start level
*/
private final Map<URI, Integer> startLevels = new HashMap<URI, Integer>();
private List<URI> autoInstallLocations;
private List<URI> autoStartLocations;
private List<URI> configuredAutoInstallLocations;
public DefaultCustomizer(Properties config) {
this.config = config;
// for optimization reasons, process these properties once and store their values
processAutoInstallLocations();
processAutoStartLocations();
processStartLevels();
}
private void processAutoInstallLocations() {
String list = config.getProperty(Constants.AUTO_INSTALL_PROP);
configuredAutoInstallLocations = getLocations(list, false);
autoInstallLocations = getLocations(list);
}
private void processAutoStartLocations() {
String list = config.getProperty(Constants.AUTO_START_PROP);
autoStartLocations = getLocations(list);
}
private void processStartLevels() {
for (String key : config.stringPropertyNames()) {
if (key.startsWith(Constants.AUTO_START_LEVEL_PROP)) {
try {
Integer startLevel = Integer.parseInt(key.substring(key.lastIndexOf('.') + 1));
String list = config.getProperty(key);
for (URI uri : getLocations(list)) {
if (startLevels.containsKey(uri)) {
logger.log(Level.WARNING, LogFacade.CANT_SET_START_LEVEL,
new Object[]{uri, startLevels.get(uri), startLevel});
} else {
startLevels.put(uri, startLevel);
}
}
}
catch (NumberFormatException ex) {
System.err.println("Invalid property: " + key);
}
}
}
}
@Override
public List<URI> getAutoInstallLocations() {
return autoInstallLocations;
}
@Override
public List<URI> getAutoStartLocations() {
return autoStartLocations;
}
private List<URI> getLocations(String list) {
return getLocations(list, true);
}
private List<URI> getLocations(String list, boolean expand) {
if (list == null || list.isEmpty()) {
return Collections.emptyList();
}
List<URI> uris = new ArrayList<URI>();
for (String s : list.split("\\s")) {
try {
URI uri = new URI(s);
if (!uri.isAbsolute()) {
logger.log(Level.WARNING, LogFacade.ENTRY_SKIPPED, new Object[]{uri});
continue;
}
if (expand && isDirectory(uri)) {
uris.addAll(listJarFiles(uri));
} else {
uris.add(uri);
}
} catch (URISyntaxException e) {
LogFacade.log(logger,
Level.WARNING, LogFacade.ENTRY_SKIPPED_DUE_TO, e, s);
}
}
return uris;
}
@Override
public int getStartOptions() {
String s = config.getProperty(Constants.AUTO_START_OPTIONS_PROP);
if (s != null) {
return Integer.valueOf(s);
} else {
return Bundle.START_ACTIVATION_POLICY;
}
}
@Override
public String makeLocation(Jar jar) {
return jar.getURI().toString();
}
/**
* Is this URI a directory?
*
* @param uri URI to be checked
* @return true if this URI represents a directory, else false.
*/
protected boolean isDirectory(URI uri) {
try {
return new File(uri).isDirectory();
} catch (Exception e) {
return false;
}
}
/**
* @param aDirectoryURI uri corresponding to a directory location which will be searched.
* @return URIs corresponding to jar files in a given directory location.
*/
protected List<? extends URI> listJarFiles(URI aDirectoryURI) {
// currently we only support file type directory URI. In future, we should be able to handle
// directories inside jar files as well.
assert (Constants.FILE_SCHEME.equalsIgnoreCase(aDirectoryURI.getScheme()));
final List<URI> jarURIs = new ArrayList<URI>();
// File dir = new File(aDirectoryURI);
new File(aDirectoryURI).listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.getName().endsWith(".jar") && !pathname.isDirectory()) {
jarURIs.add(pathname.toURI());
return true;
}
return false;
}
});
return jarURIs;
}
@Override
public boolean isManaged(Jar jar) {
URI uri = jar.getURI();
if (uri == null) {
// jar.getURI is null means we could not parse the location
// as a meaningful URI. We can't do any meaningful processing for this bundle.
return false;
} else {
for (URI configuredLocation : getConfiguredAutoInstallLocations()) {
final String otherLocationAsString = configuredLocation.toString();
if (uri.toString().regionMatches(0, otherLocationAsString, 0, otherLocationAsString.length())) {
return true;
}
}
}
return false;
}
@Override
public Integer getStartLevel(Jar jar) {
return startLevels.get(jar.getURI());
}
protected List<URI> getConfiguredAutoInstallLocations() {
return configuredAutoInstallLocations;
}
}
/**
* A simple main method to test this class
*
* @param args
*/
public static void main(String[] args) throws Exception {
logger.log(Level.INFO, LogFacade.STARTING_BUNDLEPROVISIONER);
Properties props = new Properties();
props.load(new FileInputStream(args[0]));
Util.substVars(props);
PrintStream out = new PrintStream(new FileOutputStream(args[1], true));
long t0 = System.currentTimeMillis();
Framework f = null;
for (FrameworkFactory ff : ServiceLoader.load(FrameworkFactory.class)) {
f = ff.newFramework(props);
System.out.println("framework = " + f);
break;
}
if (f == null) {
throw new RuntimeException("no OSGi framework in classpath");
}
long t1 = System.currentTimeMillis();
logger.log(Level.INFO, LogFacade.OSGI_LOCATE_TIME, (t1-t0));
f.init();
long t2 = System.currentTimeMillis();
logger.log(Level.INFO, LogFacade.OSGI_INIT_TIME, (t2-t1));
BundleProvisioner bundleProvisioner = createBundleProvisioner(f.getBundleContext(), props);
bundleProvisioner.installBundles();
long t3 = System.currentTimeMillis();
logger.log(Level.INFO, LogFacade.BUNDLE_INSTALLATION_TIME, (t3-t2));
int installed = bundleProvisioner.getNoOfInstalledBundles();
int updated = bundleProvisioner.getNoOfUpdatedBundles();
int uninstalled = bundleProvisioner.getNoOfUninstalledBundles();
System.out.printf("installed = %d, updated = %d, uninstalled = %d\n", installed, updated, uninstalled);
if (bundleProvisioner.hasAnyThingChanged()) {
System.out.println("Refreshing framework");
bundleProvisioner.refresh();
}
bundleProvisioner.startBundles();
f.start();
long t4 = System.currentTimeMillis();
logger.log(Level.INFO, LogFacade.BUNDLE_STARTING_TIME, (t4-t3));
logger.log(Level.INFO, LogFacade.TOTAL_START_TIME, (t4-t0));
if (args.length == 3 && args[2].equalsIgnoreCase("wait-before-stopping")) {
System.out.println("Hit enter to continue");
System.in.read(); //
}
f.stop();
f.waitForStop(0);
long t5 = System.currentTimeMillis();
logger.log(Level.INFO, LogFacade.BUNDLE_STOP_TIME, (t5 - t4));
logger.log(Level.INFO, LogFacade.TOTAL_TIME, (t5-t0));
out.printf("%d,%d,%d,%d,%d,%d,%d\n", t1-t0, t2-t1, t3-t2, t4-t3, t4-t0, t5-t4, t5-t0);
}
static BundleProvisioner createBundleProvisioner(BundleContext bctx, Properties props) {
Class clazz = Boolean.valueOf(props.getProperty(Constants.ONDEMAND_BUNDLE_PROVISIONING)) ?
MinimalBundleProvisioner.class : BundleProvisioner.class;
logger.log(Level.INFO, LogFacade.CREATE_BUNDLE_PROVISIONER, clazz);
try {
final Constructor constructor = clazz.getConstructor(BundleContext.class, Properties.class);
return (BundleProvisioner) constructor.newInstance(bctx, props);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}