/** Start the OSGI framework. */
public void start() throws FrameworkStartFailedException {
FrameworkFactory frameworkFactory = null; // org.eclipse.osgi.launch.EquinoxFactory
try {
frameworkFactory = java.util.ServiceLoader.load(FrameworkFactory.class).iterator().next();
} catch (Exception ex) {
LOG.error("Failed to load osgi framework class.", ex);
// failed to load FrameworkFactory class
throw new FrameworkStartFailedException("Can't load class FrameworkFactory.", ex);
}
framework = frameworkFactory.newFramework(prepareSettings());
context = null;
try {
// start OSGi container ..
framework.start();
} catch (org.osgi.framework.BundleException ex) {
LOG.error("Failed to start OSGI framework.", ex);
// failed to start/initiate framework
throw new FrameworkStartFailedException("Failed to start OSGi framework.", ex);
}
try {
context = framework.getBundleContext();
} catch (SecurityException ex) {
LOG.error("Failed to get osgi context.", ex);
// we have to stop framework ..
stop();
throw new FrameworkStartFailedException("Failed to get OSGi context.", ex);
}
// load resources
startUpLoad();
}
public static void indexTargetPlatform(
OutputStream outputStream,
List<File> additionalJarFiles,
long stopWaitTimeout,
String... dirNames)
throws Exception {
Framework framework = null;
Path tempPath = Files.createTempDirectory(null);
ClassLoader classLoader = TargetPlatformIndexerUtil.class.getClassLoader();
try (InputStream inputStream =
classLoader.getResourceAsStream("META-INF/system.packages.extra.mf")) {
Map<String, String> properties = new HashMap<>();
properties.put(Constants.FRAMEWORK_STORAGE, tempPath.toString());
Manifest extraPackagesManifest = new Manifest(inputStream);
Attributes attributes = extraPackagesManifest.getMainAttributes();
properties.put(
Constants.FRAMEWORK_SYSTEMPACKAGES_EXTRA, attributes.getValue("Export-Package"));
ServiceLoader<FrameworkFactory> serviceLoader = ServiceLoader.load(FrameworkFactory.class);
FrameworkFactory frameworkFactory = serviceLoader.iterator().next();
framework = frameworkFactory.newFramework(properties);
framework.init();
BundleContext bundleContext = framework.getBundleContext();
Bundle systemBundle = bundleContext.getBundle(0);
TargetPlatformIndexer targetPlatformIndexer =
new TargetPlatformIndexer(systemBundle, additionalJarFiles, dirNames);
targetPlatformIndexer.index(outputStream);
} finally {
framework.stop();
FrameworkEvent frameworkEvent = framework.waitForStop(stopWaitTimeout);
if (frameworkEvent.getType() == FrameworkEvent.WAIT_TIMEDOUT) {
throw new Exception(
"OSGi framework event "
+ frameworkEvent
+ " triggered after a "
+ stopWaitTimeout
+ "ms timeout");
}
PathUtil.deltree(tempPath);
}
}
@Test
public void testNativeCodeExecPermission() throws Exception {
String tempFileName =
System.getProperty("java.io.tmpdir")
+ "/osgi_native"
+ System.currentTimeMillis()
+ ".test";
File tempFile = new File(tempFileName);
try {
Map<String, String> props = new HashMap<String, String>();
props.put("org.osgi.framework.storage", "target/osgi-store");
props.put("org.osgi.framework.storage.clean", "onFirstInit");
// Execute this command for every native library found in the bundle
props.put("org.osgi.framework.command.execpermission", "cp ${abspath} " + tempFileName);
FrameworkFactory factory = ServiceLoader.loadService(FrameworkFactory.class);
Framework framework = factory.newFramework(props);
framework.start();
assertFalse("Precondition", tempFile.exists());
Bundle bundle =
framework.getBundleContext().installBundle(getTestArchivePath("simple-nativecode.jar"));
bundle.start();
assertTrue(tempFile.exists());
framework.stop();
framework.waitForStop(2000);
} finally {
tempFile.delete();
}
}
public static void main(String[] args) {
try {
ServiceLoader<FrameworkFactory> loader = ServiceLoader.load(FrameworkFactory.class);
FrameworkFactory factory = loader.iterator().next();
Map<String, Object> config = new HashMap<String, Object>();
config.put(Constants.FRAMEWORK_STORAGE, "./target/storage");
Framework framework = factory.newFramework(config);
framework.start();
BundleContext context = framework.getBundleContext();
Bundle bundle =
context.installBundle("http://www.eclipsezone.com/files/jsig/bundles/HelloWorld.jar");
bundle.start();
framework.waitForStop(0);
} catch (Exception e) {
e.printStackTrace();
}
}
private ModuleManager(File cacheRoot) {
String systemPackagesSpec =
FluentIterable.from(SYSTEM_PACKAGES).transform(appendVersion).join(COMMA_JOINER);
Map<String, String> frameworkProps =
ImmutableMap.<String, String>builder()
.put(Constants.FRAMEWORK_SYSTEMPACKAGES_EXTRA, systemPackagesSpec)
.put("org.osgi.framework.storage.clean", "onFirstInit")
.put("felix.cache.rootdir", cacheRoot.getAbsolutePath())
.put("felix.cache.locking", Boolean.FALSE.toString())
.build();
LOG.info("Framework properties are: " + frameworkProps);
FrameworkFactory frameworkFactory =
ServiceLoader.load(FrameworkFactory.class).iterator().next();
m_framework = frameworkFactory.newFramework(frameworkProps);
try {
m_framework.start();
} catch (BundleException e) {
LOG.error("Failed to start the felix OSGi framework", e);
throw new SetUpException("Failed to start the felix OSGi framework", e);
}
m_bundles = new BundleRef(m_framework);
}
@Override
protected void before() throws Throwable {
final Map<String, String> configMap = new HashMap<>(2);
// Cleans framework before first init. Subsequent init invocations do not clean framework.
configMap.put("org.osgi.framework.storage.clean", "onFirstInit");
// Delegates loading of endorsed libraries to JVM classloader
// config.put("org.osgi.framework.bootdelegation", "javax.*,org.w3c.*,org.xml.*");
framework = factory.newFramework(configMap);
framework.init();
framework.start();
}
@Override
public void startFramework() throws Exception {
List<ServiceLoaderCondition> serviceLoaderConditions =
ServiceLoader.load(ServiceLoaderCondition.class);
ServiceLoaderCondition serviceLoaderCondition = serviceLoaderConditions.get(0);
List<FrameworkFactory> frameworkFactories =
ServiceLoader.load(FrameworkFactory.class, serviceLoaderCondition);
FrameworkFactory frameworkFactory = frameworkFactories.get(0);
Map<String, String> properties = _buildFrameworkProperties(frameworkFactory.getClass());
_framework = frameworkFactory.newFramework(properties);
_framework.init();
_framework.start();
RegistryUtil.setRegistry(new RegistryImpl(_framework.getBundleContext()));
_setupInitialBundles();
}
public TestContainer start() throws TestContainerException {
ClassLoader parent = null;
try {
final Map<String, String> p = new HashMap<String, String>(m_properties);
String folder = p.get("org.osgi.framework.storage");
if (folder == null) {
folder = System.getProperty("org.osgi.framework.storage");
}
if (folder == null) {
// folder = System.getProperty( "user.home" ) + File.separator + "osgi";
folder = getCache();
}
LOG.debug("Cache folder set to " + folder);
FileUtils.delete(new File(folder));
// load default stuff
p.put("org.osgi.framework.storage", folder);
// System.setProperty( "org.osgi.vendor.framework", "org.ops4j.pax.exam" );
p.put(
"org.osgi.framework.system.packages.extra",
"org.ops4j.pax.exam;version=" + skipSnapshotFlag(Info.getPaxExamVersion()));
parent = Thread.currentThread().getContextClassLoader();
// Thread.currentThread().setContextClassLoader( null );
m_framework = m_frameworkFactory.newFramework(p);
m_framework.init();
installAndStartBundles(m_framework.getBundleContext());
Thread.currentThread().setContextClassLoader(parent);
} catch (Exception e) {
throw new TestContainerException("Problem starting test container.", e);
} finally {
if (parent != null) {
Thread.currentThread().setContextClassLoader(parent);
}
}
return this;
}
@Override
public boolean startup(IPentahoSession session) {
logger.info("Starting OSGI Environment");
String solutionRootPath = PentahoSystem.getApplicationContext().getSolutionRootPath();
final String sep = File.separator;
Properties osgiProps = new Properties();
File propsFile =
new File(solutionRootPath + sep + "system" + sep + "osgi" + sep + "config.properties");
if (propsFile.exists()) {
try {
osgiProps.load(new FileInputStream(propsFile));
} catch (IOException e) {
logger.error("Error reading OSGI Host config", e);
}
}
Map<String, String> configProps = new HashMap<String, String>();
for (Map.Entry<Object, Object> entry : osgiProps.entrySet()) {
configProps.put(entry.getKey().toString(), entry.getValue().toString());
}
// configProps.put( FelixConstants.SYSTEMBUNDLE_ACTIVATORS_PROP, Collections.singletonList(new
// org.pentaho.platform.osgi.PentahoOSGIActivator()) );
configProps.put(Constants.FRAMEWORK_STORAGE, solutionRootPath + "/system/osgi/cache");
System.setProperty("felix.fileinstall.dir", solutionRootPath + "/system/osgi/bundles");
configProps.put("felix.fileinstall.debug", "4");
configProps.put("felix.fileinstall.bundles.new.start", "true");
configProps.put("felix.fileinstall.bundles.startActivationPolicy", "false");
configProps.put("org.eclipse.virgo.kernel.home", solutionRootPath + "/osgi/virgo");
configProps.put(
"org.eclipse.virgo.kernel.config", solutionRootPath + "/osgi/virgo/configuration");
configProps.put(
"osgi.sharedConfiguration.area", solutionRootPath + "/osgi/virgo/configuration");
configProps.put("osgi.configuration.area", solutionRootPath + "/osgi/virgo/configuration");
configProps.put("osgi.install.area", solutionRootPath + "/osgi/virgo");
configProps.put("eclipse.ignoreApp", "true");
try {
logger.debug("Attempting to load OSGI FrameworkFactory.");
FrameworkFactory factory = ServiceLoader.load(FrameworkFactory.class).iterator().next();
logger.debug("FrameworkFactory found");
framework = factory.newFramework(configProps);
logger.debug("Initializing FrameworkFactory");
framework.init();
logger.debug("Starting FrameworkFactory");
framework.start();
Runtime.getRuntime()
.addShutdownHook(
new Thread("Felix Shutdown Hook") {
public void run() {
shutdownFramework();
}
});
List<Bundle> bundleList = new ArrayList<Bundle>();
File[] bundleDirectories =
new File[] {
new File(
solutionRootPath
+ File.separator
+ "system"
+ File.separator
+ "osgi"
+ File.separator
+ "core_bundles"),
new File(
solutionRootPath
+ File.separator
+ "system"
+ File.separator
+ "osgi"
+ File.separator
+ "fragment_bundles"),
new File(
solutionRootPath
+ File.separator
+ "system"
+ File.separator
+ "osgi"
+ File.separator
+ "bundles")
};
logger.debug("Installing bundles");
for (File bundleDirectory : bundleDirectories) {
if (bundleDirectory.exists() == false) {
logger.warn("Bundle directory: " + bundleDirectory.getName() + " does not exist");
continue;
}
for (File f : bundleDirectory.listFiles()) {
if (f.isFile() && f.getName().endsWith(".jar")) {
try {
Bundle b = framework.getBundleContext().installBundle(f.toURI().toString());
bundleList.add(b);
} catch (Exception e) {
logger.error("Error installing Bundle", e);
}
}
}
}
logger.debug("Starting bundles");
for (Bundle bundle : bundleList) {
try {
// detect if a fragment bundle and skip. They cannot be started..
if (bundle.getHeaders().get("Fragment-Host") != null) {
continue;
}
bundle.start();
} catch (Exception e) {
logger.error("Error installing Bundle", e);
}
}
new PentahoOSGIActivator().setBundleContext(framework.getBundleContext());
return true;
} catch (Exception ex) {
logger.error("Error starting OSGI environment", ex);
return false;
}
}
/**
* This method performs the main task of constructing an framework instance and starting its
* execution. The following functions are performed when invoked:
*
* <ol>
* <li><i><b>Examine and verify command-line arguments.</b></i> The launcher accepts a
* "<tt>-b</tt>" command line switch to set the bundle auto-deploy directory and a single
* argument to set the bundle cache directory.
* <li><i><b>Read the system properties file.</b></i> This is a file containing properties to be
* pushed into <tt>System.setProperty()</tt> before starting the framework. This mechanism
* is mainly shorthand for people starting the framework from the command line to avoid
* having to specify a bunch of <tt>-D</tt> system property definitions. The only properties
* defined in this file that will impact the framework's behavior are the those concerning
* setting HTTP proxies, such as <tt>http.proxyHost</tt>, <tt>http.proxyPort</tt>, and
* <tt>http.proxyAuth</tt>. Generally speaking, the framework does not use system properties
* at all.
* <li><i><b>Read the framework's configuration property file.</b></i> This is a file containing
* properties used to configure the framework instance and to pass configuration information
* into bundles installed into the framework instance. The configuration property file is
* called <tt>config.properties</tt> by default and is located in the <tt>conf/</tt>
* directory of the Felix installation directory, which is the parent directory of the
* directory containing the <tt>felix.jar</tt> file. It is possible to use a different
* location for the property file by specifying the desired URL using the
* <tt>felix.config.properties</tt> system property; this should be set using the
* <tt>-D</tt> syntax when executing the JVM. If the <tt>config.properties</tt> file cannot
* be found, then default values are used for all configuration properties. Refer to the <a
* href="Felix.html#Felix(java.util.Map)"><tt>Felix</tt></a> constructor documentation for
* more information on framework configuration properties.
* <li><i><b>Copy configuration properties specified as system properties into the set of
* configuration properties.</b></i> Even though the Felix framework does not consult system
* properties for configuration information, sometimes it is convenient to specify them on
* the command line when launching Felix. To make this possible, the Felix launcher copies
* any configuration properties specified as system properties into the set of configuration
* properties passed into Felix.
* <li><i><b>Add shutdown hook.</b></i> To make sure the framework shutdowns cleanly, the
* launcher installs a shutdown hook; this can be disabled with the
* <tt>felix.shutdown.hook</tt> configuration property.
* <li><i><b>Create and initialize a framework instance.</b></i> The OSGi standard
* <tt>FrameworkFactory</tt> is retrieved from <tt>META-INF/services</tt> and used to create
* a framework instance with the configuration properties.
* <li><i><b>Auto-deploy bundles.</b></i> All bundles in the auto-deploy directory are deployed
* into the framework instance.
* <li><i><b>Start the framework.</b></i> The framework is started and the launcher thread waits
* for the framework to shutdown.
* </ol>
*
* <p>It should be noted that simply starting an instance of the framework is not enough to create
* an interactive session with it. It is necessary to install and start bundles that provide a
* some means to interact with the framework; this is generally done by bundles in the auto-deploy
* directory or specifying an "auto-start" property in the configuration property file. If no
* bundles providing a means to interact with the framework are installed or if the configuration
* property file cannot be found, the framework will appear to be hung or deadlocked. This is not
* the case, it is executing correctly, there is just no way to interact with it.
*
* <p>The launcher provides two ways to deploy bundles into a framework at startup, which have
* associated configuration properties:
*
* <ul>
* <li>Bundle auto-deploy - Automatically deploys all bundles from a specified directory,
* controlled by the following configuration properties:
* <ul>
* <li><tt>felix.auto.deploy.dir</tt> - Specifies the auto-deploy directory from which
* bundles are automatically deploy at framework startup. The default is the
* <tt>bundle/</tt> directory of the current directory.
* <li><tt>felix.auto.deploy.action</tt> - Specifies the auto-deploy actions to be found
* on bundle JAR files found in the auto-deploy directory. The possible actions are
* <tt>install</tt>, <tt>update</tt>, <tt>start</tt>, and <tt>uninstall</tt>. If no
* actions are specified, then the auto-deploy directory is not processed. There is no
* default value for this property.
* </ul>
* <li>Bundle auto-properties - Configuration properties which specify URLs to bundles to
* install/start:
* <ul>
* <li><tt>felix.auto.install.N</tt> - Space-delimited list of bundle URLs to
* automatically install when the framework is started, where <tt>N</tt> is the start
* level into which the bundle will be installed (e.g., felix.auto.install.2).
* <li><tt>felix.auto.start.N</tt> - Space-delimited list of bundle URLs to automatically
* install and start when the framework is started, where <tt>N</tt> is the start
* level into which the bundle will be installed (e.g., felix.auto.start.2).
* </ul>
* </ul>
*
* <p>These properties should be specified in the <tt>config.properties</tt> so that they can be
* processed by the launcher during the framework startup process.
*
* @param args Accepts arguments to set the auto-deploy directory and/or the bundle cache
* directory.
* @throws Exception If an error occurs.
*/
public static void main(String[] args) throws Exception {
// Look for bundle directory and/or cache directory.
// We support at most one argument, which is the bundle
// cache directory.
String bundleDir = null;
String cacheDir = null;
boolean expectBundleDir = false;
for (int i = 0; i < args.length; i++) {
if (args[i].equals(BUNDLE_DIR_SWITCH)) {
expectBundleDir = true;
} else if (expectBundleDir) {
bundleDir = args[i];
expectBundleDir = false;
} else {
cacheDir = args[i];
}
}
if ((args.length > 3) || (expectBundleDir && bundleDir == null)) {
System.out.println("Usage: [-b <bundle-deploy-dir>] [<bundle-cache-dir>]");
System.exit(0);
}
// Load system properties.
Main.loadSystemProperties();
// Read configuration properties.
Properties configProps = Main.loadConfigProperties();
// If no configuration properties were found, then create
// an empty properties object.
if (configProps == null) {
System.err.println("No " + CONFIG_PROPERTIES_FILE_VALUE + " found.");
configProps = new Properties();
}
// Copy framework properties from the system properties.
Main.copySystemProperties(configProps);
// If there is a passed in bundle auto-deploy directory, then
// that overwrites anything in the config file.
if (bundleDir != null) {
configProps.setProperty(AutoProcessor.AUTO_DEPLOY_DIR_PROPERY, bundleDir);
}
// If there is a passed in bundle cache directory, then
// that overwrites anything in the config file.
if (cacheDir != null) {
configProps.setProperty(Constants.FRAMEWORK_STORAGE, cacheDir);
}
// If enabled, register a shutdown hook to make sure the framework is
// cleanly shutdown when the VM exits.
String enableHook = configProps.getProperty(SHUTDOWN_HOOK_PROP);
if ((enableHook == null) || !enableHook.equalsIgnoreCase("false")) {
Runtime.getRuntime()
.addShutdownHook(
new Thread("Felix Shutdown Hook") {
public void run() {
try {
if (m_fwk != null) {
m_fwk.stop();
m_fwk.waitForStop(0);
}
} catch (Exception ex) {
System.err.println("Error stopping framework: " + ex);
}
}
});
}
try {
// Create an instance of the framework.
FrameworkFactory factory = getFrameworkFactory();
m_fwk = factory.newFramework(configProps);
// Initialize the framework, but don't start it yet.
m_fwk.init();
// Use the system bundle context to process the auto-deploy
// and auto-install/auto-start properties.
AutoProcessor.process(configProps, m_fwk.getBundleContext());
FrameworkEvent event;
do {
// Start the framework.
m_fwk.start();
// Wait for framework to stop to exit the VM.
event = m_fwk.waitForStop(0);
}
// If the framework was updated, then restart it.
while (event.getType() == FrameworkEvent.STOPPED_UPDATE);
// Otherwise, exit.
System.exit(0);
} catch (Exception ex) {
System.err.println("Could not create framework: " + ex);
ex.printStackTrace();
System.exit(0);
}
}
@Override
public void afterPropertiesSet() throws Exception {
if (!configuration.containsKey(Constants.FRAMEWORK_STORAGE)) {
File storageDir =
Bootstrap.getHmpHomeDirectory(this.applicationContext)
.createRelative("osgi-storage")
.getFile();
if (!storageDir.exists()) {
storageDir.mkdir();
}
configuration.put(Constants.FRAMEWORK_STORAGE, storageDir.getCanonicalPath());
}
if (!configuration.containsKey(Constants.FRAMEWORK_STORAGE_CLEAN_ONFIRSTINIT)) {
configuration.put(
Constants.FRAMEWORK_STORAGE_CLEAN, Constants.FRAMEWORK_STORAGE_CLEAN_ONFIRSTINIT);
}
if (!configuration.containsKey(Constants.FRAMEWORK_SYSTEMPACKAGES_EXTRA)) {
InputStreamReader isr =
new InputStreamReader(getClass().getResourceAsStream(SYSTEM_PACKAGES_RESOURCE));
String rawSystemPackages = FileCopyUtils.copyToString(isr);
String[] lines = rawSystemPackages.split("\\r?\\n");
String systemPackages = StringUtils.collectionToCommaDelimitedString(Arrays.asList(lines));
configuration.put(Constants.FRAMEWORK_SYSTEMPACKAGES_EXTRA, systemPackages);
LOGGER.debug(systemPackages);
isr.close();
}
if (!configuration.containsKey("felix.fileinstall.dir")) {
File pluginsDir = getPluginsDir(this.applicationContext).getFile();
if (!pluginsDir.exists()) {
pluginsDir.mkdir();
}
configuration.put("felix.fileinstall.dir", pluginsDir.getCanonicalPath());
}
ServiceLoader<FrameworkFactory> factoryLoader = ServiceLoader.load(FrameworkFactory.class);
FrameworkFactory frameworkFactory = factoryLoader.iterator().next();
framework = frameworkFactory.newFramework(configuration);
framework.start();
// install some bundles
List<Bundle> installedBundles = new ArrayList<Bundle>();
File bundlesDir =
Bootstrap.getHmpHomeDirectory(this.applicationContext).createRelative("bundles").getFile();
if (!bundlesDir.exists())
throw new ServiceConfigurationError(
"HMP OSGi system bundles missing or configured incorrectly (cannot find 'bundles' folder inside '"
+ Bootstrap.getHmpHomeDirectory(this.applicationContext).getFile().getAbsolutePath());
for (File f : bundlesDir.listFiles()) {
if (f.getName().endsWith("jar")) {
try {
Bundle bundle =
framework.getBundleContext().installBundle("file:" + f.getCanonicalPath());
installedBundles.add(bundle);
} catch (BundleException e) {
LOGGER.error("Unable to install bundle: " + f.getName(), e);
}
}
}
// start the installed bundles
for (Bundle bundle : installedBundles) {
if (bundle.getHeaders().get(Constants.FRAGMENT_HOST) == null) {
try {
bundle.start();
LOGGER.info(
"Started bundle: {}({})", bundle.getSymbolicName(), bundle.getVersion().toString());
} catch (BundleException e) {
LOGGER.error("Unable to start bundle: " + bundle.getSymbolicName(), e);
}
}
}
}
