From 8c97275c55a083cab5057c7c40bc437f7647f44b Mon Sep 17 00:00:00 2001 From: Bob Kerns Date: Wed, 8 May 2013 01:06:53 -0700 Subject: [PATCH] LOG4J2-238 and Log472-159. OSGi coordination of API and Core, and search stack for bundle with config. --- api/pom.xml | 48 +++++++ .../java/org/apache/logging/log4j/LogManager.java | 11 ++ .../log4j/osgi/OSGiLoggerContextFactory.java | 150 +++++++++++++++++++++ .../apache/logging/log4j/osgi/package-info.java | 20 +++ core/pom.xml | 40 +++++- .../log4j/core/config/ConfigurationFactory.java | 65 ++++++--- .../log4j/core/impl/Log4jContextFactory.java | 11 +- .../apache/logging/log4j/core/osgi/Activator.java | 33 +++++ .../log4j/core/osgi/LoggerContextService.java | 62 +++++++++ .../log4j/core/osgi/OSGiBundleContextSelector.java | 29 ++++ .../logging/log4j/core/osgi/package-info.java | 20 +++ .../core/selector/ClassLoaderContextSelector.java | 14 +- pom.xml | 6 +- 13 files changed, 480 insertions(+), 29 deletions(-) create mode 100644 api/src/main/java/org/apache/logging/log4j/osgi/OSGiLoggerContextFactory.java create mode 100644 api/src/main/java/org/apache/logging/log4j/osgi/package-info.java create mode 100644 core/src/main/java/org/apache/logging/log4j/core/osgi/Activator.java create mode 100644 core/src/main/java/org/apache/logging/log4j/core/osgi/LoggerContextService.java create mode 100644 core/src/main/java/org/apache/logging/log4j/core/osgi/OSGiBundleContextSelector.java create mode 100644 core/src/main/java/org/apache/logging/log4j/core/osgi/package-info.java diff --git a/api/pom.xml b/api/pom.xml index b8e6ba1..acc7aae 100644 --- a/api/pom.xml +++ b/api/pom.xml @@ -45,7 +45,55 @@ junit test + + org.apache.felix + org.apache.felix.scr.annotations + 1.7.0 + + + org.osgi + core + provided + + + org.osgi + org.osgi.compendium + 4.3.0 + + + + + + org.apache.felix + maven-scr-plugin + 1.9.0 + + target/classes + + + + generate-scr-srcdescriptor + + scr + + + + + + org.apache.felix + maven-bundle-plugin + 2.3.7 + true + + + lazy + + + + + + diff --git a/api/src/main/java/org/apache/logging/log4j/LogManager.java b/api/src/main/java/org/apache/logging/log4j/LogManager.java index f8ac62d..42b7fc9 100644 --- a/api/src/main/java/org/apache/logging/log4j/LogManager.java +++ b/api/src/main/java/org/apache/logging/log4j/LogManager.java @@ -16,6 +16,7 @@ */ package org.apache.logging.log4j; +import java.lang.reflect.Method; import java.net.URI; import java.util.Formatter; import java.util.Iterator; @@ -69,6 +70,16 @@ public class LogManager { LOGGER.error("Unable to create configured LoggerContextFactory {}", factoryClass, ex); } } + + try { + Class cls = Class.forName("org.apache.logging.log4j.osgi.OSGiLoggerContextFactory"); + Method getInstance = cls.getMethod("getInstance"); + factory = (LoggerContextFactory) getInstance.invoke(null); + } catch (Exception e) { + LOGGER.info("Could not load OSGiLoggerContextFactory", e); + } catch (Error e) { + LOGGER.error("Could not load OSGiLoggerContextFactory", e); + } if (factory == null) { final SortedMap factories = new TreeMap(); diff --git a/api/src/main/java/org/apache/logging/log4j/osgi/OSGiLoggerContextFactory.java b/api/src/main/java/org/apache/logging/log4j/osgi/OSGiLoggerContextFactory.java new file mode 100644 index 0000000..6b68831 --- /dev/null +++ b/api/src/main/java/org/apache/logging/log4j/osgi/OSGiLoggerContextFactory.java @@ -0,0 +1,150 @@ +/* + * 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.logging.log4j.osgi; + +import java.net.URI; +import java.util.Comparator; +import java.util.SortedSet; +import java.util.TreeSet; + +import org.apache.felix.scr.annotations.Activate; +import org.apache.felix.scr.annotations.Component; +import org.apache.felix.scr.annotations.Deactivate; +import org.apache.felix.scr.annotations.Modified; +import org.apache.felix.scr.annotations.Reference; +import org.apache.felix.scr.annotations.ReferenceCardinality; +import org.apache.felix.scr.annotations.ReferencePolicy; +import org.apache.felix.scr.annotations.ReferenceStrategy; +import org.apache.logging.log4j.Logger; +import org.apache.logging.log4j.simple.SimpleLoggerContext; +import org.apache.logging.log4j.spi.LoggerContext; +import org.apache.logging.log4j.spi.LoggerContextFactory; +import org.apache.logging.log4j.status.StatusLogger; +import org.osgi.framework.ServiceReference; +import org.osgi.service.component.ComponentContext; + +@Component(name="Log42-API", immediate=true) +@Reference(referenceInterface=LoggerContextFactory.class, +name="LoggerContextFactory", +bind="registerContextFactory", unbind="unregisterContextFactory", +policy=ReferencePolicy.STATIC, +cardinality=ReferenceCardinality.MANDATORY_MULTIPLE, +strategy=ReferenceStrategy.EVENT) +public class OSGiLoggerContextFactory implements LoggerContextFactory { + private static final Logger LOGGER = StatusLogger.getLogger(); + public static final String SERVICE_ID = "service.id"; + public static final String SERVICE_RANKING = "service.ranking"; + private static class ServiceComparator implements Comparator { + private static long getLong(ServiceReference o, String key) { + Object val = o.getProperty(key); + if (val instanceof Long) { + return (Long)val; + } + return 0; + } + private static int getInt(ServiceReference o, String key) { + Object val = o.getProperty(key); + if (val instanceof Integer) { + return (Integer)val; + } + return 0; + } + @Override + public int compare(ServiceReference o1, ServiceReference o2) { + int rank1 = getInt(o1, SERVICE_RANKING); + int rank2 = getInt(o2, SERVICE_RANKING); + if (rank1 < rank2) return -1; + if (rank1 > rank2) return 1; + long id1 = getLong(o1, SERVICE_ID); + long id2 = getLong(o2, SERVICE_ID); + if (id1 < id2) return -1; + if (id1 > id2) return 1; + return 0; + } + } + + private final SortedSet _factories = new TreeSet(new ServiceComparator()); + + private ComponentContext _componentContext; + + private static LoggerContextFactory _instance; + + public static LoggerContextFactory getInstance() { + return _instance; + } + + public void registerContextFactory(ServiceReference ref) throws Exception { + LOGGER.debug("Registering " + ref); + _factories.add(ref); + } + + public void unregisterContextFactory(ServiceReference ref) throws Exception { + LOGGER.debug("Unregistering " + ref); + _factories.remove(ref); + } + + @Activate + public void start(ComponentContext ctx) { + LOGGER.debug("Starting " + this); + _componentContext = ctx; + _instance = this; + } + + @Modified + public void update(ComponentContext ctx) { + LOGGER.debug("Updating " + this); + _componentContext = ctx; + } + + @Deactivate + public void stop(ComponentContext ctx) { + LOGGER.debug("Stopping " + this); + _componentContext = null; + _instance = null; + } + + @Override + public LoggerContext getContext(String fqcn, ClassLoader loader, boolean currentContext) { + LoggerContextFactory factory = getFactory(); + if (factory == null) { + LOGGER.warn("Using SimpleLoggerContext"); + return new SimpleLoggerContext(); + } + return factory.getContext(fqcn, loader, currentContext); + } + + private LoggerContextFactory getFactory() { + if (_componentContext == null) { + return null; + } + if (_factories.isEmpty()) { + return null; + } + ServiceReference f = _factories.first(); + LoggerContextFactory factory = (LoggerContextFactory)_componentContext.locateService("LoggerContextFactory", f); + return factory; + } + + @Override + public LoggerContext getContext(String fqcn, ClassLoader loader, boolean currentContext, URI configLocation) { + LoggerContextFactory factory = getFactory(); + if (factory == null) { + return new SimpleLoggerContext(); + } + return factory.getContext(fqcn, loader, currentContext, configLocation); + } +} diff --git a/api/src/main/java/org/apache/logging/log4j/osgi/package-info.java b/api/src/main/java/org/apache/logging/log4j/osgi/package-info.java new file mode 100644 index 0000000..9549cec --- /dev/null +++ b/api/src/main/java/org/apache/logging/log4j/osgi/package-info.java @@ -0,0 +1,20 @@ +/* + * 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. + */ +/** + * Glue for integrating into OSGi environments. + */ +package org.apache.logging.log4j.osgi; diff --git a/core/pom.xml b/core/pom.xml index 7ae0b20..74d8725 100644 --- a/core/pom.xml +++ b/core/pom.xml @@ -120,6 +120,16 @@ mail true + + org.apache.felix + org.apache.felix.scr.annotations + 1.7.0 + + + org.osgi + org.osgi.compendium + 4.3.0 + @@ -154,6 +164,21 @@ + org.apache.felix + maven-scr-plugin + 1.9.0 + + target/classes + + + + generate-scr-srcdescriptor + + scr + + + + org.apache.felix maven-bundle-plugin @@ -165,20 +190,24 @@ true - true + false target/osgi + - - <_nouses>true + + <_nouses>false <_removeheaders>JAVA_1_3_HOME,JAVA_1_4_HOME,JAVA_1_5_HOME,JAVA_1_6_HOME,JAVA_1_7_HOME ${osgi.symbolicName} ${osgi.export} ${osgi.private} - ${osgi.import} + com.lmax.disruptor*;resolution:=optional,sun.misc;resolution:=optional,com.sun.tools.jsconsole;resolution:=optional,org.codehaus.jackson*;resolution:=optional,* ${osgi.dynamicImport} + org.apache.logging.log4j.core.osgi.Activator + lazy ${project.url} - org.apache.commons.log4j-api;bundle-version=${project.version.osgi} + target/scr-plugin-generated/**, + {maven-resources} @@ -203,6 +232,7 @@ + diff --git a/core/src/main/java/org/apache/logging/log4j/core/config/ConfigurationFactory.java b/core/src/main/java/org/apache/logging/log4j/core/config/ConfigurationFactory.java index 91d2840..5f1cdb6 100644 --- a/core/src/main/java/org/apache/logging/log4j/core/config/ConfigurationFactory.java +++ b/core/src/main/java/org/apache/logging/log4j/core/config/ConfigurationFactory.java @@ -33,8 +33,14 @@ import java.net.MalformedURLException; import java.net.URI; import java.net.URISyntaxException; import java.net.URL; +import java.security.AccessControlContext; +import java.security.AccessController; +import java.security.PrivilegedAction; import java.util.ArrayList; +import java.util.Collection; import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Set; @@ -387,27 +393,56 @@ public abstract class ConfigurationFactory { } return config != null ? config : new DefaultConfiguration(); } + + // TODO: This is not 100% compatible with existing behavior. It needs to be be driven by the + // LoggerContextFactory, but how to pass this info in? Investigate. + private Collection getLoaders() { + // Subclass SecurityManager to get access to the getClassContext() method. + // We never install it, so we don't need to worry about whether there's an existing security + // manager or permissions. + class GetLoaders extends SecurityManager implements PrivilegedAction> { + @Override + public Collection run() { + Set loaders = new LinkedHashSet(); + try { + ClassLoader contextLoader = Thread.currentThread().getContextClassLoader(); + if (contextLoader != null) { + loaders.add(contextLoader); + } + } catch (SecurityException ex) { + // Not an option... + } + loaders.add(this.getClass().getClassLoader()); + for (Class cls : getClassContext()) { + loaders.add(cls.getClassLoader()); + } + return loaders; + } + } + return AccessController.doPrivileged(new GetLoaders()); + } private Configuration getConfiguration(final boolean isTest, final String name) { final boolean named = name != null && name.length() > 0; - final ClassLoader loader = this.getClass().getClassLoader(); - for (final ConfigurationFactory factory : factories) { - String configName; - final String prefix = isTest ? TEST_PREFIX : DEFAULT_PREFIX; - final String [] types = factory.getSupportedTypes(); - if (types == null) { - continue; - } - - for (final String suffix : types) { - if (suffix.equals("*")) { + for (ClassLoader loader : getLoaders()) { + for (final ConfigurationFactory factory : factories) { + String configName; + final String prefix = isTest ? TEST_PREFIX : DEFAULT_PREFIX; + final String [] types = factory.getSupportedTypes(); + if (types == null) { continue; } - configName = named ? prefix + name + suffix : prefix + suffix; - final ConfigurationSource source = getInputFromResource(configName, loader); - if (source != null) { - return factory.getConfiguration(source); + for (final String suffix : types) { + if (suffix.equals("*")) { + continue; + } + configName = named ? prefix + name + suffix : prefix + suffix; + + final ConfigurationSource source = getInputFromResource(configName, loader); + if (source != null) { + return factory.getConfiguration(source); + } } } } diff --git a/core/src/main/java/org/apache/logging/log4j/core/impl/Log4jContextFactory.java b/core/src/main/java/org/apache/logging/log4j/core/impl/Log4jContextFactory.java index b220a01..1dfab22 100644 --- a/core/src/main/java/org/apache/logging/log4j/core/impl/Log4jContextFactory.java +++ b/core/src/main/java/org/apache/logging/log4j/core/impl/Log4jContextFactory.java @@ -53,7 +53,7 @@ public class Log4jContextFactory implements LoggerContextFactory { } } if (selector == null) { - selector = new ClassLoaderContextSelector(); + selector = createDefaultSelector(); } try { Server.registerMBeans(selector); @@ -63,6 +63,15 @@ public class Log4jContextFactory implements LoggerContextFactory { } /** + * Called to create a {@link ContextSelector} if none is successfully specified via the {@link Constants#LOG4J_CONTEXT_SELECTOR} + * property + * @return the {@link ContextSelector} to use + */ + protected ContextSelector createDefaultSelector() { + return new ClassLoaderContextSelector(); + } + + /** * Returns the ContextSelector. * @return The ContextSelector. */ diff --git a/core/src/main/java/org/apache/logging/log4j/core/osgi/Activator.java b/core/src/main/java/org/apache/logging/log4j/core/osgi/Activator.java new file mode 100644 index 0000000..5a05fe8 --- /dev/null +++ b/core/src/main/java/org/apache/logging/log4j/core/osgi/Activator.java @@ -0,0 +1,33 @@ +/* + * 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.logging.log4j.core.osgi; + +import org.osgi.framework.BundleActivator; +import org.osgi.framework.BundleContext; + +public class Activator implements BundleActivator { + + @Override + public void start(BundleContext context) throws Exception { + + } + + @Override + public void stop(BundleContext context) throws Exception { + + } +} diff --git a/core/src/main/java/org/apache/logging/log4j/core/osgi/LoggerContextService.java b/core/src/main/java/org/apache/logging/log4j/core/osgi/LoggerContextService.java new file mode 100644 index 0000000..d175a12 --- /dev/null +++ b/core/src/main/java/org/apache/logging/log4j/core/osgi/LoggerContextService.java @@ -0,0 +1,62 @@ +/* + * 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.logging.log4j.core.osgi; + +import org.apache.felix.scr.annotations.Activate; +import org.apache.felix.scr.annotations.Component; +import org.apache.felix.scr.annotations.ConfigurationPolicy; +import org.apache.felix.scr.annotations.Deactivate; +import org.apache.felix.scr.annotations.Modified; +import org.apache.felix.scr.annotations.Property; +import org.apache.felix.scr.annotations.Service; +import org.apache.logging.log4j.core.impl.Log4jContextFactory; +import org.apache.logging.log4j.core.selector.ContextSelector; +import org.apache.logging.log4j.status.StatusLogger; +import org.osgi.service.component.ComponentContext; + +@Component(name="log4j2", immediate=true, enabled=true, policy=ConfigurationPolicy.IGNORE) +@Service(org.apache.logging.log4j.spi.LoggerContextFactory.class) +public class LoggerContextService extends Log4jContextFactory implements org.apache.logging.log4j.spi.LoggerContextFactory { + @Property(intValue=10) + public static final String SERVICE_RANKING = "service.ranking"; + @SuppressWarnings("unused") + private ComponentContext _componentContext; + private static final StatusLogger LOGGER = StatusLogger.getLogger(); + + @Activate + public void start(ComponentContext ctx) { + LOGGER.debug("Starting Log4J OSGI service"); + _componentContext = ctx; + } + + @Modified + public void update(ComponentContext ctx) { + LOGGER.debug("Updating Log4J OSGI service"); + _componentContext = ctx; + } + + @Deactivate + public void stop(ComponentContext ctx) { + LOGGER.debug("Stopping Log4J OSGI service"); + _componentContext = null; + } + + @Override + protected ContextSelector createDefaultSelector() { + return new OSGiBundleContextSelector(); + } +} diff --git a/core/src/main/java/org/apache/logging/log4j/core/osgi/OSGiBundleContextSelector.java b/core/src/main/java/org/apache/logging/log4j/core/osgi/OSGiBundleContextSelector.java new file mode 100644 index 0000000..e83db2d --- /dev/null +++ b/core/src/main/java/org/apache/logging/log4j/core/osgi/OSGiBundleContextSelector.java @@ -0,0 +1,29 @@ +/* + * 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.logging.log4j.core.osgi; + +import org.apache.logging.log4j.core.selector.ClassLoaderContextSelector; +import org.osgi.framework.BundleReference; + +public class OSGiBundleContextSelector extends ClassLoaderContextSelector { + protected String nameContext(ClassLoader loader) { + if (loader instanceof BundleReference) { + return ((BundleReference) loader).getBundle().getSymbolicName(); + } + return String.valueOf(loader); + } +} diff --git a/core/src/main/java/org/apache/logging/log4j/core/osgi/package-info.java b/core/src/main/java/org/apache/logging/log4j/core/osgi/package-info.java new file mode 100644 index 0000000..d5602cb --- /dev/null +++ b/core/src/main/java/org/apache/logging/log4j/core/osgi/package-info.java @@ -0,0 +1,20 @@ +/* + * 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. + */ +/** + * Glue to integrate into OSGi environments. + */ +package org.apache.logging.log4j.core.osgi; diff --git a/core/src/main/java/org/apache/logging/log4j/core/selector/ClassLoaderContextSelector.java b/core/src/main/java/org/apache/logging/log4j/core/selector/ClassLoaderContextSelector.java index 71cd327..5415a15 100644 --- a/core/src/main/java/org/apache/logging/log4j/core/selector/ClassLoaderContextSelector.java +++ b/core/src/main/java/org/apache/logging/log4j/core/selector/ClassLoaderContextSelector.java @@ -55,7 +55,7 @@ public class ClassLoaderContextSelector implements ContextSelector { private static final StatusLogger LOGGER = StatusLogger.getLogger(); - private static final ConcurrentMap>> CONTEXT_MAP = + protected static final ConcurrentMap>> CONTEXT_MAP = new ConcurrentHashMap>>(); static { @@ -144,7 +144,7 @@ public class ClassLoaderContextSelector implements ContextSelector { for (final Map.Entry>> entry : CONTEXT_MAP.entrySet()) { final LoggerContext ctx = entry.getValue().get().get(); if (ctx == context) { - CONTEXT_MAP.remove(entry.getKey()); + CONTEXT_MAP.remove(entry.getKey(), entry.getValue()); } } } @@ -162,14 +162,14 @@ public class ClassLoaderContextSelector implements ContextSelector { } private LoggerContext locateContext(final ClassLoader loader, final URI configLocation) { - final String name = loader.toString(); + final String name = nameContext(loader); AtomicReference> ref = CONTEXT_MAP.get(name); if (ref == null) { if (configLocation == null) { ClassLoader parent = loader.getParent(); while (parent != null) { - ref = CONTEXT_MAP.get(parent.toString()); + ref = CONTEXT_MAP.get(nameContext(parent)); if (ref != null) { final WeakReference r = ref.get(); LoggerContext ctx = r.get(); @@ -201,7 +201,7 @@ public class ClassLoaderContextSelector implements ContextSelector { final AtomicReference> r = new AtomicReference>(); r.set(new WeakReference(ctx)); - CONTEXT_MAP.putIfAbsent(loader.toString(), r); + CONTEXT_MAP.putIfAbsent(nameContext(loader), r); ctx = CONTEXT_MAP.get(name).get().get(); return ctx; } else { @@ -216,6 +216,10 @@ public class ClassLoaderContextSelector implements ContextSelector { } } + protected String nameContext(final ClassLoader loader) { + return loader.toString(); + } + private static void setupCallerCheck() { try { final ClassLoader loader = Loader.getClassLoader(); diff --git a/pom.xml b/pom.xml index 428e446..f4063f8 100644 --- a/pom.xml +++ b/pom.xml @@ -454,11 +454,11 @@ true - true + false target/osgi - - <_nouses>true + + <_nouses>false <_removeheaders>JAVA_1_3_HOME,JAVA_1_4_HOME,JAVA_1_5_HOME,JAVA_1_6_HOME,JAVA_1_7_HOME ${osgi.symbolicName} -- 1.8.0.msysgit.0