From 6648f2e8438e06ea62343a9796107c580efe326b Mon Sep 17 00:00:00 2001 From: Mathieu Baudier Date: Thu, 10 Feb 2022 09:40:07 +0100 Subject: [PATCH] Move SLF4J implementation from Commons to SLC --- Makefile | 26 ++- ext/org.argeo.ext.slf4j/.classpath | 7 + ext/org.argeo.ext.slf4j/.project | 28 +++ ext/org.argeo.ext.slf4j/bnd.bnd | 3 + ext/org.argeo.ext.slf4j/build.properties | 4 + ext/org.argeo.ext.slf4j/pom.xml | 14 ++ .../src/org/slf4j/impl/ArgeoLogger.java | 180 ++++++++++++++++ .../org/slf4j/impl/StaticLoggerBinder.java | 41 ++++ .../org/slf4j/impl/SystemLoggingAdapter.java | 203 ++++++++++++++++++ org.argeo.slc.factory/build.properties | 3 +- sdk/includes.mk | 2 +- 11 files changed, 498 insertions(+), 13 deletions(-) create mode 100644 ext/org.argeo.ext.slf4j/.classpath create mode 100644 ext/org.argeo.ext.slf4j/.project create mode 100644 ext/org.argeo.ext.slf4j/bnd.bnd create mode 100644 ext/org.argeo.ext.slf4j/build.properties create mode 100644 ext/org.argeo.ext.slf4j/pom.xml create mode 100644 ext/org.argeo.ext.slf4j/src/org/slf4j/impl/ArgeoLogger.java create mode 100644 ext/org.argeo.ext.slf4j/src/org/slf4j/impl/StaticLoggerBinder.java create mode 100644 ext/org.argeo.ext.slf4j/src/org/slf4j/impl/SystemLoggingAdapter.java diff --git a/Makefile b/Makefile index fb4e41880..599b85de8 100644 --- a/Makefile +++ b/Makefile @@ -1,14 +1,15 @@ include sdk.mk .PHONY: clean all osgi -all: osgi +all: osgi distribution -BUNDLE_PREFIX = org.argeo.slc +BUNDLE_PREFIX = org.argeo A2_CATEGORY = org.argeo.slc BUNDLES = \ org.argeo.slc.api \ org.argeo.slc.factory \ +ext/org.argeo.ext.slf4j BUILD_CLASSPATH_FEDORA = \ /usr/share/java/osgi-core/osgi.core.jar:$\ @@ -42,6 +43,7 @@ BUILD_BASE = $(SDK_BUILD_BASE) distribution: osgi $(JVM) -cp $(DISTRIBUTION_CLASSPATH) tp/Make.java + # # GENERIC # @@ -50,9 +52,9 @@ JAVADOC := /usr/bin/javadoc ECJ_JAR := /usr/share/java/ecj.jar BND_TOOL := /usr/bin/bnd -WORKSPACE_BNDS := $(shell cd $(SDK_SRC_BASE) && find cnf -name '*.bnd') +WORKSPACE_BNDS := $(shell cd $(SDK_SRC_BASE) && find cnf -name '*.bnd') #BND_WORKSPACES := $(foreach bundle, $(BUNDLES), ./$(dir $(bundle))) -BUILD_WORKSPACE_BNDS := $(WORKSPACE_BNDS:%=$(SDK_BUILD_BASE)/%) +BUILD_WORKSPACE_BNDS := $(WORKSPACE_BNDS:%=$(SDK_BUILD_BASE)/%) $(WORKSPACE_BNDS:%=$(SDK_BUILD_BASE)/ext/%) cnf: $(BUILD_WORKSPACE_BNDS) @@ -63,22 +65,25 @@ JAVA_SRCS = $(foreach bundle, $(BUNDLES), $(shell find $(bundle) -name '*.java') ECJ_SRCS = $(foreach bundle, $(BUNDLES), $(bundle)/src[-d $(BUILD_BASE)/$(bundle)/bin]) osgi: cnf $(A2_BUNDLES) + mkdir -p $(SDK_BUILD_BASE)/a2/org.argeo.tp + mv $(SDK_BUILD_BASE)/a2/$(A2_CATEGORY)/ext/org.argeo.ext.slf4j.$(MAJOR).$(MINOR).jar $(SDK_BUILD_BASE)/a2/org.argeo.tp + rmdir $(SDK_BUILD_BASE)/a2/$(A2_CATEGORY)/ext clean: rm -rf $(BUILD_BASE)/*-compiled - rm -rf $(BUILD_BASE)/{cnf,a2} + rm -rf $(BUILD_BASE)/cnf + rm -rf $(BUILD_BASE)/a2 rm -rf $(BUILD_BASE)/$(BUNDLE_PREFIX).* + rm -rf $(BUILD_BASE)/ext + rm -rf $(BUILD_BASE)/build + rm -rf $(BUILD_BASE)/deb # SDK level $(SDK_BUILD_BASE)/cnf/%.bnd: cnf/%.bnd mkdir -p $(dir $@) cp $< $@ -$(SDK_BUILD_BASE)/eclipse/cnf/%.bnd: cnf/%.bnd - mkdir -p $(dir $@) - cp $< $@ - -$(SDK_BUILD_BASE)/rcp/cnf/%.bnd: cnf/%.bnd +$(SDK_BUILD_BASE)/ext/cnf/%.bnd: cnf/%.bnd mkdir -p $(dir $@) cp $< $@ @@ -88,6 +93,7 @@ $(SDK_BUILD_BASE)/a2/$(A2_CATEGORY)/%.$(MAJOR).$(MINOR).jar : $(BUILD_BASE)/%/bu # Build level $(BUILD_BASE)/%/bundle.jar : %/bnd.bnd $(BUILD_BASE)/java-compiled + mkdir -p $(dir $@) rsync -r --exclude "*.java" $(dir $<)src/ $(dir $@)bin rsync -r $(dir $<)src/ $(dir $@)src if [ -d "$(dir $<)OSGI-INF" ]; then rsync -r $(dir $<)OSGI-INF/ $(dir $@)/OSGI-INF; fi diff --git a/ext/org.argeo.ext.slf4j/.classpath b/ext/org.argeo.ext.slf4j/.classpath new file mode 100644 index 000000000..e801ebfb4 --- /dev/null +++ b/ext/org.argeo.ext.slf4j/.classpath @@ -0,0 +1,7 @@ + + + + + + + diff --git a/ext/org.argeo.ext.slf4j/.project b/ext/org.argeo.ext.slf4j/.project new file mode 100644 index 000000000..3ed363df7 --- /dev/null +++ b/ext/org.argeo.ext.slf4j/.project @@ -0,0 +1,28 @@ + + + org.argeo.ext.slf4j + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.pde.ManifestBuilder + + + + + org.eclipse.pde.SchemaBuilder + + + + + + org.eclipse.pde.PluginNature + org.eclipse.jdt.core.javanature + + diff --git a/ext/org.argeo.ext.slf4j/bnd.bnd b/ext/org.argeo.ext.slf4j/bnd.bnd new file mode 100644 index 000000000..37061df59 --- /dev/null +++ b/ext/org.argeo.ext.slf4j/bnd.bnd @@ -0,0 +1,3 @@ +Export-Package: org.slf4j.impl + +Import-Package: * diff --git a/ext/org.argeo.ext.slf4j/build.properties b/ext/org.argeo.ext.slf4j/build.properties new file mode 100644 index 000000000..34d2e4d2d --- /dev/null +++ b/ext/org.argeo.ext.slf4j/build.properties @@ -0,0 +1,4 @@ +source.. = src/ +output.. = bin/ +bin.includes = META-INF/,\ + . diff --git a/ext/org.argeo.ext.slf4j/pom.xml b/ext/org.argeo.ext.slf4j/pom.xml new file mode 100644 index 000000000..ede65efc8 --- /dev/null +++ b/ext/org.argeo.ext.slf4j/pom.xml @@ -0,0 +1,14 @@ + + + 4.0.0 + + org.argeo.slc + 2.3-SNAPSHOT + argeo-slc + .. + + org.argeo.tp + org.argeo.ext.slf4j + jar + SLF4J implementation based on Sytem.Logger + \ No newline at end of file diff --git a/ext/org.argeo.ext.slf4j/src/org/slf4j/impl/ArgeoLogger.java b/ext/org.argeo.ext.slf4j/src/org/slf4j/impl/ArgeoLogger.java new file mode 100644 index 000000000..5c4889aed --- /dev/null +++ b/ext/org.argeo.ext.slf4j/src/org/slf4j/impl/ArgeoLogger.java @@ -0,0 +1,180 @@ +package org.slf4j.impl; + +import org.slf4j.helpers.MarkerIgnoringBase; + +class ArgeoLogger extends MarkerIgnoringBase { + private static final long serialVersionUID = -7719157836932627307L; + private final SystemLoggingAdapter log; + + protected ArgeoLogger(String name, SystemLoggingAdapter log) { + this.name = name; + this.log = log; + } + + @Override + public boolean isDebugEnabled() { + return log.isDebugEnabled(); + } + + @Override + public boolean isTraceEnabled() { + return log.isDebugEnabled(); + } + + @Override + public void trace(String msg) { + log.trace(msg); + + } + + @Override + public void trace(String format, Object... arguments) { + log.trace(format, arguments); + + } + + @Override + public void trace(String msg, Throwable t) { + log.trace(msg, t); + + } + + @Override + public void debug(String msg) { + log.debug(msg); + + } + + @Override + public void debug(String format, Object... arguments) { + log.debug(format, arguments); + + } + + @Override + public void debug(String msg, Throwable t) { + log.debug(msg, t); + + } + + @Override + public boolean isInfoEnabled() { + return log.isInfoEnabled(); + } + + @Override + public void info(String msg) { + log.info(msg); + + } + + @Override + public void info(String format, Object... arguments) { + log.info(format, arguments); + } + + @Override + public void info(String msg, Throwable t) { + log.info(msg, t); + + } + + @Override + public boolean isWarnEnabled() { + return log.isWarnEnabled(); + } + + @Override + public void warn(String msg) { + log.warn(msg); + + } + + @Override + public void warn(String format, Object... arguments) { + log.warn(format, arguments); + + } + + @Override + public void warn(String msg, Throwable t) { + log.warn(msg, t); + + } + + @Override + public boolean isErrorEnabled() { + + return log.isErrorEnabled(); + } + + @Override + public void error(String msg) { + log.error(msg); + + } + + @Override + public void error(String format, Object... arguments) { + log.error(format, arguments); + + } + + @Override + public void error(String msg, Throwable t) { + log.error(msg, t); + + } + + @Override + public void trace(String format, Object arg) { + trace(format, new Object[] { arg }); + + } + + @Override + public void trace(String format, Object arg1, Object arg2) { + trace(format, new Object[] { arg1, arg2 }); + } + + @Override + public void debug(String format, Object arg) { + debug(format, new Object[] { arg }); + } + + @Override + public void debug(String format, Object arg1, Object arg2) { + debug(format, new Object[] { arg1, arg2 }); + } + + @Override + public void info(String format, Object arg) { + info(format, new Object[] { arg }); + } + + @Override + public void info(String format, Object arg1, Object arg2) { + info(format, new Object[] { arg1, arg2 }); + } + + @Override + public void warn(String format, Object arg) { + warn(format, new Object[] { arg }); + } + + @Override + public void warn(String format, Object arg1, Object arg2) { + warn(format, new Object[] { arg1, arg2 }); + } + + @Override + public void error(String format, Object arg) { + error(format, new Object[] { arg }); + } + + @Override + public void error(String format, Object arg1, Object arg2) { + error(format, new Object[] { arg1, arg2 }); + } + +} \ No newline at end of file diff --git a/ext/org.argeo.ext.slf4j/src/org/slf4j/impl/StaticLoggerBinder.java b/ext/org.argeo.ext.slf4j/src/org/slf4j/impl/StaticLoggerBinder.java new file mode 100644 index 000000000..8c5b3ad8e --- /dev/null +++ b/ext/org.argeo.ext.slf4j/src/org/slf4j/impl/StaticLoggerBinder.java @@ -0,0 +1,41 @@ +package org.slf4j.impl; + +import org.slf4j.ILoggerFactory; +import org.slf4j.spi.LoggerFactoryBinder; + +public class StaticLoggerBinder implements LoggerFactoryBinder { + public static final String REQUESTED_API_VERSION = "1.7"; + + private static final StaticLoggerBinder SINGLETON = new StaticLoggerBinder(); + + private final ILoggerFactory loggerFactory; + + protected StaticLoggerBinder() { + loggerFactory = new SystemLoggerFactory(); + } + + @Override + public ILoggerFactory getLoggerFactory() { + return loggerFactory; + } + + @Override + public String getLoggerFactoryClassStr() { + return SystemLoggerFactory.class.getName(); + } + + public static final StaticLoggerBinder getSingleton() { + return SINGLETON; + } + + static class SystemLoggerFactory implements ILoggerFactory { + + @Override + public org.slf4j.Logger getLogger(String name) { + SystemLoggingAdapter logger = SystemLoggingAdapter.getLog(name); + return new ArgeoLogger(name, logger); + } + + } + +} diff --git a/ext/org.argeo.ext.slf4j/src/org/slf4j/impl/SystemLoggingAdapter.java b/ext/org.argeo.ext.slf4j/src/org/slf4j/impl/SystemLoggingAdapter.java new file mode 100644 index 000000000..7a6c86555 --- /dev/null +++ b/ext/org.argeo.ext.slf4j/src/org/slf4j/impl/SystemLoggingAdapter.java @@ -0,0 +1,203 @@ +package org.slf4j.impl; + +import java.lang.System.Logger; +import java.lang.System.Logger.Level; +import java.util.Objects; +import java.util.function.Supplier; + +/** + * A Commons Logging / SLF4J style logging utilities wrapping a standard Java + * platform {@link Logger}. + */ +public interface SystemLoggingAdapter { + Logger getLogger(); + + default boolean isDebugEnabled() { + return getLogger().isLoggable(Level.DEBUG); + } + + default boolean isErrorEnabled() { + return getLogger().isLoggable(Level.ERROR); + } + + default boolean isInfoEnabled() { + return getLogger().isLoggable(Level.INFO); + } + + default boolean isTraceEnabled() { + return getLogger().isLoggable(Level.TRACE); + } + + default boolean isWarnEnabled() { + return getLogger().isLoggable(Level.WARNING); + } + + /* + * TRACE + */ + + default void trace(String message) { + getLogger().log(Level.TRACE, message); + } + + default void trace(Supplier message) { + getLogger().log(Level.TRACE, message); + } + + default void trace(Object message) { + getLogger().log(Level.TRACE, Objects.requireNonNull(message)); + } + + default void trace(String message, Throwable t) { + getLogger().log(Level.TRACE, message, t); + } + + default void trace(Object message, Throwable t) { + trace(Objects.requireNonNull(message).toString(), t); + } + + default void trace(String format, Object... arguments) { + getLogger().log(Level.TRACE, format, arguments); + } + + /* + * DEBUG + */ + + default void debug(String message) { + getLogger().log(Level.DEBUG, message); + } + + default void debug(Supplier message) { + getLogger().log(Level.DEBUG, message); + } + + default void debug(Object message) { + getLogger().log(Level.DEBUG, message); + } + + default void debug(String message, Throwable t) { + getLogger().log(Level.DEBUG, message, t); + } + + default void debug(Object message, Throwable t) { + debug(Objects.requireNonNull(message).toString(), t); + } + + default void debug(String format, Object... arguments) { + getLogger().log(Level.DEBUG, format, arguments); + } + + /* + * INFO + */ + + default void info(String message) { + getLogger().log(Level.INFO, message); + } + + default void info(Supplier message) { + getLogger().log(Level.INFO, message); + } + + default void info(Object message) { + getLogger().log(Level.INFO, message); + } + + default void info(String message, Throwable t) { + getLogger().log(Level.INFO, message, t); + } + + default void info(Object message, Throwable t) { + info(Objects.requireNonNull(message).toString(), t); + } + + default void info(String format, Object... arguments) { + getLogger().log(Level.INFO, format, arguments); + } + + /* + * WARN + */ + + default void warn(String message) { + getLogger().log(Level.WARNING, message); + } + + default void warn(Supplier message) { + getLogger().log(Level.WARNING, message); + } + + default void warn(Object message) { + getLogger().log(Level.WARNING, message); + } + + default void warn(String message, Throwable t) { + getLogger().log(Level.WARNING, message, t); + } + + default void warn(Object message, Throwable t) { + warn(Objects.requireNonNull(message).toString(), t); + } + + default void warn(String format, Object... arguments) { + getLogger().log(Level.WARNING, format, arguments); + } + + /* + * ERROR + */ + + default void error(String message) { + getLogger().log(Level.ERROR, message); + } + + default void error(Supplier message) { + getLogger().log(Level.ERROR, message); + } + + default void error(Object message) { + getLogger().log(Level.ERROR, message); + } + + default void error(String message, Throwable t) { + getLogger().log(Level.ERROR, message, t); + } + + default void error(Object message, Throwable t) { + error(Objects.requireNonNull(message).toString(), t); + } + + default void error(String format, Object... arguments) { + getLogger().log(Level.ERROR, format, arguments); + } + + /* + * STATIC UTILITIES + */ + + static SystemLoggingAdapter getLog(Class clss) { + return getLog(Objects.requireNonNull(clss).getName()); + } + + static SystemLoggingAdapter getLog(String name) { + Logger logger = System.getLogger(Objects.requireNonNull(name)); + return new LoggerWrapper(logger); + } + + /** A trivial implementation wrapping a platform logger. */ + static class LoggerWrapper implements SystemLoggingAdapter { + private final Logger logger; + + LoggerWrapper(Logger logger) { + this.logger = logger; + } + + @Override + public Logger getLogger() { + return logger; + } + + } + +} diff --git a/org.argeo.slc.factory/build.properties b/org.argeo.slc.factory/build.properties index f7efa14e3..60501270b 100644 --- a/org.argeo.slc.factory/build.properties +++ b/org.argeo.slc.factory/build.properties @@ -3,5 +3,4 @@ output.. = bin/ bin.includes = META-INF/,\ . additional.bundles = org.argeo.init,\ - org.slf4j.api,\ - org.argeo.cms.tp + org.slf4j.api \ No newline at end of file diff --git a/sdk/includes.mk b/sdk/includes.mk index d7cc8d848..31efbf517 100644 --- a/sdk/includes.mk +++ b/sdk/includes.mk @@ -1 +1 @@ -include $(SDK_SRC_BASE)/sdk/deb.mk +##include $(SDK_SRC_BASE)/sdk/deb.mk -- 2.39.2