You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@felix.apache.org by tj...@apache.org on 2020/11/20 20:24:30 UTC
[felix-dev] branch master updated (5758834 -> 462bfe2)
This is an automated email from the ASF dual-hosted git repository.
tjwatson pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/felix-dev.git.
from 5758834 FELIX-6308 : Revert changes
new 4c826f0 Format according to the rest of SCR codebase
new 462bfe2 FELIX-6361 - Avoid IllegalArgumentException for calls to getLogger
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../apache/felix/scr/impl/logger/BundleLogger.java | 6 +-
.../felix/scr/impl/logger/ComponentLogger.java | 5 +-
.../felix/scr/impl/logger/ExtLogManager.java | 77 +--
.../felix/scr/impl/logger/InternalLogger.java | 152 +++---
.../apache/felix/scr/impl/logger/LogManager.java | 422 ++++++++-------
.../felix/scr/impl/logger/ScrLogManager.java | 570 +++++++++++----------
.../apache/felix/scr/impl/logger/ScrLogger.java | 19 +-
7 files changed, 690 insertions(+), 561 deletions(-)
[felix-dev] 01/02: Format according to the rest of SCR codebase
Posted by tj...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
tjwatson pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/felix-dev.git
commit 4c826f08b01a28c9abad111a410d2381288c6741
Author: Thomas Watson <tj...@us.ibm.com>
AuthorDate: Fri Nov 20 09:06:56 2020 -0600
Format according to the rest of SCR codebase
---
.../apache/felix/scr/impl/logger/BundleLogger.java | 6 +-
.../felix/scr/impl/logger/ComponentLogger.java | 5 +-
.../felix/scr/impl/logger/ExtLogManager.java | 77 +--
.../felix/scr/impl/logger/InternalLogger.java | 152 +++---
.../apache/felix/scr/impl/logger/LogManager.java | 408 ++++++++-------
.../felix/scr/impl/logger/ScrLogManager.java | 570 +++++++++++----------
.../apache/felix/scr/impl/logger/ScrLogger.java | 19 +-
7 files changed, 676 insertions(+), 561 deletions(-)
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/BundleLogger.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/BundleLogger.java
index 6f9c6c2..6e6d652 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/BundleLogger.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/logger/BundleLogger.java
@@ -25,7 +25,9 @@ import org.osgi.framework.Bundle;
* an extended bundle. This avoids that all clients doing logging on behalf of
* a component bundle need to pass in things like {@code BundleContext}.
*/
-public interface BundleLogger extends InternalLogger {
+public interface BundleLogger extends InternalLogger
+{
- ComponentLogger component(Bundle m_bundle, String implementationClassName, String name);
+ ComponentLogger component(Bundle m_bundle, String implementationClassName,
+ String name);
}
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/ComponentLogger.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/ComponentLogger.java
index facf595..8d86ee4 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/ComponentLogger.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/logger/ComponentLogger.java
@@ -23,6 +23,7 @@ package org.apache.felix.scr.impl.logger;
* This avoids avoids that all clients doing logging on behalf of a component need to
* pass in things like {@code ComponentMetadata} or the component Id.
*/
-public interface ComponentLogger extends InternalLogger {
- void setComponentId(long m_componentId);
+public interface ComponentLogger extends InternalLogger
+{
+ void setComponentId(long m_componentId);
}
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/ExtLogManager.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/ExtLogManager.java
index 1752987..759d63d 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/ExtLogManager.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/logger/ExtLogManager.java
@@ -35,45 +35,54 @@ import org.osgi.framework.BundleContext;
* the bundle symbolic name + "." + component name
* </ul>
*/
-class ExtLogManager extends ScrLogManager {
- public static String SCR_LOGGER_NAME = "org.apache.felix.scr.impl";
- public static String SCR_LOGGER_PREFIX = "org.apache.felix.scr.";
- private final Bundle bundle;
+class ExtLogManager extends ScrLogManager
+{
+ public static String SCR_LOGGER_NAME = "org.apache.felix.scr.impl";
+ public static String SCR_LOGGER_PREFIX = "org.apache.felix.scr.";
+ private final Bundle bundle;
- ExtLogManager(BundleContext context, ScrConfiguration config) {
- super(context, config);
- this.bundle = context.getBundle();
- }
+ ExtLogManager(BundleContext context, ScrConfiguration config)
+ {
+ super(context, config);
+ this.bundle = context.getBundle();
+ }
- @Override
- public ScrLogger scr() {
- return getLogger(bundle, SCR_LOGGER_NAME, ScrLoggerFacade.class);
- }
+ @Override
+ public ScrLogger scr()
+ {
+ return getLogger(bundle, SCR_LOGGER_NAME, ScrLoggerFacade.class);
+ }
- @Override
- public BundleLogger bundle(Bundle bundle) {
- return getLogger(bundle, SCR_LOGGER_PREFIX.concat(bundle.getSymbolicName()), ScrLoggerFacade.class);
- }
+ @Override
+ public BundleLogger bundle(Bundle bundle)
+ {
+ return getLogger(bundle, SCR_LOGGER_PREFIX.concat(bundle.getSymbolicName()),
+ ScrLoggerFacade.class);
+ }
- @Override
- public ComponentLogger component(Bundle bundle, String implementationClass, String componentName) {
+ @Override
+ public ComponentLogger component(Bundle bundle, String implementationClass,
+ String componentName)
+ {
- assert bundle != null;
- assert bundle.getSymbolicName() != null : "scr requires recent bundles";
- assert implementationClass != null;
- assert componentName != null;
+ assert bundle != null;
+ assert bundle.getSymbolicName() != null : "scr requires recent bundles";
+ assert implementationClass != null;
+ assert componentName != null;
- String loggerName = SCR_LOGGER_PREFIX.concat(bundle.getSymbolicName()).concat(".").concat(componentName);
- ScrLoggerFacade logger = getLogger(bundle, loggerName, ScrLoggerFacade.class);
- logger.setPrefix("["+componentName+"]");
- return logger;
- }
+ String loggerName = SCR_LOGGER_PREFIX.concat(bundle.getSymbolicName()).concat(
+ ".").concat(componentName);
+ ScrLoggerFacade logger = getLogger(bundle, loggerName, ScrLoggerFacade.class);
+ logger.setPrefix("[" + componentName + "]");
+ return logger;
+ }
- String componentPrefix(ScrLoggerFacade slf, long id) {
- assert slf.prefix != null;
- if ( slf.prefix.indexOf(')')<0)
- return slf.prefix.replace("]", "(" + id + ")]");
- else
- return slf.prefix;
- }
+ String componentPrefix(ScrLoggerFacade slf, long id)
+ {
+ assert slf.prefix != null;
+ if (slf.prefix.indexOf(')') < 0)
+ return slf.prefix.replace("]", "(" + id + ")]");
+ else
+ return slf.prefix;
+ }
}
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/InternalLogger.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/InternalLogger.java
index 4eca75f..a4851ce 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/InternalLogger.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/logger/InternalLogger.java
@@ -28,83 +28,91 @@ import org.osgi.service.log.admin.LoggerAdmin;
* this package, it could be private. However, then Level should be standalone,
* which would change most files. So minimize the code change, it is kept public.
*/
-public interface InternalLogger {
- /**
- * The level to log. This is aligned with the OSGi LogLevel
- */
- public enum Level {
- AUDIT {
- boolean err() {
- return true;
- }
- },
- ERROR {
- boolean err() {
- return true;
- }
- },
- WARN, INFO, DEBUG, TRACE;
+public interface InternalLogger
+{
+ /**
+ * The level to log. This is aligned with the OSGi LogLevel
+ */
+ public enum Level
+ {
+ AUDIT
+ {
+ boolean err()
+ {
+ return true;
+ }
+ },
+ ERROR
+ {
+ boolean err()
+ {
+ return true;
+ }
+ },
+ WARN, INFO, DEBUG, TRACE;
- /**
- * Check if this log level is higher or the same of the other level.
- *
- * @param other
- * the other level
- * @return true if the level other should be logged
- */
- boolean implies(Level other) {
- return ordinal() >= other.ordinal();
- }
+ /**
+ * Check if this log level is higher or the same of the other level.
+ *
+ * @param other
+ * the other level
+ * @return true if the level other should be logged
+ */
+ boolean implies(Level other)
+ {
+ return ordinal() >= other.ordinal();
+ }
- boolean err() {
- return false;
- }
+ boolean err()
+ {
+ return false;
+ }
- }
+ }
- /**
- * Logs the message to an appropriate OSGi logger. If not such logger can be
- * found then it will log to stderr for ERROR & AUDIT messages and stdout
- * for other messages
- *
- * @param level
- * only log when this level is implied by the current log
- * level
- * @param message
- * the message to log
- * @param ex
- * a Throwable or null
- */
- void log(Level level, String message, Throwable ex);
+ /**
+ * Logs the message to an appropriate OSGi logger. If not such logger can be
+ * found then it will log to stderr for ERROR & AUDIT messages and stdout
+ * for other messages
+ *
+ * @param level
+ * only log when this level is implied by the current log
+ * level
+ * @param message
+ * the message to log
+ * @param ex
+ * a Throwable or null
+ */
+ void log(Level level, String message, Throwable ex);
- /**
- * Formats the message using the {@link MessageFormat} class, i.e. with {}
- * place holders for the args. It then calls
- * {@link #log(Level, String, Throwable)}.
- *
- * @param level
- * only log when this level is implied by the current log
- * level
- * @param message
- * the message to log
- * @param ex
- * a Throwable or null
- * @param args
- * the arguments to the {@link MessageFormat} formatting
- */
- void log(Level level, String message, Throwable ex, Object... args);
+ /**
+ * Formats the message using the {@link MessageFormat} class, i.e. with {}
+ * place holders for the args. It then calls
+ * {@link #log(Level, String, Throwable)}.
+ *
+ * @param level
+ * only log when this level is implied by the current log
+ * level
+ * @param message
+ * the message to log
+ * @param ex
+ * a Throwable or null
+ * @param args
+ * the arguments to the {@link MessageFormat} formatting
+ */
+ void log(Level level, String message, Throwable ex, Object... args);
- /**
- * Answer true if the current logging level is enabled for the given level.
- * For stdout/stderr fallback the logging level is defined by the
- * {@link ScrConfiguration#getLogLevel()}. If there is an OSGi logger
- * available then the logger name will define the log level via
- * {@link LoggerAdmin}.
- *
- * @param level
- * the level to check
- * @return true if the given log level is enabled
- */
- boolean isLogEnabled(Level level);
+ /**
+ * Answer true if the current logging level is enabled for the given level.
+ * For stdout/stderr fallback the logging level is defined by the
+ * {@link ScrConfiguration#getLogLevel()}. If there is an OSGi logger
+ * available then the logger name will define the log level via
+ * {@link LoggerAdmin}.
+ *
+ * @param level
+ * the level to check
+ * @return true if the given log level is enabled
+ */
+ boolean isLogEnabled(Level level);
}
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/LogManager.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/LogManager.java
index d5cd008..a5ccd34 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/LogManager.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/logger/LogManager.java
@@ -45,192 +45,232 @@ import org.osgi.util.tracker.ServiceTracker;
* The LogDomain represents every bundle. Per LogDomain, we keep the facades. If the factory goes,
* we reset the facades.
*/
-class LogManager extends ServiceTracker<Object, Object> implements BundleListener {
+class LogManager extends ServiceTracker<Object, Object> implements BundleListener
+{
private static final String LOGGER_FACTORY_CLASS_NAME = "org.osgi.service.log.LoggerFactory";
- final BundleContext scrContext;
- final AtomicBoolean closed = new AtomicBoolean(false);
-
- /*
- * Locks access to guarded fields
- */
- class Lock {
- final Map<Bundle, LogDomain> domains = new HashMap<>();
- int trackingCount;
- Object factory;
- int ranking=0;
-
- synchronized LogDomain getLogDomain(Bundle bundle) {
- LogDomain domain = domains.get(bundle);
- if (domain == null) {
- domain = new LogDomain(bundle);
- domains.put(bundle, domain);
- }
- return domain;
- }
-
- synchronized void removedFactory(Object service) {
- if (this.factory == service) {
- this.factory = null;
- reset();
- }
- }
-
- synchronized void setFactory(int ranking, Object service) {
- if (this.factory == null) {
- this.factory = service;
- this.ranking = ranking;
- } else if (this.ranking < ranking) {
- this.factory = service;
- this.ranking = ranking;
- reset();
- }
- }
-
- synchronized void reset() {
- for (LogDomain domain : domains.values()) {
- domain.reset();
- }
- }
-
- synchronized Object getLogger(LoggerFacade facade, Bundle bundle, String name) {
- if (factory == null)
- return facade.logger = null;
- else
- return facade.logger = ((LoggerFactory) factory).getLogger(bundle, name, Logger.class);
- }
-
- synchronized LogDomain remove(Bundle bundle) {
- return domains.remove(bundle);
- }
-
- synchronized void close() {
- reset();
- domains.clear();
- }
-
- }
-
- final Lock lock = new Lock();
-
- LogManager(BundleContext context) {
- super(context, LOGGER_FACTORY_CLASS_NAME, null);
- this.scrContext = context;
- scrContext.addBundleListener(this);
- }
-
- @Override
- public Object addingService(ServiceReference<Object> reference) {
- Object service = super.addingService(reference);
- Integer ranking = (Integer) reference.getProperty(Constants.SERVICE_RANKING);
- if (ranking == null)
- ranking = 0;
- lock.setFactory(ranking, service);
- return service;
- }
-
- @Override
- public void removedService(ServiceReference<Object> reference, Object service) {
- super.removedService(reference, service);
- lock.removedFactory(service);
- }
-
- <T> T getLogger(Bundle bundle, String name, Class<T> type) {
- return type.cast(lock.getLogDomain(bundle).getLogger(name));
- }
-
- @SuppressWarnings("resource")
- @Override
- public void bundleChanged(BundleEvent event) {
- if (event.getType() == BundleEvent.STOPPED && !closed.get()) {
- LogDomain domain = lock.remove(event.getBundle());
- if (domain != null) {
- domain.close();
- }
- }
- }
-
- /*
- * Tracks a bundle's LoggerFactory service
- */
- class LogDomain
- implements Closeable {
-
- private final Bundle bundle;
- private final Set<LoggerFacade> facades = new HashSet<>();
-
- LogDomain(Bundle bundle) {
- this.bundle = bundle;
- }
-
- private void reset() {
- synchronized (facades) {
- for (LoggerFacade facade : facades) {
- facade.reset();
- }
- }
- }
-
- LoggerFacade getLogger(String name) {
- LoggerFacade facade = createLoggerFacade(this, name);
- synchronized (facades) {
- facades.add(facade);
- }
- return facade;
- }
-
- @Override
- public void close() {
- reset();
- }
-
- }
-
- class LoggerFacade {
- private final String name;
- private final LogDomain domain;
- volatile Object logger;
- volatile String prefix;
-
- LoggerFacade(LogDomain logDomain, String name) {
- this.domain = logDomain;
- this.name = name;
- }
-
- void reset() {
- logger = null;
- }
-
- Object getLogger() {
- Object l = this.logger;
- if (l == null) {
- l = lock.getLogger(this, domain.bundle, name);
- }
- return l;
- }
-
- Bundle getBundle() {
- return domain.bundle;
- }
-
- String getName() {
- return name;
- }
-
- }
-
- public void close() {
- if (closed.compareAndSet(false, true)) {
- lock.close();
- super.close();
- this.context.removeBundleListener(this);
- }
- }
-
- LoggerFacade createLoggerFacade(LogDomain logDomain, String name) {
- assert !closed.get();
- return new LoggerFacade(logDomain, name);
- }
+ final BundleContext scrContext;
+ final AtomicBoolean closed = new AtomicBoolean(false);
+
+ /*
+ * Locks access to guarded fields
+ */
+ class Lock
+ {
+ final Map<Bundle, LogDomain> domains = new HashMap<>();
+ int trackingCount;
+ Object factory;
+ int ranking = 0;
+
+ synchronized LogDomain getLogDomain(Bundle bundle)
+ {
+ LogDomain domain = domains.get(bundle);
+ if (domain == null)
+ {
+ domain = new LogDomain(bundle);
+ domains.put(bundle, domain);
+ }
+ return domain;
+ }
+
+ synchronized void removedFactory(Object service)
+ {
+ if (this.factory == service)
+ {
+ this.factory = null;
+ reset();
+ }
+ }
+
+ synchronized void setFactory(int ranking, Object service)
+ {
+ if (this.factory == null)
+ {
+ this.factory = service;
+ this.ranking = ranking;
+ }
+ else if (this.ranking < ranking)
+ {
+ this.factory = service;
+ this.ranking = ranking;
+ reset();
+ }
+ }
+
+ synchronized void reset()
+ {
+ for (LogDomain domain : domains.values())
+ {
+ domain.reset();
+ }
+ }
+
+ synchronized Object getLogger(LoggerFacade facade, Bundle bundle, String name)
+ {
+ if (factory == null)
+ return facade.logger = null;
+ else
+ return facade.logger = ((LoggerFactory) factory).getLogger(bundle, name,
+ Logger.class);
+ }
+
+ synchronized LogDomain remove(Bundle bundle)
+ {
+ return domains.remove(bundle);
+ }
+
+ synchronized void close()
+ {
+ reset();
+ domains.clear();
+ }
+
+ }
+
+ final Lock lock = new Lock();
+
+ LogManager(BundleContext context)
+ {
+ super(context, LOGGER_FACTORY_CLASS_NAME, null);
+ this.scrContext = context;
+ scrContext.addBundleListener(this);
+ }
+
+ @Override
+ public Object addingService(ServiceReference<Object> reference)
+ {
+ Object service = super.addingService(reference);
+ Integer ranking = (Integer) reference.getProperty(Constants.SERVICE_RANKING);
+ if (ranking == null)
+ ranking = 0;
+ lock.setFactory(ranking, service);
+ return service;
+ }
+
+ @Override
+ public void removedService(ServiceReference<Object> reference, Object service)
+ {
+ super.removedService(reference, service);
+ lock.removedFactory(service);
+ }
+
+ <T> T getLogger(Bundle bundle, String name, Class<T> type)
+ {
+ return type.cast(lock.getLogDomain(bundle).getLogger(name));
+ }
+
+ @SuppressWarnings("resource")
+ @Override
+ public void bundleChanged(BundleEvent event)
+ {
+ if (event.getType() == BundleEvent.STOPPED && !closed.get())
+ {
+ LogDomain domain = lock.remove(event.getBundle());
+ if (domain != null)
+ {
+ domain.close();
+ }
+ }
+ }
+
+ /*
+ * Tracks a bundle's LoggerFactory service
+ */
+ class LogDomain implements Closeable
+ {
+
+ private final Bundle bundle;
+ private final Set<LoggerFacade> facades = new HashSet<>();
+
+ LogDomain(Bundle bundle)
+ {
+ this.bundle = bundle;
+ }
+
+ private void reset()
+ {
+ synchronized (facades)
+ {
+ for (LoggerFacade facade : facades)
+ {
+ facade.reset();
+ }
+ }
+ }
+
+ LoggerFacade getLogger(String name)
+ {
+ LoggerFacade facade = createLoggerFacade(this, name);
+ synchronized (facades)
+ {
+ facades.add(facade);
+ }
+ return facade;
+ }
+
+ @Override
+ public void close()
+ {
+ reset();
+ }
+
+ }
+
+ class LoggerFacade
+ {
+ private final String name;
+ private final LogDomain domain;
+ volatile Object logger;
+ volatile String prefix;
+
+ LoggerFacade(LogDomain logDomain, String name)
+ {
+ this.domain = logDomain;
+ this.name = name;
+ }
+
+ void reset()
+ {
+ logger = null;
+ }
+
+ Object getLogger()
+ {
+ Object l = this.logger;
+ if (l == null)
+ {
+ l = lock.getLogger(this, domain.bundle, name);
+ }
+ return l;
+ }
+
+ Bundle getBundle()
+ {
+ return domain.bundle;
+ }
+
+ String getName()
+ {
+ return name;
+ }
+
+ }
+
+ public void close()
+ {
+ if (closed.compareAndSet(false, true))
+ {
+ lock.close();
+ super.close();
+ this.context.removeBundleListener(this);
+ }
+ }
+
+ LoggerFacade createLoggerFacade(LogDomain logDomain, String name)
+ {
+ assert !closed.get();
+ return new LoggerFacade(logDomain, name);
+ }
}
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/ScrLogManager.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/ScrLogManager.java
index 1aa1f70..56e88b5 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/ScrLogManager.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/logger/ScrLogManager.java
@@ -36,268 +36,322 @@ import org.osgi.service.log.Logger;
* {@link ExtLogManager} implements the extension behavior. The {@link #scr()}
* method makes this distinction based on the configuration.
*/
-public class ScrLogManager extends LogManager {
-
- private final Bundle bundle;
- private final ScrConfiguration config;
-
- /**
- * Get a new log manager based on the configuration.
- *
- * @param context
- * the bundle context of the SCR bundle
- * @param config
- * the SCR configuration
- * @return a proper ScrLogManager
- */
-
- public static ScrLogger scr(BundleContext context, ScrConfiguration config) {
+public class ScrLogManager extends LogManager
+{
+
+ private final Bundle bundle;
+ private final ScrConfiguration config;
+
+ /**
+ * Get a new log manager based on the configuration.
+ *
+ * @param context
+ * the bundle context of the SCR bundle
+ * @param config
+ * the SCR configuration
+ * @return a proper ScrLogManager
+ */
+
+ public static ScrLogger scr(BundleContext context, ScrConfiguration config)
+ {
ScrLogManager manager;
- if (config.isLogExtension())
+ if (config.isLogExtension())
manager = new ExtLogManager(context, config);
- else
+ else
manager = new ScrLogManager(context, config);
manager.open();
return manager.scr();
- }
-
- ScrLogManager(BundleContext context, ScrConfiguration config) {
- super(context);
- this.config = config;
- this.bundle = context.getBundle();
- }
-
- /**
- * This logger is used for the main code of SCR. This will use the SCR
- * bundle & the {@link Logger#ROOT_LOGGER_NAME}
- *
- * @return an Scr Logger.
- */
- public ScrLogger scr() {
- ScrLoggerFacade scrl = super.getLogger(bundle, Logger.ROOT_LOGGER_NAME, ScrLoggerFacade.class);
- scrl.setPrefix(getBundleIdentifier(bundle));
- return scrl;
- }
-
- /**
- * This logger is used for the logging on a per bundle basis. This will use
- * the target bundle & the {@link Logger#ROOT_LOGGER_NAME}
- *
- * @param bundle
- * the target bundle
- * @return a logger suitable to log bundle entries
- */
- public BundleLogger bundle(Bundle bundle) {
- ScrLoggerFacade logger = getLogger(bundle, Logger.ROOT_LOGGER_NAME, ScrLoggerFacade.class);
- logger.setPrefix(getBundleIdentifier(bundle));
- return logger;
- }
-
- /**
- * This logger is used for the logging on a per bundle basis. This will use
- * the target bundle & the implementation class as logger name.
- *
- * @param bundle
- * the target bundle
- * @return a logger suitable to log bundle entries
- */
- public ComponentLogger component(Bundle bundle, String implementationClass, String name) {
-
- // assert bundle != null;
- // assert bundle.getSymbolicName() != null : "scr requires recent
- // bundles";
- // assert implementationClass != null;
- // assert name != null;
-
- ScrLoggerFacade facade = getLogger(bundle, implementationClass, ScrLoggerFacade.class);
- facade.setComponentId(-1);
- return (ComponentLogger) facade;
- }
-
- class ScrLoggerFacade extends LoggerFacade implements InternalLogger, ScrLogger, BundleLogger, ComponentLogger {
- ScrLoggerFacade(LogDomain logDomain, String name) {
- super(logDomain, name);
- }
-
- @Override
- public void setComponentId(long id) {
- setPrefix(componentPrefix(this, id));
- }
-
- public boolean isLogEnabled(Level level) {
-
- // assert !closed.get();
-
- Object checkLogger = getLogger();
- if (checkLogger != null) {
- Logger logger = (Logger) checkLogger;
- switch (level) {
- case AUDIT:
- return true;
- case ERROR:
- return logger.isErrorEnabled();
- case WARN:
- return logger.isWarnEnabled();
- case INFO:
- return logger.isInfoEnabled();
- case TRACE:
- return logger.isTraceEnabled();
- case DEBUG:
- default:
- return logger.isDebugEnabled();
- }
- } else {
- return getLogLevel().implies(level);
- }
- }
-
- @Override
- public void log(Level level, String format, Throwable ex, Object... arguments) {
- if (isLogEnabled(level))
- log0(level, format(format, arguments), ex);
- }
-
- @Override
- public void log(Level level, String message, Throwable ex) {
- if (isLogEnabled(level))
- log0(level, message, ex);
- }
-
- void log0(Level level, String message, Throwable ex) {
- if (prefix != null && prefix.length() > 0) {
- message = prefix.concat(" ").concat(message);
- }
- Object checkLogger = getLogger();
- if (checkLogger != null) {
- Logger logger = (Logger) checkLogger;
- if (ex == null) {
- switch (level) {
- case AUDIT:
- logger.audit(message);
- break;
- case ERROR:
- logger.error(message);
- break;
- case WARN:
- logger.warn(message);
- break;
- case INFO:
- logger.info(message);
- break;
- case TRACE:
- logger.trace(message);
- break;
- case DEBUG:
- default:
- logger.debug(message);
- }
- } else {
- switch (level) {
- case AUDIT:
- logger.audit(message, ex);
- break;
- case ERROR:
- logger.error(message, ex);
- break;
- case WARN:
- logger.warn(message, ex);
- break;
- case INFO:
- logger.info(message, ex);
- break;
- case TRACE:
- logger.trace(message, ex);
- break;
- case DEBUG:
- default:
- logger.debug(message, ex);
- }
- }
- } else {
- StringWriter buf = new StringWriter();
- String l = String.format("%-5s", level);
- buf.append(l).append(" : ").append(message);
- if (ex != null) {
- try (PrintWriter pw = new PrintWriter(buf)) {
- pw.println();
- ex.printStackTrace(pw);
- }
- }
-
- @SuppressWarnings("resource")
- PrintStream out = level.err() ? System.err : System.out;
- out.println(buf);
- }
- }
-
- void setPrefix(String prefix) {
- this.prefix = prefix;
- }
-
- @Override
- public ComponentLogger component(Bundle bundle, String implementationClassName, String name) {
- // assert !closed.get();
- return ScrLogManager.this.component(bundle, implementationClassName, name);
- }
-
- @Override
- public BundleLogger bundle(Bundle bundle) {
- // assert !closed.get();
- return ScrLogManager.this.bundle(bundle);
- }
-
- @Override
- public void close() {
- // assert !closed.get();
- ScrLogManager.this.close();
- }
- };
-
- LoggerFacade createLoggerFacade(LogDomain logDomain, String name) {
- // assert !closed.get();
- return new ScrLoggerFacade(logDomain, name);
- }
-
- Level getLogLevel() {
- return config.getLogLevel();
- }
-
- String getBundleIdentifier(final Bundle bundle) {
- final StringBuilder sb = new StringBuilder("bundle ");
-
- if (bundle.getSymbolicName() != null) {
- sb.append(bundle.getSymbolicName());
- sb.append(':');
- sb.append(bundle.getVersion());
- sb.append(" (");
- sb.append(bundle.getBundleId());
- sb.append(")");
- } else {
- sb.append(bundle.getBundleId());
- }
-
- return sb.toString();
- }
-
- String componentPrefix(ScrLoggerFacade slf, long id) {
- if (id >= 0) {
- return getBundleIdentifier(slf.getBundle()) + "[" + slf.getName() + "(" + id + ")] :";
- } else {
- return getBundleIdentifier(slf.getBundle()) + "[" + slf.getName() + "] :";
- }
- }
-
- String format(final String pattern, final Object... arguments) {
- if (arguments == null || arguments.length == 0) {
- return pattern;
- } else {
- for (int i = 0; i < arguments.length; i++) {
- if (arguments[i] instanceof Bundle) {
- arguments[i] = getBundleIdentifier((Bundle) arguments[i]);
- }
- }
- return MessageFormat.format(pattern, arguments);
- }
- }
+ }
+
+ ScrLogManager(BundleContext context, ScrConfiguration config)
+ {
+ super(context);
+ this.config = config;
+ this.bundle = context.getBundle();
+ }
+
+ /**
+ * This logger is used for the main code of SCR. This will use the SCR
+ * bundle & the {@link Logger#ROOT_LOGGER_NAME}
+ *
+ * @return an Scr Logger.
+ */
+ public ScrLogger scr()
+ {
+ ScrLoggerFacade scrl = super.getLogger(bundle, Logger.ROOT_LOGGER_NAME,
+ ScrLoggerFacade.class);
+ scrl.setPrefix(getBundleIdentifier(bundle));
+ return scrl;
+ }
+
+ /**
+ * This logger is used for the logging on a per bundle basis. This will use
+ * the target bundle & the {@link Logger#ROOT_LOGGER_NAME}
+ *
+ * @param bundle
+ * the target bundle
+ * @return a logger suitable to log bundle entries
+ */
+ public BundleLogger bundle(Bundle bundle)
+ {
+ ScrLoggerFacade logger = getLogger(bundle, Logger.ROOT_LOGGER_NAME,
+ ScrLoggerFacade.class);
+ logger.setPrefix(getBundleIdentifier(bundle));
+ return logger;
+ }
+
+ /**
+ * This logger is used for the logging on a per bundle basis. This will use
+ * the target bundle & the implementation class as logger name.
+ *
+ * @param bundle
+ * the target bundle
+ * @return a logger suitable to log bundle entries
+ */
+ public ComponentLogger component(Bundle bundle, String implementationClass,
+ String name)
+ {
+
+ // assert bundle != null;
+ // assert bundle.getSymbolicName() != null : "scr requires recent
+ // bundles";
+ // assert implementationClass != null;
+ // assert name != null;
+
+ ScrLoggerFacade facade = getLogger(bundle, implementationClass,
+ ScrLoggerFacade.class);
+ facade.setComponentId(-1);
+ return (ComponentLogger) facade;
+ }
+
+ class ScrLoggerFacade extends LoggerFacade implements InternalLogger, ScrLogger, BundleLogger, ComponentLogger
+ {
+ ScrLoggerFacade(LogDomain logDomain, String name)
+ {
+ super(logDomain, name);
+ }
+
+ @Override
+ public void setComponentId(long id)
+ {
+ setPrefix(componentPrefix(this, id));
+ }
+
+ public boolean isLogEnabled(Level level)
+ {
+
+ // assert !closed.get();
+
+ Object checkLogger = getLogger();
+ if (checkLogger != null)
+ {
+ Logger logger = (Logger) checkLogger;
+ switch (level)
+ {
+ case AUDIT:
+ return true;
+ case ERROR:
+ return logger.isErrorEnabled();
+ case WARN:
+ return logger.isWarnEnabled();
+ case INFO:
+ return logger.isInfoEnabled();
+ case TRACE:
+ return logger.isTraceEnabled();
+ case DEBUG:
+ default:
+ return logger.isDebugEnabled();
+ }
+ }
+ else
+ {
+ return getLogLevel().implies(level);
+ }
+ }
+
+ @Override
+ public void log(Level level, String format, Throwable ex, Object... arguments)
+ {
+ if (isLogEnabled(level))
+ log0(level, format(format, arguments), ex);
+ }
+
+ @Override
+ public void log(Level level, String message, Throwable ex)
+ {
+ if (isLogEnabled(level))
+ log0(level, message, ex);
+ }
+
+ void log0(Level level, String message, Throwable ex)
+ {
+ if (prefix != null && prefix.length() > 0)
+ {
+ message = prefix.concat(" ").concat(message);
+ }
+ Object checkLogger = getLogger();
+ if (checkLogger != null)
+ {
+ Logger logger = (Logger) checkLogger;
+ if (ex == null)
+ {
+ switch (level)
+ {
+ case AUDIT:
+ logger.audit(message);
+ break;
+ case ERROR:
+ logger.error(message);
+ break;
+ case WARN:
+ logger.warn(message);
+ break;
+ case INFO:
+ logger.info(message);
+ break;
+ case TRACE:
+ logger.trace(message);
+ break;
+ case DEBUG:
+ default:
+ logger.debug(message);
+ }
+ }
+ else
+ {
+ switch (level)
+ {
+ case AUDIT:
+ logger.audit(message, ex);
+ break;
+ case ERROR:
+ logger.error(message, ex);
+ break;
+ case WARN:
+ logger.warn(message, ex);
+ break;
+ case INFO:
+ logger.info(message, ex);
+ break;
+ case TRACE:
+ logger.trace(message, ex);
+ break;
+ case DEBUG:
+ default:
+ logger.debug(message, ex);
+ }
+ }
+ }
+ else
+ {
+ StringWriter buf = new StringWriter();
+ String l = String.format("%-5s", level);
+ buf.append(l).append(" : ").append(message);
+ if (ex != null)
+ {
+ try (PrintWriter pw = new PrintWriter(buf))
+ {
+ pw.println();
+ ex.printStackTrace(pw);
+ }
+ }
+
+ @SuppressWarnings("resource")
+ PrintStream out = level.err() ? System.err : System.out;
+ out.println(buf);
+ }
+ }
+
+ void setPrefix(String prefix)
+ {
+ this.prefix = prefix;
+ }
+
+ @Override
+ public ComponentLogger component(Bundle bundle, String implementationClassName,
+ String name)
+ {
+ // assert !closed.get();
+ return ScrLogManager.this.component(bundle, implementationClassName, name);
+ }
+
+ @Override
+ public BundleLogger bundle(Bundle bundle)
+ {
+ // assert !closed.get();
+ return ScrLogManager.this.bundle(bundle);
+ }
+
+ @Override
+ public void close()
+ {
+ // assert !closed.get();
+ ScrLogManager.this.close();
+ }
+ };
+
+ LoggerFacade createLoggerFacade(LogDomain logDomain, String name)
+ {
+ // assert !closed.get();
+ return new ScrLoggerFacade(logDomain, name);
+ }
+
+ Level getLogLevel()
+ {
+ return config.getLogLevel();
+ }
+
+ String getBundleIdentifier(final Bundle bundle)
+ {
+ final StringBuilder sb = new StringBuilder("bundle ");
+
+ if (bundle.getSymbolicName() != null)
+ {
+ sb.append(bundle.getSymbolicName());
+ sb.append(':');
+ sb.append(bundle.getVersion());
+ sb.append(" (");
+ sb.append(bundle.getBundleId());
+ sb.append(")");
+ }
+ else
+ {
+ sb.append(bundle.getBundleId());
+ }
+
+ return sb.toString();
+ }
+
+ String componentPrefix(ScrLoggerFacade slf, long id)
+ {
+ if (id >= 0)
+ {
+ return getBundleIdentifier(slf.getBundle()) + "[" + slf.getName() + "(" + id
+ + ")] :";
+ }
+ else
+ {
+ return getBundleIdentifier(slf.getBundle()) + "[" + slf.getName() + "] :";
+ }
+ }
+
+ String format(final String pattern, final Object... arguments)
+ {
+ if (arguments == null || arguments.length == 0)
+ {
+ return pattern;
+ }
+ else
+ {
+ for (int i = 0; i < arguments.length; i++)
+ {
+ if (arguments[i] instanceof Bundle)
+ {
+ arguments[i] = getBundleIdentifier((Bundle) arguments[i]);
+ }
+ }
+ return MessageFormat.format(pattern, arguments);
+ }
+ }
}
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/ScrLogger.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/ScrLogger.java
index cbf8a42..09f085a 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/ScrLogger.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/logger/ScrLogger.java
@@ -24,15 +24,16 @@ import org.osgi.framework.Bundle;
/**
* Logger used by SCR main code
*/
-public interface ScrLogger extends InternalLogger {
+public interface ScrLogger extends InternalLogger
+{
- /**
- * Create a bundle logger
- */
- BundleLogger bundle(Bundle bundle);
+ /**
+ * Create a bundle logger
+ */
+ BundleLogger bundle(Bundle bundle);
- /**
- * Close the log manager
- */
- void close();
+ /**
+ * Close the log manager
+ */
+ void close();
}
[felix-dev] 02/02: FELIX-6361 - Avoid IllegalArgumentException for
calls to getLogger
Posted by tj...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
tjwatson pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/felix-dev.git
commit 462bfe2b3a398b35ac495473c63e348003545248
Author: Thomas Watson <tj...@us.ibm.com>
AuthorDate: Fri Nov 20 09:15:23 2020 -0600
FELIX-6361 - Avoid IllegalArgumentException for calls to getLogger
---
.../org/apache/felix/scr/impl/logger/LogManager.java | 18 ++++++++++++++++--
1 file changed, 16 insertions(+), 2 deletions(-)
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/LogManager.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/LogManager.java
index a5ccd34..027f4a6 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/LogManager.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/logger/LogManager.java
@@ -109,10 +109,24 @@ class LogManager extends ServiceTracker<Object, Object> implements BundleListene
synchronized Object getLogger(LoggerFacade facade, Bundle bundle, String name)
{
if (factory == null)
+ {
return facade.logger = null;
+ }
else
- return facade.logger = ((LoggerFactory) factory).getLogger(bundle, name,
- Logger.class);
+ {
+ try
+ {
+ return facade.logger = ((LoggerFactory) factory).getLogger(bundle,
+ name, Logger.class);
+ }
+ catch (IllegalArgumentException e)
+ {
+ // The bundle probably got uninstalled or somehow unresolved,
+ // fallback to the SCR bundle's logger
+ return ((LoggerFactory) factory).getLogger(context.getBundle(), name,
+ Logger.class);
+ }
+ }
}
synchronized LogDomain remove(Bundle bundle)