implemented streaming request/response streaming

added metadata to cache values added cache servlet for comparison
2025-02-19 22:36:31 +08:00
parent 0463038aaa
commit f048a60540
66 changed files with 2474 additions and 1078 deletions
--- a/rbcs-common/src/main/java/module-info.java
+++ b/rbcs-common/src/main/java/module-info.java
@@ -5,6 +5,7 @@ module net.woggioni.rbcs.common {
    requires kotlin.stdlib;
    requires net.woggioni.jwo;
    requires io.netty.buffer;
+    requires io.netty.transport;

    provides java.net.spi.URLStreamHandlerProvider with net.woggioni.rbcs.common.RbcsUrlStreamHandlerFactory;
    exports net.woggioni.rbcs.common;
--- a/rbcs-common/src/main/kotlin/net/woggioni/rbcs/common/Logging.kt
+++ b/rbcs-common/src/main/kotlin/net/woggioni/rbcs/common/Logging.kt
@@ -1,90 +1,173 @@
 package net.woggioni.rbcs.common

+import io.netty.channel.ChannelHandlerContext
+import io.netty.channel.Channel
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
+import org.slf4j.MDC
 import org.slf4j.event.Level
+import org.slf4j.spi.LoggingEventBuilder
 import java.nio.file.Files
 import java.nio.file.Path
 import java.util.logging.LogManager

 inline fun <reified T> T.contextLogger() = LoggerFactory.getLogger(T::class.java)
+inline fun <reified T> createLogger() = LoggerFactory.getLogger(T::class.java)

-inline fun Logger.traceParam(messageBuilder : () -> Pair<String, Array<Any>>) {
-    if(isTraceEnabled) {
+inline fun Logger.traceParam(messageBuilder: () -> Pair<String, Array<Any>>) {
+    if (isTraceEnabled) {
        val (format, params) = messageBuilder()
        trace(format, params)
    }
 }

-inline fun Logger.debugParam(messageBuilder : () -> Pair<String, Array<Any>>) {
-    if(isDebugEnabled) {
+inline fun Logger.debugParam(messageBuilder: () -> Pair<String, Array<Any>>) {
+    if (isDebugEnabled) {
        val (format, params) = messageBuilder()
        info(format, params)
    }
 }

-inline fun Logger.infoParam(messageBuilder : () -> Pair<String, Array<Any>>) {
-    if(isInfoEnabled) {
+inline fun Logger.infoParam(messageBuilder: () -> Pair<String, Array<Any>>) {
+    if (isInfoEnabled) {
        val (format, params) = messageBuilder()
        info(format, params)
    }
 }

-inline fun Logger.warnParam(messageBuilder : () -> Pair<String, Array<Any>>) {
-    if(isWarnEnabled) {
+inline fun Logger.warnParam(messageBuilder: () -> Pair<String, Array<Any>>) {
+    if (isWarnEnabled) {
        val (format, params) = messageBuilder()
        warn(format, params)
    }
 }

-inline fun Logger.errorParam(messageBuilder : () -> Pair<String, Array<Any>>) {
-    if(isErrorEnabled) {
+inline fun Logger.errorParam(messageBuilder: () -> Pair<String, Array<Any>>) {
+    if (isErrorEnabled) {
        val (format, params) = messageBuilder()
        error(format, params)
    }
 }


-inline fun log(log : Logger,
-               filter : Logger.() -> Boolean,
-               loggerMethod : Logger.(String) -> Unit, messageBuilder : () -> String) {
-    if(log.filter()) {
+inline fun log(
+    log: Logger,
+    filter: Logger.() -> Boolean,
+    loggerMethod: Logger.(String) -> Unit, messageBuilder: () -> String
+) {
+    if (log.filter()) {
        log.loggerMethod(messageBuilder())
    }
 }

-inline fun Logger.log(level : Level, messageBuilder : () -> String) {
-    if(isEnabledForLevel(level)) {
+fun withMDC(params: Array<Pair<String, String>>, cb: () -> Unit) {
+    object : AutoCloseable {
+        override fun close() {
+            for ((key, _) in params) MDC.remove(key)
+        }
+    }.use {
+        for ((key, value) in params) MDC.put(key, value)
+        cb()
+    }
+}
+
+inline fun Logger.log(level: Level, channel: Channel, crossinline messageBuilder: (LoggingEventBuilder) -> Unit ) {
+    if (isEnabledForLevel(level)) {
+        val params = arrayOf<Pair<String, String>>(
+            "channel-id-short" to channel.id().asShortText(),
+            "channel-id-long" to channel.id().asLongText(),
+            "remote-address" to channel.remoteAddress().toString(),
+            "local-address" to channel.localAddress().toString(),
+        )
+        withMDC(params) {
+            val builder = makeLoggingEventBuilder(level)
+//            for ((key, value) in params) {
+//                builder.addKeyValue(key, value)
+//            }
+            messageBuilder(builder)
+            builder.log()
+        }
+    }
+}
+inline fun Logger.log(level: Level, channel: Channel, crossinline messageBuilder: () -> String) {
+    log(level, channel) { builder ->
+        builder.setMessage(messageBuilder())
+    }
+}
+
+inline fun Logger.trace(ch: Channel, crossinline messageBuilder: () -> String) {
+    log(Level.TRACE, ch, messageBuilder)
+}
+
+inline fun Logger.debug(ch: Channel, crossinline messageBuilder: () -> String) {
+    log(Level.DEBUG, ch, messageBuilder)
+}
+
+inline fun Logger.info(ch: Channel, crossinline messageBuilder: () -> String) {
+    log(Level.INFO, ch, messageBuilder)
+}
+
+inline fun Logger.warn(ch: Channel, crossinline messageBuilder: () -> String) {
+    log(Level.WARN, ch, messageBuilder)
+}
+
+inline fun Logger.error(ch: Channel, crossinline messageBuilder: () -> String) {
+    log(Level.ERROR, ch, messageBuilder)
+}
+
+inline fun Logger.trace(ctx: ChannelHandlerContext, crossinline messageBuilder: () -> String) {
+    log(Level.TRACE, ctx.channel(), messageBuilder)
+}
+
+inline fun Logger.debug(ctx: ChannelHandlerContext, crossinline messageBuilder: () -> String) {
+    log(Level.DEBUG, ctx.channel(), messageBuilder)
+}
+
+inline fun Logger.info(ctx: ChannelHandlerContext, crossinline messageBuilder: () -> String) {
+    log(Level.INFO, ctx.channel(), messageBuilder)
+}
+
+inline fun Logger.warn(ctx: ChannelHandlerContext, crossinline messageBuilder: () -> String) {
+    log(Level.WARN, ctx.channel(), messageBuilder)
+}
+
+inline fun Logger.error(ctx: ChannelHandlerContext, crossinline messageBuilder: () -> String) {
+    log(Level.ERROR, ctx.channel(), messageBuilder)
+}
+
+
+inline fun Logger.log(level: Level, messageBuilder: () -> String) {
+    if (isEnabledForLevel(level)) {
        makeLoggingEventBuilder(level).log(messageBuilder())
    }
 }

-inline fun Logger.trace(messageBuilder : () -> String) {
-    if(isTraceEnabled) {
+inline fun Logger.trace(messageBuilder: () -> String) {
+    if (isTraceEnabled) {
        trace(messageBuilder())
    }
 }

-inline fun Logger.debug(messageBuilder : () -> String) {
-    if(isDebugEnabled) {
+inline fun Logger.debug(messageBuilder: () -> String) {
+    if (isDebugEnabled) {
        debug(messageBuilder())
    }
 }

-inline fun Logger.info(messageBuilder : () -> String) {
-    if(isInfoEnabled) {
+inline fun Logger.info(messageBuilder: () -> String) {
+    if (isInfoEnabled) {
        info(messageBuilder())
    }
 }

-inline fun Logger.warn(messageBuilder : () -> String) {
-    if(isWarnEnabled) {
+inline fun Logger.warn(messageBuilder: () -> String) {
+    if (isWarnEnabled) {
        warn(messageBuilder())
    }
 }

-inline fun Logger.error(messageBuilder : () -> String) {
-    if(isErrorEnabled) {
+inline fun Logger.error(messageBuilder: () -> String) {
+    if (isErrorEnabled) {
        error(messageBuilder())
    }
 }
@@ -94,9 +177,9 @@ class LoggingConfig {

    init {
        val logManager = LogManager.getLogManager()
-        System.getProperty("log.config.source")?.let withSource@ { source ->
+        System.getProperty("log.config.source")?.let withSource@{ source ->
            val urls = LoggingConfig::class.java.classLoader.getResources(source)
-            while(urls.hasMoreElements()) {
+            while (urls.hasMoreElements()) {
                val url = urls.nextElement()
                url.openStream().use { inputStream ->
                    logManager.readConfiguration(inputStream)
--- a/rbcs-common/src/main/kotlin/net/woggioni/rbcs/common/RBCS.kt
+++ b/rbcs-common/src/main/kotlin/net/woggioni/rbcs/common/RBCS.kt
@@ -44,4 +44,18 @@ object RBCS {
    ): String {
        return JWO.bytesToHex(digest(data, md))
    }
+
+    fun processCacheKey(key: String, digestAlgorithm: String?) = digestAlgorithm
+        ?.let(MessageDigest::getInstance)
+        ?.let { md ->
+            digest(key.toByteArray(), md)
+        } ?: key.toByteArray(Charsets.UTF_8)
+
+    fun Long.toIntOrNull(): Int? {
+        return if (this >= Int.MIN_VALUE && this <= Int.MAX_VALUE) {
+            toInt()
+        } else {
+            null
+        }
+    }
 }
--- a/rbcs-common/src/main/kotlin/net/woggioni/rbcs/common/Xml.kt
+++ b/rbcs-common/src/main/kotlin/net/woggioni/rbcs/common/Xml.kt
@@ -79,7 +79,7 @@ class Xml(val doc: Document, val element: Element) {
    class ErrorHandler(private val fileURL: URL) : ErrHandler {

        companion object {
-            private val log = LoggerFactory.getLogger(ErrorHandler::class.java)
+            private val log = createLogger<ErrorHandler>()
        }

         override fun warning(ex: SAXParseException)= err(ex, Level.WARN)