diff options
Diffstat (limited to 'src/main/patch/houston')
| -rw-r--r-- | src/main/patch/houston/default-20230203.patch | 52 | ||||
| -rw-r--r-- | src/main/patch/houston/default-20230214.patch | 56 | ||||
| -rw-r--r-- | src/main/patch/houston/default-20230331.patch | 56 | ||||
| -rw-r--r-- | src/main/patch/houston/default.patch | 88 | ||||
| -rw-r--r-- | src/main/patch/houston/fixidiots.patch | 365 | ||||
| -rw-r--r-- | src/main/patch/houston/future.patch | 47 |
6 files changed, 477 insertions, 187 deletions
diff --git a/src/main/patch/houston/default-20230203.patch b/src/main/patch/houston/default-20230203.patch deleted file mode 100644 index c1deeca..0000000 --- a/src/main/patch/houston/default-20230203.patch +++ /dev/null @@ -1,52 +0,0 @@ - - My custom patch ready-to-apply to have an "usable" houston. - - Contains: - - Simplelogger - - Listen localhost only - - Queue-Retry every 5 seconds. - -diff --git a/houston-process/pom.xml b/houston-process/pom.xml -index fff9c178..960c0098 100644 ---- a/houston-process/pom.xml -+++ b/houston-process/pom.xml -@@ -20,6 +20,26 @@ - <skip.node.install>true</skip.node.install> - </properties> - <dependencies> -+ <dependency> <!-- TODO: Remove --> -+ <groupId>org.slf4j</groupId> <!-- TODO: Remove --> -+ <artifactId>slf4j-api</artifactId> <!-- TODO: Remove --> -+ <version>1.7.25</version> <!-- TODO: Remove --> -+ </dependency> <!-- TODO: Remove --> -+ <dependency> <!-- TODO: Remove --> -+ <groupId>org.slf4j</groupId> <!-- TODO: Remove --> -+ <artifactId>slf4j-simple</artifactId> <!-- TODO: Remove --> -+ <version>1.7.25</version> <!-- TODO: Remove --> -+ </dependency> <!-- TODO: Remove --> -+ <dependency> <!-- TODO: Remove --> -+ <groupId>org.slf4j</groupId> <!-- TODO: Remove --> -+ <artifactId>jcl-over-slf4j</artifactId> <!-- TODO: Remove --> -+ <version>1.7.25</version> <!-- TODO: Remove --> -+ </dependency> <!-- TODO: Remove --> -+ <dependency> <!-- TODO: Remove --> -+ <groupId>org.slf4j</groupId> <!-- TODO: Remove --> -+ <artifactId>jul-to-slf4j</artifactId> <!-- TODO: Remove --> -+ <version>1.7.25</version> <!-- TODO: Remove --> -+ </dependency> <!-- TODO: Remove --> - <!-- project --> - <dependency> - <groupId>ch.post.it.paisa.houston</groupId> -diff --git a/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java b/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java -index ee7d8b02..b28ae8d6 100644 ---- a/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java -+++ b/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java -@@ -256,7 +256,7 @@ public class Deployer { - qc.add(new QueueConfiguration().withPattern("brox-from-vehicles-.*").withRetryIntervals(10, 20, 30, 60, 120) - .withEnqueueDelayMillisPerSize(10).withEnqueueMaxDelayMillis(10_000)); - // All other queues (typically to backend services) with a slow-down pattern after failed delivery -- qc.add(new QueueConfiguration().withPattern(".*").withRetryIntervals(10, 20, 30, 60, 120)); -+ qc.add(new QueueConfiguration().withPattern(".*").withRetryIntervals(5));/*TODO revert*/ - - RedisquesConfiguration redisquesConfig = RedisquesConfiguration.with() - .address(Address.redisquesAddress()) diff --git a/src/main/patch/houston/default-20230214.patch b/src/main/patch/houston/default-20230214.patch deleted file mode 100644 index 3f8fa16..0000000 --- a/src/main/patch/houston/default-20230214.patch +++ /dev/null @@ -1,56 +0,0 @@ - - My custom patch ready-to-apply to have an "usable" houston. - - Contains: - - Simplelogger - - Listen localhost only - - Queue-Retry every 5 seconds. - - Patch based on "houston-02.01.12.00" aka - "3c61ef7ded53d6340001d2b56cd829d2ae450580" from 2023-01-12. - -diff --git a/houston-process/pom.xml b/houston-process/pom.xml -index fff9c178..960c0098 100644 ---- a/houston-process/pom.xml -+++ b/houston-process/pom.xml -@@ -20,6 +20,26 @@ - </properties> - - <dependencies> -+ <dependency> <!-- TODO: Remove --> -+ <groupId>org.slf4j</groupId> <!-- TODO: Remove --> -+ <artifactId>slf4j-api</artifactId> <!-- TODO: Remove --> -+ <version>1.7.25</version> <!-- TODO: Remove --> -+ </dependency> <!-- TODO: Remove --> -+ <dependency> <!-- TODO: Remove --> -+ <groupId>org.slf4j</groupId> <!-- TODO: Remove --> -+ <artifactId>slf4j-simple</artifactId> <!-- TODO: Remove --> -+ <version>1.7.25</version> <!-- TODO: Remove --> -+ </dependency> <!-- TODO: Remove --> -+ <dependency> <!-- TODO: Remove --> -+ <groupId>org.slf4j</groupId> <!-- TODO: Remove --> -+ <artifactId>jcl-over-slf4j</artifactId> <!-- TODO: Remove --> -+ <version>1.7.25</version> <!-- TODO: Remove --> -+ </dependency> <!-- TODO: Remove --> -+ <dependency> <!-- TODO: Remove --> -+ <groupId>org.slf4j</groupId> <!-- TODO: Remove --> -+ <artifactId>jul-to-slf4j</artifactId> <!-- TODO: Remove --> -+ <version>1.7.25</version> <!-- TODO: Remove --> -+ </dependency> <!-- TODO: Remove --> - <!-- project --> - <dependency> - <groupId>ch.post.it.paisa.houston</groupId> -diff --git a/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java b/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java -index ee7d8b02..b28ae8d6 100644 ---- a/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java -+++ b/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java -@@ -309,7 +309,7 @@ public class Deployer { - qc.add(new QueueConfiguration().withPattern("timetable-situation-trips-for-aws").withRetryIntervals(standardDelays) - .withEnqueueDelayMillisPerSize(10).withEnqueueMaxDelayMillis(100)); - // All other queues (typically to backend services) with a slow-down pattern after failed delivery -- qc.add(new QueueConfiguration().withPattern(".*").withRetryIntervals(standardDelays)); -+ qc.add(new QueueConfiguration().withPattern(".*").withRetryIntervals(5/*TODO revert*/)); - - RedisquesConfiguration redisquesConfig = RedisquesConfiguration.with() - .address(Address.redisquesAddress()) - diff --git a/src/main/patch/houston/default-20230331.patch b/src/main/patch/houston/default-20230331.patch deleted file mode 100644 index 64d3628..0000000 --- a/src/main/patch/houston/default-20230331.patch +++ /dev/null @@ -1,56 +0,0 @@ - - My custom patch ready-to-apply to have an "usable" houston. - - Contains: - - Simplelogger - - Listen localhost only - - Queue-Retry every 5 seconds. - - Patch based on "houston-02.01.12.00" aka - "3c61ef7ded53d6340001d2b56cd829d2ae450580" from 2023-01-12. - -diff --git a/houston-process/pom.xml b/houston-process/pom.xml -index fff9c178..960c0098 100644 ---- a/houston-process/pom.xml -+++ b/houston-process/pom.xml -@@ -20,6 +20,26 @@ - </properties> - - <dependencies> -+ <dependency> <!-- TODO: Remove --> -+ <groupId>org.slf4j</groupId> <!-- TODO: Remove --> -+ <artifactId>slf4j-api</artifactId> <!-- TODO: Remove --> -+ <version>2.0.1</version> <!-- TODO: Remove --> -+ </dependency> <!-- TODO: Remove --> -+ <dependency> <!-- TODO: Remove --> -+ <groupId>org.slf4j</groupId> <!-- TODO: Remove --> -+ <artifactId>slf4j-simple</artifactId> <!-- TODO: Remove --> -+ <version>2.0.1</version> <!-- TODO: Remove --> -+ </dependency> <!-- TODO: Remove --> -+ <dependency> <!-- TODO: Remove --> -+ <groupId>org.slf4j</groupId> <!-- TODO: Remove --> -+ <artifactId>jcl-over-slf4j</artifactId> <!-- TODO: Remove --> -+ <version>2.0.1</version> <!-- TODO: Remove --> -+ </dependency> <!-- TODO: Remove --> -+ <dependency> <!-- TODO: Remove --> -+ <groupId>org.slf4j</groupId> <!-- TODO: Remove --> -+ <artifactId>jul-to-slf4j</artifactId> <!-- TODO: Remove --> -+ <version>2.0.1</version> <!-- TODO: Remove --> -+ </dependency> <!-- TODO: Remove --> - <!-- project --> - <dependency> - <groupId>ch.post.it.paisa.houston</groupId> -diff --git a/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java b/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java -index ee7d8b02..b28ae8d6 100644 ---- a/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java -+++ b/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java -@@ -309,7 +309,7 @@ public class Deployer { - qc.add(new QueueConfiguration().withPattern("timetable-situation-trips-for-aws").withRetryIntervals(standardDelays) - .withEnqueueDelayMillisPerSize(10).withEnqueueMaxDelayMillis(100)); - // All other queues (typically to backend services) with a slow-down pattern after failed delivery -- qc.add(new QueueConfiguration().withPattern(".*").withRetryIntervals(standardDelays)); -+ qc.add(new QueueConfiguration().withPattern(".*").withRetryIntervals(5/*TODO revert*/)); - - RedisquesConfiguration redisquesConfig = RedisquesConfiguration.with() - .address(Address.redisquesAddress()) - diff --git a/src/main/patch/houston/default.patch b/src/main/patch/houston/default.patch index d70b12b..b5b7639 100644 --- a/src/main/patch/houston/default.patch +++ b/src/main/patch/houston/default.patch @@ -2,29 +2,55 @@ Custom houston patch to have a "usable" service at all. Patch based on "develop" aka - "3b1275e123c2b7aa2ffaa34270a5e1a373a65993" from "2023-04-27". + "497a9477c9e2100130f9a29ec130c1131220c935" from "2024-04-22". -diff --git a/pom.xml b/pom.xml -index 0ed4f7f3..b44c5693 100644 --- a/pom.xml +++ b/pom.xml -@@ -72,8 +72,6 @@ - <skip.wagon>false</skip.wagon> +@@ -73,7 +73,7 @@ <skip.copy-dependencies>false</skip.copy-dependencies> -- <!-- spotless --> + <!-- spotless --> - <source.format.apply.phase>compile</source.format.apply.phase> - </properties> ++ <source.format.apply.phase>none</source.format.apply.phase> - <scm> -diff --git a/houston-process/pom.xml b/houston-process/pom.xml -index 374dcb97..3c24937c 100644 + <!-- JavaMelody --> + <jetty.version>9.4.43.v20210629</jetty.version> + + +--- a/pom.xml ++++ b/pom.xml +@@ -301,4 +301,25 @@ + </properties> + </profile> + </profiles> ++ <build> ++ <plugins> ++ <plugin> ++ <groupId>com.diffplug.spotless</groupId> ++ <artifactId>spotless-maven-plugin</artifactId> ++ <executions> ++ <execution> ++ <id>spotless-apply</id> ++ <phase>none</phase> ++ </execution> ++ <execution> ++ <id>spotless-check</id> ++ <phase>none</phase> ++ </execution> ++ </executions> ++ <configuration> ++ <skip>true</skip> ++ </configuration> ++ </plugin> ++ </plugins> ++ </build> + </project> + + --- a/houston-process/pom.xml +++ b/houston-process/pom.xml -@@ -25,6 +25,26 @@ - </properties> - +@@ -27,3 +27,23 @@ <dependencies> + <dependency> <!-- TODO: Remove --> + <groupId>org.slf4j</groupId> <!-- TODO: Remove --> @@ -48,27 +74,43 @@ index 374dcb97..3c24937c 100644 + </dependency> <!-- TODO: Remove --> <!-- project --> <dependency> - <groupId>ch.post.it.paisa.houston</groupId> -diff --git a/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java b/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java -index 432efb01..d1729fe9 100644 + + +--- a/houston-process/pom.xml ++++ b/houston-process/pom.xml +@@ -212,6 +232,2 @@ + </dependency> +- <dependency> +- <groupId>org.apache.logging.log4j</groupId> +- <artifactId>log4j-slf4j2-impl</artifactId> +- </dependency> + <dependency> + + --- a/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java +++ b/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java -@@ -68,6 +68,9 @@ public class Deployer { +@@ -98,6 +98,9 @@ public class Deployer { private static final Logger LOGGER = LoggerFactory.getLogger(Deployer.class); public static void main(String[] args) throws Exception { + boolean isAssertIsEnabled = false; + assert isAssertIsEnabled = true; + if (!isAssertIsEnabled) throw new UnsupportedOperationException("Enable assertions to fix this problem -> https://stackoverflow.com/a/68893479/4415884"); - setStartupProperties(); - Props.prepare(); + throwIfLoggerAmbiguous(); -@@ -378,7 +378,7 @@ public class Deployer { + configureObjectMapper(); + + +--- a/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java ++++ b/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/Deployer.java +@@ -471,7 +477,7 @@ public class Deployer { // All other queues (typically to backend services) with a slow-down pattern after // failed delivery qc.add( - new QueueConfiguration().withPattern(".*").withRetryIntervals(standardDelays)); + new QueueConfiguration().withPattern(".*").withRetryIntervals(5/*TODO revert*/)); - - RedisquesConfiguration redisquesConfig = - RedisquesConfiguration.with() + LOGGER.info( + "Redisques redis-client will created with MaxPoolSize: {}, MaxPoolWaiting: {}, MaxWaitingHandlers: {}", + Props.getMaxRedisConnectionPoolSize4RedisQues(), + + diff --git a/src/main/patch/houston/fixidiots.patch b/src/main/patch/houston/fixidiots.patch new file mode 100644 index 0000000..7af8f9d --- /dev/null +++ b/src/main/patch/houston/fixidiots.patch @@ -0,0 +1,365 @@ + + Why is it so fucking hard to just keep out all those random annoying logger + implementations?!? + + Who the heck wants to configure all of them, and if ONE is missed just have + all important error reports concealed to the nirvana? Who the fuck wants such + shit? + + Please: STOP THIS SHIT! Libraries solely have to depend on slf4j. As its name + already says, it is a FACADE! NOT AN IMPLEMENTATION! STOP MESSING THIS UP ALL + THE TIME WITH YET ANOTHER NEW SHITTY NERDY LOGGER IMPL! + + +--- /dev/null ++++ b/houston-process/src/main/java/org/apache/logging/slf4j/Log4jLogger.java +@@ -0,0 +1,109 @@ ++package org.apache.logging.slf4j; ++ ++import org.apache.logging.log4j.spi.ExtendedLogger; ++import org.slf4j.Logger; ++import org.slf4j.Marker; ++import org.slf4j.event.Level; ++import org.slf4j.spi.LocationAwareLogger; ++import org.slf4j.spi.LoggingEventBuilder; ++ ++import java.io.Serializable; ++import java.lang.reflect.Constructor; ++import java.lang.reflect.InvocationTargetException; ++import java.lang.reflect.Method; ++ ++ ++/** <p>FU** this fu***** damn sh** code that still tries to use log4j, no matter ++ * how strong we tell it NOT to use it!</p> ++ * <p>This class only exists to prevent services from starting if IDEA still did miss ++ * the dependency changes in pom and still tries to use the wrong logger impl.</p> */ ++public class Log4jLogger implements LocationAwareLogger, Serializable { ++ ++ private final org.slf4j.Logger log; ++ ++ Log4jLogger(final Log4jMarkerFactory markerFactory, final ExtendedLogger logger, final String name) { ++ try { ++ Class<?> logrFactClz = Class.forName("org.slf4j.simple.SimpleLoggerFactory"); ++ Constructor<?> ctor = logrFactClz.getConstructor(); ++ Method getLoggerFn = logrFactClz.getMethod("getLogger", String.class); ++ this.log = (Logger) getLoggerFn.invoke(ctor.newInstance(), name); ++ } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException ex) { ++ throw new UnsupportedOperationException(ex); ++ } ++ } ++ ++ @Override public void log(Marker marker, String s, int i, String s1, Object[] objects, Throwable throwable) { ++ throw new UnsupportedOperationException(/*TODO*/"Not impl yet"); ++ } ++ ++ @Override public String getName() { return log.getName(); } ++ @Override public LoggingEventBuilder makeLoggingEventBuilder(Level level) { return log.makeLoggingEventBuilder(level); } ++ @Override public LoggingEventBuilder atLevel(Level level) { return log.atLevel(level); } ++ @Override public boolean isEnabledForLevel(Level level) { return log.isEnabledForLevel(level); } ++ @Override public boolean isTraceEnabled() { return log.isTraceEnabled(); } ++ @Override public void trace(String s) { log.trace(s); } ++ @Override public void trace(String s, Object o) { log.trace(s, o); } ++ @Override public void trace(String s, Object o, Object o1) { log.trace(s, o, o1); } ++ @Override public void trace(String s, Object... objects) { log.trace(s, objects); } ++ @Override public void trace(String s, Throwable throwable) { log.trace(s, throwable); } ++ @Override public boolean isTraceEnabled(Marker marker) { return log.isTraceEnabled(marker); } ++ @Override public LoggingEventBuilder atTrace() { return log.atTrace(); } ++ @Override public void trace(Marker marker, String s) { log.trace(marker, s); } ++ @Override public void trace(Marker marker, String s, Object o) { log.trace(marker, s, o); } ++ @Override public void trace(Marker marker, String s, Object o, Object o1) { log.trace(marker, s, o, o1); } ++ @Override public void trace(Marker marker, String s, Object... objects) { log.trace(marker, s, objects); } ++ @Override public void trace(Marker marker, String s, Throwable throwable) { log.trace(marker, s, throwable); } ++ @Override public boolean isDebugEnabled() { return log.isDebugEnabled(); } ++ @Override public void debug(String s) { log.debug(s); } ++ @Override public void debug(String s, Object o) { log.debug(s, o); } ++ @Override public void debug(String s, Object o, Object o1) { log.debug(s, o, o1); } ++ @Override public void debug(String s, Object... objects) { log.debug(s, objects); } ++ @Override public void debug(String s, Throwable throwable) { log.debug(s, throwable); } ++ @Override public boolean isDebugEnabled(Marker marker) { return log.isDebugEnabled(marker); } ++ @Override public void debug(Marker marker, String s) { log.debug(marker, s); } ++ @Override public void debug(Marker marker, String s, Object o) { log.debug(marker, s, o); } ++ @Override public void debug(Marker marker, String s, Object o, Object o1) { log.debug(marker, s, o, o1); } ++ @Override public void debug(Marker marker, String s, Object... objects) { log.debug(marker, s, objects); } ++ @Override public void debug(Marker marker, String s, Throwable throwable) { log.debug(marker, s, throwable); } ++ @Override public LoggingEventBuilder atDebug() { return log.atDebug(); } ++ @Override public boolean isInfoEnabled() { return log.isInfoEnabled(); } ++ @Override public void info(String s) { log.info(s); } ++ @Override public void info(String s, Object o) { log.info(s, o); } ++ @Override public void info(String s, Object o, Object o1) { log.info(s, o, o1); } ++ @Override public void info(String s, Object... objects) { log.info(s, objects); } ++ @Override public void info(String s, Throwable throwable) { log.info(s, throwable); } ++ @Override public boolean isInfoEnabled(Marker marker) { return log.isInfoEnabled(marker); } ++ @Override public void info(Marker marker, String s) { log.info(marker, s); } ++ @Override public void info(Marker marker, String s, Object o) { log.info(marker, s, o); } ++ @Override public void info(Marker marker, String s, Object o, Object o1) { log.info(marker, s, o, o1); } ++ @Override public void info(Marker marker, String s, Object... objects) { log.info(marker, s, objects); } ++ @Override public void info(Marker marker, String s, Throwable throwable) { log.info(marker, s, throwable); } ++ @Override public LoggingEventBuilder atInfo() { return log.atInfo(); } ++ @Override public boolean isWarnEnabled() { return log.isWarnEnabled(); } ++ @Override public void warn(String s) { log.warn(s); } ++ @Override public void warn(String s, Object o) { log.warn(s, o); } ++ @Override public void warn(String s, Object... objects) { log.warn(s, objects); } ++ @Override public void warn(String s, Object o, Object o1) { log.warn(s, o, o1); } ++ @Override public void warn(String s, Throwable throwable) { log.warn(s, throwable); } ++ @Override public boolean isWarnEnabled(Marker marker) { return log.isWarnEnabled(marker); } ++ @Override public void warn(Marker marker, String s) { log.warn(marker, s); } ++ @Override public void warn(Marker marker, String s, Object o) { log.warn(marker, s, o); } ++ @Override public void warn(Marker marker, String s, Object o, Object o1) { log.warn(marker, s, o, o1); } ++ @Override public void warn(Marker marker, String s, Object... objects) { log.warn(marker, s, objects); } ++ @Override public void warn(Marker marker, String s, Throwable throwable) { log.warn(marker, s, throwable); } ++ @Override public LoggingEventBuilder atWarn() { return log.atWarn(); } ++ @Override public boolean isErrorEnabled() { return log.isErrorEnabled(); } ++ @Override public void error(String s) { log.error(s); } ++ @Override public void error(String s, Object o) { log.error(s, o); } ++ @Override public void error(String s, Object o, Object o1) { log.error(s, o, o1); } ++ @Override public void error(String s, Object... objects) { log.error(s, objects); } ++ @Override public void error(String s, Throwable throwable) { log.error(s, throwable); } ++ @Override public boolean isErrorEnabled(Marker marker) { return log.isErrorEnabled(marker); } ++ @Override public void error(Marker marker, String s) { log.error(marker, s); } ++ @Override public void error(Marker marker, String s, Object o) { log.error(marker, s, o); } ++ @Override public void error(Marker marker, String s, Object o, Object o1) { log.error(marker, s, o, o1); } ++ @Override public void error(Marker marker, String s, Object... objects) { log.error(marker, s, objects); } ++ @Override public void error(Marker marker, String s, Throwable throwable) { log.error(marker, s, throwable); } ++ @Override public LoggingEventBuilder atError() { return log.atError(); } ++ ++} + + + +--- /dev/null ++++ b/houston-process/src/main/java/org/slf4j/reload4j/Reload4jLoggerAdapter.java +@@ -0,0 +1,16 @@ ++package org.slf4j.reload4j; ++ ++/** <p>FU** this fu***** damn sh** code that still tries to use log4j, no matter ++ * how strong we tell it NOT to use it!</p> ++ * <p>This class only exists to prevent services from starting if IDEA still did miss ++ * the dependency changes in pom and still tries to use the wrong logger impl.</p> */ ++public class Reload4jLoggerAdapter { ++ ++ public Reload4jLoggerAdapter(org.apache.log4j.Logger l) { ++ throw new UnsupportedOperationException("Fuck those fucking script-kiddies!" ++ + " How fucking hard can it be to just properly setup logging?!?" ++ + " Please !STOP! intermixing interfaces with implementations all the time!" ++ + " This fucking shit just conceals erros all the time! STOP IT!"); ++ } ++ ++} + + +--- /dev/null ++++ b/houston-process/src/main/java/org/slf4j/reload4j/Reload4jServiceProvider.java +@@ -0,0 +1,64 @@ ++package org.slf4j.reload4j; ++ ++import org.slf4j.ILoggerFactory; ++import org.slf4j.IMarkerFactory; ++import org.slf4j.Logger; ++import org.slf4j.Marker; ++import org.slf4j.spi.MDCAdapter; ++import org.slf4j.spi.SLF4JServiceProvider; ++ ++import java.lang.reflect.InvocationTargetException; ++import java.lang.reflect.Method; ++import java.util.Deque; ++import java.util.Map; ++ ++ ++/** <p>How many of those fu**ing damn stupid idiots are still out there ++ * continuing to stubbornly include those stupid logger impls with their ++ * libraries?!?</p> */ ++public class Reload4jServiceProvider implements SLF4JServiceProvider, ILoggerFactory, IMarkerFactory, MDCAdapter { ++ ++ private final Object slf4jSimpleLoggerFactory; ++ private final Method getLoggerFn; ++ ++ public Reload4jServiceProvider() { ++ try { ++ Class<?> logrFactClz = Class.forName("org.slf4j.simple.SimpleLoggerFactory"); ++ slf4jSimpleLoggerFactory = logrFactClz.getConstructor().newInstance(); ++ getLoggerFn = logrFactClz.getMethod("getLogger", String.class); ++ } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException ex) { ++ throw new UnsupportedOperationException(ex); ++ } ++ } ++ ++ @Override public ILoggerFactory getLoggerFactory() { return this; } ++ @Override public IMarkerFactory getMarkerFactory() { return this; } ++ @Override public MDCAdapter getMDCAdapter() { return this; } ++ @Override public String getRequestedApiVersion() { return "2.0"; } ++ @Override public void initialize() {} ++ ++ @Override ++ public Logger getLogger(String name) { ++ try { ++ return (Logger) getLoggerFn.invoke(slf4jSimpleLoggerFactory, name); ++ } catch (IllegalAccessException | InvocationTargetException ex) { ++ throw new RuntimeException(ex); ++ } ++ } ++ ++ @Override public Marker getMarker(String s) { assert false : "TODO not impl yet"; return null; } ++ @Override public boolean exists(String s) { assert false : "TODO not impl yet"; return false; } ++ @Override public boolean detachMarker(String s) { assert false : "TODO not impl yet"; return false; } ++ @Override public Marker getDetachedMarker(String s) { assert false : "TODO not impl yet"; return null; } ++ @Override public void put(String s, String s1) { assert false : "TODO not impl yet"; } ++ @Override public String get(String s) { assert false : "TODO not impl yet"; return null; } ++ @Override public void remove(String s) { assert false : "TODO not impl yet"; } ++ @Override public void clear() { assert false : "TODO not impl yet"; } ++ @Override public Map<String, String> getCopyOfContextMap() { assert false : "TODO not impl yet"; return null; } ++ @Override public void setContextMap(Map<String, String> map) { assert false : "TODO not impl yet"; } ++ @Override public void pushByKey(String s, String s1) { assert false : "TODO not impl yet"; } ++ @Override public String popByKey(String s) { assert false : "TODO not impl yet"; return null; } ++ @Override public Deque<String> getCopyOfDequeByKey(String s) { assert false : "TODO not impl yet"; return null; } ++ @Override public void clearDequeByKey(String s) { assert false : "TODO not impl yet"; } ++ ++} + + +--- /dev/null ++++ b/houston-process/src/main/java/org/apache/logging/slf4j/SLF4JServiceProvider.java +@@ -0,0 +1,62 @@ ++package org.apache.logging.slf4j; ++ ++import org.slf4j.ILoggerFactory; ++import org.slf4j.IMarkerFactory; ++import org.slf4j.Logger; ++import org.slf4j.Marker; ++import org.slf4j.spi.MDCAdapter; ++ ++import java.lang.reflect.InvocationTargetException; ++import java.lang.reflect.Method; ++import java.util.Deque; ++import java.util.Map; ++ ++ ++/** <p>How many of those fu**ing damn stupid idiotic libs are still out there ++ * continuing to stubbornly include those stupid logger impls?!?</p> */ ++public class SLF4JServiceProvider implements org.slf4j.spi.SLF4JServiceProvider, ILoggerFactory, IMarkerFactory, MDCAdapter { ++ ++ private final Object slf4jSimpleLoggerFactory; ++ private final Method getLoggerFn; ++ ++ public SLF4JServiceProvider() { ++ try { ++ Class<?> logrFactClz = Class.forName("org.slf4j.simple.SimpleLoggerFactory"); ++ slf4jSimpleLoggerFactory = logrFactClz.getConstructor().newInstance(); ++ getLoggerFn = logrFactClz.getMethod("getLogger", String.class); ++ } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException ex) { ++ throw new UnsupportedOperationException(ex); ++ } ++ } ++ ++ @Override public ILoggerFactory getLoggerFactory() { return this; } ++ @Override public IMarkerFactory getMarkerFactory() { return this; } ++ @Override public MDCAdapter getMDCAdapter() { return this; } ++ @Override public String getRequestedApiVersion() { return "2.0"; } ++ @Override public void initialize() {} ++ ++ @Override ++ public Logger getLogger(String name) { ++ try { ++ return (Logger) getLoggerFn.invoke(slf4jSimpleLoggerFactory, name); ++ } catch (IllegalAccessException | InvocationTargetException ex) { ++ throw new RuntimeException(ex); ++ } ++ } ++ ++ @Override public Marker getMarker(String s) { assert false : "TODO not impl yet"; return null; } ++ @Override public boolean exists(String s) { assert false : "TODO not impl yet"; return false; } ++ @Override public boolean detachMarker(String s) { assert false : "TODO not impl yet"; return false; } ++ @Override public Marker getDetachedMarker(String s) { assert false : "TODO not impl yet"; return null; } ++ @Override public void put(String s, String s1) { assert false : "TODO not impl yet"; } ++ @Override public String get(String s) { assert false : "TODO not impl yet"; return null; } ++ @Override public void remove(String s) { assert false : "TODO not impl yet"; } ++ @Override public void clear() { assert false : "TODO not impl yet"; } ++ @Override public Map<String, String> getCopyOfContextMap() { assert false : "TODO not impl yet"; return null; } ++ @Override public void setContextMap(Map<String, String> map) { assert false : "TODO not impl yet"; } ++ @Override public void pushByKey(String s, String s1) { assert false : "TODO not impl yet"; } ++ @Override public String popByKey(String s) { assert false : "TODO not impl yet"; return null; } ++ @Override public Deque<String> getCopyOfDequeByKey(String s) { assert false : "TODO not impl yet"; return null; } ++ @Override public void clearDequeByKey(String s) { assert false : "TODO not impl yet"; } ++ ++} + + +--- /dev/null ++++ b/houston-process/src/main/java/net/bull/javamelody/internal/common/Log4J2Logger.java +@@ -0,0 +1,38 @@ ++package net.bull.javamelody.internal.common; ++ ++import org.slf4j.Logger; ++ ++import javax.servlet.http.HttpServletRequest; ++import java.lang.reflect.InvocationTargetException; ++import java.lang.reflect.Method; ++ ++ ++/** <p>How many of those fu**ing damn stupid idiot libs are still out there ++ * continuing to stubbornly include those stupid logger impls?!?</p> */ ++public class Log4J2Logger implements net.bull.javamelody.JavaMelodyLogger { ++ ++ private final org.slf4j.Logger log; ++ ++ public Log4J2Logger(){ ++ try { ++ Class<?> logrFactClz = Class.forName("org.slf4j.simple.SimpleLoggerFactory"); ++ Object slf4jSimpleLoggerFactory = logrFactClz.getConstructor().newInstance(); ++ Method getLoggerFn = logrFactClz.getMethod("getLogger", String.class); ++ this.log = (Logger) getLoggerFn.invoke(slf4jSimpleLoggerFactory, "net.bull.javamelody"); ++ } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException ex) { ++ throw new UnsupportedOperationException(ex); ++ } ++ } ++ ++ @Override public void debug(String s) { log.debug(s); } ++ @Override public void debug(String s, Throwable ex) { log.debug(s, ex); } ++ @Override public void info(String s) { log.info(s); } ++ @Override public void info(String s, Throwable ex) { log.info(s, ex);} ++ @Override public void warn(String s, Throwable ex) { log.warn(s, ex);} ++ @Override public void logHttpRequest( ++ HttpServletRequest httpRequest, String requestName, long duration, boolean systemError, int responseStatus, long responseSize, String loggerName ++ ){ ++ if (log.isInfoEnabled()) log.info("{}", LOG.buildLogMessage(httpRequest, duration, systemError, responseStatus, responseSize)); ++ } ++ ++} + + +--- /dev/null ++++ b/houston-process/src/main/java/org/eclipse/jetty/util/log/Slf4jLog.java +@@ -0,0 +1,32 @@ ++package org.eclipse.jetty.util.log; ++ ++import org.slf4j.LoggerFactory; ++ ++ ++/** Yet another fu**ing bastard lib having its own shiny stupid loggers. */ ++public class Slf4jLog { ++ ++ private final org.slf4j.Logger log; ++ ++ public Slf4jLog() { ++ this.log = LoggerFactory.getLogger("org.eclipse.jetty.util.log"); ++ } ++ ++ public Slf4jLog(String name) { ++ this.log = LoggerFactory.getLogger(name); ++ } ++ ++ public String getName() { return log.getName(); } ++ public void warn(String msg, Object... args) { log.warn(msg, args); } ++ public void warn(Throwable thrown) { log.warn("", thrown); } ++ public void warn(String msg, Throwable thrown) { log.warn(msg, thrown); } ++ public void info(String msg, Object... args) { log.info(msg, args); } ++ public void info(Throwable thrown) { log.info("", thrown); } ++ public void info(String msg, Throwable thrown) { log.info(msg, thrown); } ++ public void debug(String msg, Object... args) { log.debug(msg, args); } ++ public void debug(String msg, long arg) { if (log.isDebugEnabled()) log.debug(msg, arg); } ++ public void debug(Throwable thrown) { this.debug("", thrown); } ++ public void debug(String msg, Throwable thrown) { log.debug(msg, thrown); } ++ public boolean isDebugEnabled() { return log.isDebugEnabled(); } ++ public void setDebugEnabled(boolean enabled) { log.warn("setDebugEnabled not implemented"); } ++ ++} + diff --git a/src/main/patch/houston/future.patch b/src/main/patch/houston/future.patch new file mode 100644 index 0000000..2ac5922 --- /dev/null +++ b/src/main/patch/houston/future.patch @@ -0,0 +1,47 @@ + + Some patches that maybe will become relevant in future. For example bcause a + PR is no yet merged or similar. + + +--- /dev/null ++++ b/houston-process/src/main/java/net/bull/javamelody/internal/common/Log4J2Logger.java +@@ -22,1 +22,1 @@ + if (!iLoaders.hasNext()) throw new IllegalStateException("Too few logger impls"); + SLF4JServiceProvider loggerProvider = iLoaders.next(); +- if (iLoaders.hasNext()) throw new IllegalStateException("Too many logger impls"); ++ if (!(loggerProvider instanceof org.slf4j.simple.SimpleServiceProvider) && iLoaders.hasNext()) throw new IllegalStateException("Too many logger impls"); + loggerProvider.initialize(); + ILoggerFactory loggerFactory = loggerProvider.getLoggerFactory(); + + +--- /dev/null ++++ b/houston-process/src/main/java/ch/post/it/paisa/houston/process/main/BadLoggerImplKiller.java +@@ -0,0 +1,26 @@ ++package ch.post.it.paisa.houston.process.main; ++ ++import org.slf4j.spi.SLF4JServiceProvider; ++ ++import java.util.ServiceLoader; ++ ++ ++public class BadLoggerImplKiller { ++ ++ public static void assertExactlyOneLoggerImplPresent(){ ++ Class<?> log4jProviderClz, simpleProviderClz; ++ try { ++ log4jProviderClz = Class.forName("org.apache.logging.slf4j.SLF4JServiceProvider"); ++ simpleProviderClz = Class.forName("org.slf4j.simple.SimpleServiceProvider"); ++ }catch( ClassNotFoundException ex ){ ++ throw new RuntimeException(ex); ++ } ++ for( SLF4JServiceProvider provider : ServiceLoader.load(SLF4JServiceProvider.class) ){ ++ Class<?> providerClass = provider.getClass(); ++ if( log4jProviderClz.isAssignableFrom(providerClass) ) continue; ++ if( simpleProviderClz.isAssignableFrom(providerClass) ) continue; ++ throw new IllegalStateException("Go away with this ugly logger: "+ providerClass.getName()); ++ } ++ } ++ ++} + + |