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:31 UTC
[felix-dev] 01/02: Format according to the rest of SCR codebase
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();
}