org.apache.camel.blueprint.CamelBlueprintHelper Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of camel-blueprint-main Show documentation
Show all versions of camel-blueprint-main Show documentation
Main support for OSGi Blueprint
/*
* 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.camel.blueprint;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.jar.JarInputStream;
import org.apache.camel.impl.engine.DefaultClassResolver;
import org.apache.camel.spi.ClassResolver;
import org.apache.camel.support.ObjectHelper;
import org.apache.camel.util.FileUtil;
import org.apache.camel.util.IOHelper;
import org.apache.felix.connect.PojoServiceRegistryFactoryImpl;
import org.apache.felix.connect.felix.framework.util.Util;
import org.apache.felix.connect.launch.BundleDescriptor;
import org.apache.felix.connect.launch.ClasspathScanner;
import org.apache.felix.connect.launch.PojoServiceRegistry;
import org.apache.felix.connect.launch.PojoServiceRegistryFactory;
import org.ops4j.pax.tinybundles.core.TinyBundle;
import org.ops4j.pax.tinybundles.core.TinyBundles;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleEvent;
import org.osgi.framework.BundleException;
import org.osgi.framework.Constants;
import org.osgi.framework.Filter;
import org.osgi.framework.FrameworkUtil;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceReference;
import org.osgi.framework.ServiceRegistration;
import org.osgi.framework.SynchronousBundleListener;
import org.osgi.service.blueprint.container.BlueprintEvent;
import org.osgi.service.blueprint.container.BlueprintListener;
import org.osgi.service.cm.Configuration;
import org.osgi.service.cm.ConfigurationAdmin;
import org.osgi.util.tracker.ServiceTracker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Helper for using Blueprint with Camel.
*/
public final class CamelBlueprintHelper {
public static final long DEFAULT_TIMEOUT = 30000;
public static final String BUNDLE_FILTER = "(Bundle-SymbolicName=*)";
public static final String BUNDLE_VERSION = "1.0.0";
private static final Logger LOG = LoggerFactory.getLogger(CamelBlueprintHelper.class);
private static final ClassResolver RESOLVER = new DefaultClassResolver();
private CamelBlueprintHelper() {
}
public static BundleContext createBundleContext(String name, String descriptors, boolean includeTestBundle) throws Exception {
return createBundleContext(name, descriptors, includeTestBundle, BUNDLE_FILTER, BUNDLE_VERSION);
}
public static BundleContext createBundleContext(String name, String descriptors, boolean includeTestBundle,
String bundleFilter, String testBundleVersion) throws Exception {
return createBundleContext(name, descriptors, includeTestBundle, bundleFilter, testBundleVersion, null);
}
public static BundleContext createBundleContext(String name, String descriptors, boolean includeTestBundle,
String bundleFilter, String testBundleVersion, String testBundleDirectives,
String[]... configAdminPidFiles) throws Exception {
return createBundleContext(name, descriptors, includeTestBundle,
bundleFilter, testBundleVersion, testBundleDirectives,
null,
configAdminPidFiles);
}
public static BundleContext createBundleContext(String name, String descriptors, boolean includeTestBundle,
String bundleFilter, String testBundleVersion, String testBundleDirectives,
ClassLoader loader,
String[]... configAdminPidFiles) throws Exception {
TinyBundle bundle = null;
TinyBundle configAdminInitBundle = null;
if (includeTestBundle) {
// add ourselves as a bundle
bundle = createTestBundle(testBundleDirectives == null ? name : name + ';' + testBundleDirectives,
testBundleVersion, descriptors);
}
if (configAdminPidFiles != null) {
configAdminInitBundle = createConfigAdminInitBundle(configAdminPidFiles);
}
return createBundleContext(name, bundleFilter, bundle, configAdminInitBundle, loader);
}
public static BundleContext createBundleContext(String name, String bundleFilter, TinyBundle bundle) throws Exception {
return createBundleContext(name, bundleFilter, bundle, null, null);
}
public static BundleContext createBundleContext(String name, String bundleFilter,
TinyBundle bundle, TinyBundle configAdminInitBundle,
ClassLoader loader) throws Exception {
// ensure felix-connect stores bundles in an unique target directory
String uid = "" + System.currentTimeMillis();
String tempDir = "target/bundles/" + uid;
System.setProperty("org.osgi.framework.storage", tempDir);
createDirectory(tempDir);
// use another directory for the jar of the bundle as it cannot be in the same directory
// as it has a file lock during running the tests which will cause the temp dir to not be
// fully deleted between tests
createDirectory("target/test-bundles");
List bundles = new LinkedList<>();
if (configAdminInitBundle != null) {
String jarName = "configAdminInitBundle-" + uid + ".jar";
bundles.add(getBundleDescriptor("target/test-bundles/" + jarName, configAdminInitBundle));
}
if (bundle != null) {
String jarName = name.toLowerCase(Locale.ENGLISH) + "-" + uid + ".jar";
bundles.add(getBundleDescriptor("target/test-bundles/" + jarName, bundle));
}
List bundleDescriptors = getBundleDescriptors(bundleFilter, loader);
// let's put configadmin before blueprint.core
int idx1 = -1;
int idx2 = -1;
for (int i = 0; i < bundleDescriptors.size(); i++) {
BundleDescriptor bd = bundleDescriptors.get(i);
if ("org.apache.felix.configadmin".equals(bd.getHeaders().get("Bundle-SymbolicName"))) {
idx1 = i;
}
if ("org.apache.aries.blueprint.core".equals(bd.getHeaders().get("Bundle-SymbolicName"))) {
idx2 = i;
}
}
if (idx1 >= 0 && idx2 >= 0 && idx1 > idx2) {
bundleDescriptors.add(idx2, bundleDescriptors.remove(idx1));
}
// get the bundles
bundles.addAll(bundleDescriptors);
if (LOG.isDebugEnabled()) {
for (int i = 0; i < bundles.size(); i++) {
BundleDescriptor desc = bundles.get(i);
LOG.debug("Bundle #{} -> {}", i, desc);
}
}
// setup felix-connect to use our bundles
Map config = new HashMap<>();
config.put(PojoServiceRegistryFactory.BUNDLE_DESCRIPTORS, bundles);
// create pojorsr osgi service registry
PojoServiceRegistry reg = new PojoServiceRegistryFactoryImpl().newPojoServiceRegistry(config);
return reg.getBundleContext();
}
public static void disposeBundleContext(BundleContext bundleContext) throws BundleException {
try {
if (bundleContext != null) {
List bundles = new ArrayList<>();
bundles.addAll(Arrays.asList(bundleContext.getBundles()));
Collections.reverse(bundles);
for (Bundle bundle : bundles) {
LOG.debug("Stopping bundle {}", bundle);
bundle.stop();
}
}
} catch (Exception e) {
IllegalStateException ise = org.apache.camel.util.ObjectHelper.getException(IllegalStateException.class, e);
if (ise != null) {
// we dont care about illegal state exception as that may happen from OSGi
LOG.debug("Error during disposing BundleContext. This exception will be ignored.", e);
} else {
LOG.warn("Error during disposing BundleContext. This exception will be ignored.", e);
}
} finally {
String tempDir = System.clearProperty("org.osgi.framework.storage");
if (tempDir != null) {
LOG.info("Deleting work directory {}", tempDir);
deleteDirectory(tempDir);
}
}
}
// pick up persistent file configuration
@SuppressWarnings({"unchecked", "rawtypes"})
public static void setPersistentFileForConfigAdmin(BundleContext bundleContext, String pid,
String fileName, final Dictionary props,
String symbolicName, Set bpEvents,
boolean expectReload) throws IOException, InterruptedException {
if (pid != null) {
if (fileName == null) {
throw new IllegalArgumentException("The persistent file should not be null");
} else {
File load = new File(fileName);
LOG.debug("Loading properties from OSGi config admin file: {}", load);
org.apache.felix.utils.properties.Properties cfg = new org.apache.felix.utils.properties.Properties(load);
for (Object key : cfg.keySet()) {
props.put(key, cfg.get(key));
}
ConfigurationAdmin configAdmin = CamelBlueprintHelper
.getOsgiService(bundleContext, ConfigurationAdmin.class);
if (configAdmin != null) {
// ensure we update
// we *have to* use "null" as 2nd arg to have correct bundle location for Configuration object
final Configuration config = configAdmin.getConfiguration(pid, null);
LOG.info("Updating ConfigAdmin {} by overriding properties {}", config, props);
// we may have update and in consequence, BP container reload, let's wait for it to
// be CREATED again
if (expectReload) {
CamelBlueprintHelper.waitForBlueprintContainer(bpEvents, bundleContext, symbolicName, BlueprintEvent.CREATED, new Runnable() {
@Override
public void run() {
try {
config.update(props);
} catch (IOException e) {
throw new RuntimeException(e.getMessage(), e);
}
}
});
} else {
config.update(props);
}
}
}
}
}
public static T getOsgiService(BundleContext bundleContext, Class type, long timeout) {
return getOsgiService(bundleContext, type, null, timeout);
}
public static T getOsgiService(BundleContext bundleContext, Class type) {
return getOsgiService(bundleContext, type, null, DEFAULT_TIMEOUT);
}
public static T getOsgiService(BundleContext bundleContext, Class type, String filter) {
return getOsgiService(bundleContext, type, filter, DEFAULT_TIMEOUT);
}
public static T getOsgiService(BundleContext bundleContext, Class type, String filter, long timeout) {
ServiceTracker tracker;
try {
String flt;
if (filter != null) {
if (filter.startsWith("(")) {
flt = "(&(" + Constants.OBJECTCLASS + "=" + type.getName() + ")" + filter + ")";
} else {
flt = "(&(" + Constants.OBJECTCLASS + "=" + type.getName() + ")(" + filter + "))";
}
} else {
flt = "(" + Constants.OBJECTCLASS + "=" + type.getName() + ")";
}
Filter osgiFilter = FrameworkUtil.createFilter(flt);
tracker = new ServiceTracker<>(bundleContext, osgiFilter, null);
tracker.open(true);
// Note that the tracker is not closed to keep the reference
// This is buggy, as the service reference may change i think
Object svc = tracker.waitForService(timeout);
if (svc == null) {
Dictionary dic = bundleContext.getBundle().getHeaders();
LOG.warn("Test bundle headers: " + explode(dic));
for (ServiceReference ref : asCollection(bundleContext.getAllServiceReferences(null, null))) {
LOG.warn("ServiceReference: " + ref + ", bundle: " + ref.getBundle() + ", symbolicName: " + ref.getBundle().getSymbolicName());
}
for (ServiceReference ref : asCollection(bundleContext.getAllServiceReferences(null, flt))) {
LOG.warn("Filtered ServiceReference: " + ref + ", bundle: " + ref.getBundle() + ", symbolicName: " + ref.getBundle().getSymbolicName());
}
throw new RuntimeException("Gave up waiting for service " + flt);
}
return type.cast(svc);
} catch (InvalidSyntaxException e) {
throw new IllegalArgumentException("Invalid filter", e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
/**
* Synchronization method to wait for particular state of BlueprintContainer under test.
*/
public static void waitForBlueprintContainer(final Set eventHistory, BundleContext context,
final String symbolicName, final int bpEvent, final Runnable runAndWait)
throws InterruptedException {
final CountDownLatch latch = new CountDownLatch(1);
final Throwable[] pThrowable = new Throwable[] {null};
ServiceRegistration registration = context.registerService(BlueprintListener.class, new BlueprintListener() {
@Override
public void blueprintEvent(BlueprintEvent event) {
if (event.getBundle().getSymbolicName().equals(symbolicName)) {
if (event.getType() == bpEvent) {
// we skip events that we've already seen
// it works with BP container reloads if next CREATE state is at least 1ms after previous one
if (eventHistory == null || eventHistory.add(event.getTimestamp())) {
latch.countDown();
}
} else if (event.getType() == BlueprintEvent.FAILURE) {
// we didn't wait for FAILURE, but we got it - fail fast then
pThrowable[0] = event.getCause();
latch.countDown();
}
}
}
}, null);
if (runAndWait != null) {
runAndWait.run();
}
boolean found = latch.await(CamelBlueprintHelper.DEFAULT_TIMEOUT, TimeUnit.MILLISECONDS);
registration.unregister();
if (!found) {
throw new RuntimeException("Gave up waiting for BlueprintContainer from bundle \"" + symbolicName + "\"");
}
if (pThrowable[0] != null) {
throw new RuntimeException(pThrowable[0].getMessage(), pThrowable[0]);
}
}
protected static TinyBundle createConfigAdminInitBundle(String[]... configAdminPidFiles) throws IOException {
TinyBundle bundle = TinyBundles.bundle();
StringWriter configAdminInit = null;
for (String[] configAdminPidFile : configAdminPidFiles) {
if (configAdminPidFile == null) {
continue;
}
if (configAdminInit == null) {
configAdminInit = new StringWriter();
} else {
configAdminInit.append(',');
}
configAdminInit.append(configAdminPidFile[1]).append("=");
configAdminInit.append(new File(configAdminPidFile[0]).toURI().toString());
}
bundle.add(TestBundleActivator.class);
bundle.add(Util.class);
bundle.set("Manifest-Version", "2")
.set("Bundle-ManifestVersion", "2")
.set("Bundle-SymbolicName", "ConfigAdminInit")
.set("Bundle-Version", BUNDLE_VERSION)
.set("Bundle-Activator", TestBundleActivator.class.getName());
if (configAdminInit != null) {
bundle.set("X-Camel-Blueprint-ConfigAdmin-Init", configAdminInit.toString());
}
return bundle;
}
protected static TinyBundle createTestBundle(String name, String version, String descriptors) throws IOException {
TinyBundle bundle = TinyBundles.bundle();
for (URL url : getBlueprintDescriptors(descriptors)) {
LOG.info("Using Blueprint XML file: " + url.getFile());
bundle.add("OSGI-INF/blueprint/blueprint-" + url.getFile().replace("/", "-"), url);
}
bundle.set("Manifest-Version", "2")
.set("Bundle-ManifestVersion", "2")
.set("Bundle-SymbolicName", name)
.set("Bundle-Version", version);
return bundle;
}
/**
* Explode the dictionary into a , delimited list of key=value pairs.
*/
private static String explode(Dictionary dictionary) {
Enumeration keys = dictionary.keys();
StringBuilder result = new StringBuilder();
while (keys.hasMoreElements()) {
Object key = keys.nextElement();
result.append(String.format("%s=%s", key, dictionary.get(key)));
if (keys.hasMoreElements()) {
result.append(", ");
}
}
return result.toString();
}
/**
* create the directory
*
* @param file the directory to be created
*/
public static void createDirectory(String file) {
File dir = new File(file);
dir.mkdirs();
}
/**
* Recursively delete a directory, useful to zapping test data
*
* @param file the directory to be deleted
* @return false if error deleting directory
*/
public static boolean deleteDirectory(String file) {
return deleteDirectory(new File(file));
}
/**
* Recursively delete a directory, useful to zapping test data
*
* @param file the directory to be deleted
* @return false if error deleting directory
*/
public static boolean deleteDirectory(File file) {
int tries = 0;
int maxTries = 5;
boolean exists = true;
while (exists && (tries < maxTries)) {
recursivelyDeleteDirectory(file);
tries++;
exists = file.exists();
if (exists) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// Ignore
}
}
}
return !exists;
}
private static void recursivelyDeleteDirectory(File file) {
if (!file.exists()) {
return;
}
if (file.isDirectory()) {
File[] files = file.listFiles();
for (File child : files) {
recursivelyDeleteDirectory(child);
}
}
boolean success = file.delete();
if (!success) {
LOG.warn("Deletion of file: " + file.getAbsolutePath() + " failed");
}
}
/**
* Provides an iterable collection of references, even if the original array is null.
*/
private static Collection asCollection(ServiceReference[] references) {
return references == null ? new ArrayList<>(0) : Arrays.asList(references);
}
/**
* Gets list of bundle descriptors.
* @param bundleFilter Filter expression for OSGI bundles.
*
* @return List pointers to OSGi bundles.
* @throws Exception If looking up the bundles fails.
*/
private static List getBundleDescriptors(final String bundleFilter, ClassLoader loader) throws Exception {
return new ClasspathScanner().scanForBundles(bundleFilter, loader);
}
/**
* Gets the bundle descriptors as {@link URL} resources.
*
* @param descriptors the bundle descriptors, can be separated by comma
* @return the bundle descriptors.
* @throws FileNotFoundException is thrown if a bundle descriptor cannot be found
*/
public static Collection getBlueprintDescriptors(String descriptors) throws FileNotFoundException, MalformedURLException {
List answer = new ArrayList<>();
if (descriptors != null) {
// there may be more resources separated by comma
Iterator it = ObjectHelper.createIterator(descriptors);
while (it.hasNext()) {
String s = (String) it.next();
LOG.trace("Resource descriptor: {}", s);
// remove leading / to be able to load resource from the classpath
s = FileUtil.stripLeadingSeparator(s);
// if there is wildcards for *.xml then we need to find the urls from the package
if (s.endsWith("*.xml")) {
String packageName = s.substring(0, s.length() - 5);
// remove trailing / to be able to load resource from the classpath
Enumeration urls = org.apache.camel.util.ObjectHelper.loadResourcesAsURL(packageName);
while (urls.hasMoreElements()) {
URL url = urls.nextElement();
File dir = new File(url.getFile());
if (dir.isDirectory()) {
File[] files = dir.listFiles();
if (files != null) {
for (File file : files) {
if (file.isFile() && file.exists() && file.getName().endsWith(".xml")) {
String name = packageName + file.getName();
LOG.debug("Resolving resource: {}", name);
URL xmlUrl = org.apache.camel.util.ObjectHelper.loadResourceAsURL(name);
if (xmlUrl != null) {
answer.add(xmlUrl);
}
}
}
}
}
}
} else {
LOG.debug("Resolving resource: {}", s);
URL url = RESOLVER.loadResourceAsURL(s);
if (url == null) {
throw new FileNotFoundException("Resource " + s + " not found");
}
answer.add(url);
}
}
} else {
throw new IllegalArgumentException("No bundle descriptor configured. Override getBlueprintDescriptor() or getBlueprintDescriptors() method");
}
if (answer.isEmpty()) {
throw new IllegalArgumentException("Cannot find any resources in classpath from descriptor " + descriptors);
}
return answer;
}
private static BundleDescriptor getBundleDescriptor(String path, TinyBundle bundle) throws Exception {
File file = new File(path);
// tell the JVM its okay to delete this file on exit as its a temporary file
// the JVM may not successfully delete the file though
file.deleteOnExit();
FileOutputStream fos = new FileOutputStream(file, false);
InputStream is = bundle.build();
try {
IOHelper.copyAndCloseInput(is, fos);
} finally {
IOHelper.close(is, fos);
}
BundleDescriptor answer;
FileInputStream fis = null;
JarInputStream jis = null;
try {
fis = new FileInputStream(file);
jis = new JarInputStream(fis);
Map headers = new HashMap<>();
for (Map.Entry entry : jis.getManifest().getMainAttributes().entrySet()) {
headers.put(entry.getKey().toString(), entry.getValue().toString());
}
answer = new BundleDescriptor(
bundle.getClass().getClassLoader(),
"jar:" + file.toURI().toString() + "!/",
headers);
} finally {
IOHelper.close(jis, fis);
}
return answer;
}
/**
* Bundle activator that will be invoked in right time to set initial configadmin configuration
* for blueprint container.
*/
public static class TestBundleActivator implements BundleActivator {
@Override
public void start(BundleContext bundleContext) throws Exception {
final String configAdminInit = bundleContext.getBundle().getHeaders().get("X-Camel-Blueprint-ConfigAdmin-Init");
if (configAdminInit != null) {
final BundleContext sysContext = bundleContext.getBundle(0).getBundleContext();
// we are started before blueprint.core and felix.configadmin
// we are sure that felix.configadmin is started before blueprint.core
sysContext.addBundleListener(new SynchronousBundleListener() {
@Override
public void bundleChanged(BundleEvent event) {
if (event.getType() == BundleEvent.STARTED
&& "org.apache.felix.configadmin".equals(event.getBundle().getSymbolicName())) {
// configadmin should have already been started
ServiceReference sr = sysContext.getServiceReference("org.osgi.service.cm.ConfigurationAdmin");
if (sr != null && sysContext.getService(sr) != null) {
initializeConfigAdmin(sysContext, configAdminInit);
}
}
}
});
}
}
private void initializeConfigAdmin(BundleContext context, String configAdminInit) {
String[] pidFiles = configAdminInit.split(",");
for (String pidFile : pidFiles) {
String[] pf = pidFile.split("=");
try {
CamelBlueprintHelper.setPersistentFileForConfigAdmin(context, pf[0], new URI(pf[1]).getPath(),
new Properties(), null, null, false);
} catch (IOException | URISyntaxException e) {
throw new RuntimeException(e.getMessage(), e);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e.getMessage(), e);
}
}
}
@Override
public void stop(BundleContext bundleContext) throws Exception {
}
}
}