Java tutorial
/* * Copyright 2015 The Apache Software Foundation. * * Licensed 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.brooklyn.rt.felix; import com.google.common.base.Stopwatch; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.net.URL; import java.util.Arrays; import java.util.Enumeration; import java.util.HashMap; import java.util.Map; import java.util.Set; import java.util.jar.Attributes; import java.util.jar.JarOutputStream; import java.util.jar.Manifest; import org.apache.brooklyn.util.collections.MutableMap; import org.apache.brooklyn.util.collections.MutableSet; import org.apache.brooklyn.util.exceptions.Exceptions; import org.apache.brooklyn.util.exceptions.ReferenceWithError; import org.apache.brooklyn.util.net.Urls; import org.apache.brooklyn.util.osgi.OsgiUtils; import org.apache.brooklyn.util.time.Duration; import org.apache.brooklyn.util.time.Time; import org.apache.felix.framework.FrameworkFactory; import org.osgi.framework.Bundle; import org.osgi.framework.BundleContext; import org.osgi.framework.BundleException; import org.osgi.framework.Constants; import org.osgi.framework.launch.Framework; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * Functions for starting an Apache Felix OSGi framework inside a non-OSGi Brooklyn distro. * * @author Ciprian Ciubotariu <cheepeero@gmx.net> */ public class EmbeddedFelixFramework { private static final Logger LOG = LoggerFactory.getLogger(EmbeddedFelixFramework.class); private static final String EXTENSION_PROTOCOL = "system"; private static final String MANIFEST_PATH = "META-INF/MANIFEST.MF"; private static final Set<String> SYSTEM_BUNDLES = MutableSet.of(); // -------- creating /* * loading framework factory and starting framework based on: * http://felix.apache.org/documentation/subprojects/apache-felix-framework/apache-felix-framework-launching-and-embedding.html */ public static FrameworkFactory newFrameworkFactory() { URL url = EmbeddedFelixFramework.class.getClassLoader() .getResource("META-INF/services/org.osgi.framework.launch.FrameworkFactory"); if (url != null) { try { BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream())); try { for (String s = br.readLine(); s != null; s = br.readLine()) { s = s.trim(); // load the first non-empty, non-commented line if ((s.length() > 0) && (s.charAt(0) != '#')) { return (FrameworkFactory) Class.forName(s).newInstance(); } } } finally { if (br != null) br.close(); } } catch (Exception e) { // class creation exceptions are not interesting to caller... throw Exceptions.propagate(e); } } throw new IllegalStateException("Could not find framework factory."); } public static Framework newFrameworkStarted(String felixCacheDir, boolean clean, Map<?, ?> extraStartupConfig) { Map<Object, Object> cfg = MutableMap.copyOf(extraStartupConfig); if (clean) cfg.put(Constants.FRAMEWORK_STORAGE_CLEAN, "onFirstInit"); if (felixCacheDir != null) cfg.put(Constants.FRAMEWORK_STORAGE, felixCacheDir); cfg.put(Constants.FRAMEWORK_BSNVERSION, Constants.FRAMEWORK_BSNVERSION_MULTIPLE); FrameworkFactory factory = newFrameworkFactory(); Stopwatch timer = Stopwatch.createStarted(); Framework framework = factory.newFramework(cfg); try { framework.init(); installBootBundles(framework); framework.start(); } catch (Exception e) { // framework bundle start exceptions are not interesting to caller... throw Exceptions.propagate(e); } LOG.debug("System bundles are: " + SYSTEM_BUNDLES); LOG.debug("OSGi framework started in " + Duration.of(timer)); return framework; } public static void stopFramework(Framework framework) throws RuntimeException { try { if (framework != null) { framework.stop(); framework.waitForStop(0); } } catch (BundleException | InterruptedException e) { throw Exceptions.propagate(e); } } /* --- helper functions */ private static void installBootBundles(Framework framework) { Stopwatch timer = Stopwatch.createStarted(); LOG.debug("Installing OSGi boot bundles from " + EmbeddedFelixFramework.class.getClassLoader() + "..."); Enumeration<URL> resources; try { resources = EmbeddedFelixFramework.class.getClassLoader().getResources(MANIFEST_PATH); } catch (IOException e) { throw Exceptions.propagate(e); } BundleContext bundleContext = framework.getBundleContext(); Map<String, Bundle> installedBundles = getInstalledBundlesById(bundleContext); while (resources.hasMoreElements()) { URL url = resources.nextElement(); ReferenceWithError<?> installResult = installExtensionBundle(bundleContext, url, installedBundles, OsgiUtils.getVersionedId(framework)); if (installResult.hasError() && !installResult.masksErrorIfPresent()) { // it's reported as a critical error, so warn here LOG.warn("Unable to install manifest from " + url + ": " + installResult.getError(), installResult.getError()); } else { Object result = installResult.getWithoutError(); if (result instanceof Bundle) { String v = OsgiUtils.getVersionedId((Bundle) result); SYSTEM_BUNDLES.add(v); if (installResult.hasError()) { LOG.debug(installResult.getError().getMessage() + (result != null ? " (" + result + "/" + v + ")" : "")); } else { LOG.debug("Installed " + v + " from " + url); } } else if (installResult.hasError()) { LOG.debug(installResult.getError().getMessage()); } } } LOG.debug("Installed OSGi boot bundles in " + Time.makeTimeStringRounded(timer) + ": " + Arrays.asList(framework.getBundleContext().getBundles())); } private static Map<String, Bundle> getInstalledBundlesById(BundleContext bundleContext) { Map<String, Bundle> installedBundles = new HashMap<String, Bundle>(); Bundle[] bundles = bundleContext.getBundles(); for (Bundle b : bundles) { installedBundles.put(OsgiUtils.getVersionedId(b), b); } return installedBundles; } /** Wraps the bundle if successful or already installed, wraps TRUE if it's the system entry, * wraps null if the bundle is already installed from somewhere else; * in all these cases <i>masking</i> an explanatory error if already installed or it's the system entry. * <p> * Returns an instance wrapping null and <i>throwing</i> an error if the bundle could not be installed. */ private static ReferenceWithError<?> installExtensionBundle(BundleContext bundleContext, URL manifestUrl, Map<String, Bundle> installedBundles, String frameworkVersionedId) { //ignore http://felix.extensions:9/ system entry if ("felix.extensions".equals(manifestUrl.getHost())) return ReferenceWithError.newInstanceMaskingError(null, new IllegalArgumentException( "Skipping install of internal extension bundle from " + manifestUrl)); try { Manifest manifest = readManifest(manifestUrl); if (!isValidBundle(manifest)) return ReferenceWithError.newInstanceMaskingError(null, new IllegalArgumentException( "Resource at " + manifestUrl + " is not an OSGi bundle: no valid manifest")); String versionedId = OsgiUtils.getVersionedId(manifest); URL bundleUrl = OsgiUtils.getContainerUrl(manifestUrl, MANIFEST_PATH); Bundle existingBundle = installedBundles.get(versionedId); if (existingBundle != null) { if (!bundleUrl.equals(existingBundle.getLocation()) && //the framework bundle is always pre-installed, don't display duplicate info !versionedId.equals(frameworkVersionedId)) { return ReferenceWithError.newInstanceMaskingError(null, new IllegalArgumentException("Bundle " + versionedId + " (from manifest " + manifestUrl + ") is already installed, from " + existingBundle.getLocation())); } return ReferenceWithError.newInstanceMaskingError(existingBundle, new IllegalArgumentException( "Bundle " + versionedId + " from manifest " + manifestUrl + " is already installed")); } byte[] jar = buildExtensionBundle(manifest); LOG.debug("Installing boot bundle " + bundleUrl); //mark the bundle as extension so we can detect it later using the "system:" protocol //(since we cannot access BundleImpl.isExtension) Bundle newBundle = bundleContext.installBundle(EXTENSION_PROTOCOL + ":" + bundleUrl.toString(), new ByteArrayInputStream(jar)); installedBundles.put(versionedId, newBundle); return ReferenceWithError.newInstanceWithoutError(newBundle); } catch (Exception e) { Exceptions.propagateIfFatal(e); return ReferenceWithError.newInstanceThrowingError(null, new IllegalStateException("Problem installing extension bundle " + manifestUrl + ": " + e, e)); } } private static Manifest readManifest(URL manifestUrl) throws IOException { Manifest manifest; InputStream in = null; try { in = manifestUrl.openStream(); manifest = new Manifest(in); } finally { if (in != null) { try { in.close(); } catch (Exception e) { } ; } } return manifest; } private static byte[] buildExtensionBundle(Manifest manifest) throws IOException { Attributes atts = manifest.getMainAttributes(); //the following properties are invalid in extension bundles atts.remove(new Attributes.Name(Constants.IMPORT_PACKAGE)); atts.remove(new Attributes.Name(Constants.REQUIRE_BUNDLE)); atts.remove(new Attributes.Name(Constants.BUNDLE_NATIVECODE)); atts.remove(new Attributes.Name(Constants.DYNAMICIMPORT_PACKAGE)); atts.remove(new Attributes.Name(Constants.BUNDLE_ACTIVATOR)); //mark as extension bundle atts.putValue(Constants.FRAGMENT_HOST, "system.bundle; extension:=framework"); //create the jar containing the manifest ByteArrayOutputStream jar = new ByteArrayOutputStream(); JarOutputStream out = new JarOutputStream(jar, manifest); out.close(); return jar.toByteArray(); } private static boolean isValidBundle(Manifest manifest) { Attributes atts = manifest.getMainAttributes(); return atts.containsKey(new Attributes.Name(Constants.BUNDLE_MANIFESTVERSION)); } public static boolean isSystemBundle(Bundle bundle) { String versionedId = OsgiUtils.getVersionedId(bundle); return SYSTEM_BUNDLES.contains(versionedId); } public static boolean isExtensionBundle(Bundle bundle) { String location = bundle.getLocation(); return location != null && EXTENSION_PROTOCOL.equals(Urls.getProtocol(location)); } }