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:$\
distribution: osgi
$(JVM) -cp $(DISTRIBUTION_CLASSPATH) tp/Make.java
+
#
# GENERIC
#
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)
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 $< $@
# 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
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-11"/>
+ <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>org.argeo.ext.slf4j</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.ManifestBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.SchemaBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.pde.PluginNature</nature>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
--- /dev/null
+Export-Package: org.slf4j.impl
+
+Import-Package: *
--- /dev/null
+source.. = src/
+output.. = bin/
+bin.includes = META-INF/,\
+ .
--- /dev/null
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.argeo.slc</groupId>
+ <version>2.3-SNAPSHOT</version>
+ <artifactId>argeo-slc</artifactId>
+ <relativePath>..</relativePath>
+ </parent>
+ <groupId>org.argeo.tp</groupId>
+ <artifactId>org.argeo.ext.slf4j</artifactId>
+ <packaging>jar</packaging>
+ <name>SLF4J implementation based on Sytem.Logger</name>
+</project>
\ No newline at end of file
--- /dev/null
+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
--- /dev/null
+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);
+ }
+
+ }
+
+}
--- /dev/null
+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<String> 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<String> 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<String> 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<String> 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<String> 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;
+ }
+
+ }
+
+}
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
-include $(SDK_SRC_BASE)/sdk/deb.mk
+##include $(SDK_SRC_BASE)/sdk/deb.mk