temporary commit

gbcs-base/build.gradle

@@ -0,0 +1,21 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    id 'java-library'
+    alias catalog.plugins.kotlin.jvm
+}
+
+dependencies {
+    compileOnly project(':gbcs-api')
+    compileOnly catalog.slf4j.api
+}
+
+tasks.named(JavaPlugin.COMPILE_JAVA_TASK_NAME, JavaCompile) {
+    options.compilerArgs << '--patch-module' << 'net.woggioni.gbcs.base=' + project.sourceSets.main.output.asPath
+    options.javaModuleVersion = version
+}
+
+tasks.named("compileKotlin", KotlinCompile.class) {
+    compilerOptions.jvmTarget = JvmTarget.JVM_21
+}

gbcs-base/src/main/java/module-info.java

@@ -0,0 +1,8 @@
+module net.woggioni.gbcs.base {
+    requires java.xml;
+    requires java.logging;
+    requires org.slf4j;
+    requires kotlin.stdlib;
+
+    exports net.woggioni.gbcs.base;
+}

gbcs-base/src/main/kotlin/net/woggioni/gbcs/base/GBCS.kt

@@ -0,0 +1,12 @@
+package net.woggioni.gbcs.base
+
+import java.net.URI
+import java.net.URL
+
+object GBCS {
+    fun String.toUrl() : URL = URL.of(URI(this), null)
+
+    const val GBCS_NAMESPACE_URI: String = "urn:net.woggioni.gbcs"
+    const val GBCS_PREFIX: String = "gbcs"
+    const val XML_SCHEMA_NAMESPACE_URI = "http://www.w3.org/2001/XMLSchema-instance"
+}

gbcs-base/src/main/kotlin/net/woggioni/gbcs/base/HostAndPort.kt

@@ -0,0 +1,8 @@
+package net.woggioni.gbcs.base
+
+
+data class HostAndPort(val host: String, val port: Int = 0) {
+    override fun toString(): String {
+        return "$host:$port"
+    }
+}

gbcs-base/src/main/kotlin/net/woggioni/gbcs/base/Logging.kt

@@ -0,0 +1,104 @@
+package net.woggioni.gbcs.base
+
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+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 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) {
+        val (format, params) = messageBuilder()
+        info(format, params)
+    }
+}
+
+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) {
+        val (format, params) = messageBuilder()
+        warn(format, params)
+    }
+}
+
+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()) {
+        log.loggerMethod(messageBuilder())
+    }
+}
+
+inline fun Logger.trace(messageBuilder : () -> String) {
+    if(isTraceEnabled) {
+        trace(messageBuilder())
+    }
+}
+
+inline fun Logger.debug(messageBuilder : () -> String) {
+    if(isDebugEnabled) {
+        debug(messageBuilder())
+    }
+}
+
+inline fun Logger.info(messageBuilder : () -> String) {
+    if(isInfoEnabled) {
+        info(messageBuilder())
+    }
+}
+
+inline fun Logger.warn(messageBuilder : () -> String) {
+    if(isWarnEnabled) {
+        warn(messageBuilder())
+    }
+}
+
+inline fun Logger.error(messageBuilder : () -> String) {
+    if(isErrorEnabled) {
+        error(messageBuilder())
+    }
+}
+
+
+class LoggingConfig {
+
+    init {
+        val logManager = LogManager.getLogManager()
+        System.getProperty("log.config.source")?.let withSource@ { source ->
+            val urls = LoggingConfig::class.java.classLoader.getResources(source)
+            while(urls.hasMoreElements()) {
+                val url = urls.nextElement()
+                url.openStream().use { inputStream ->
+                    logManager.readConfiguration(inputStream)
+                    return@withSource
+                }
+            }
+            Path.of(source).takeIf(Files::exists)
+                ?.let(Files::newInputStream)
+                ?.use(logManager::readConfiguration)
+        }
+    }
+}

gbcs-base/src/main/kotlin/net/woggioni/gbcs/base/Xml.kt

@@ -0,0 +1,269 @@
+package net.woggioni.gbcs.base
+
+import org.slf4j.LoggerFactory
+import org.w3c.dom.Document
+import org.w3c.dom.Element
+import org.w3c.dom.Node
+import org.w3c.dom.NodeList
+import org.xml.sax.SAXNotRecognizedException
+import org.xml.sax.SAXNotSupportedException
+import org.xml.sax.SAXParseException
+import java.io.InputStream
+import java.io.OutputStream
+import java.net.URL
+import javax.xml.XMLConstants.ACCESS_EXTERNAL_DTD
+import javax.xml.XMLConstants.ACCESS_EXTERNAL_SCHEMA
+import javax.xml.XMLConstants.FEATURE_SECURE_PROCESSING
+import javax.xml.XMLConstants.W3C_XML_SCHEMA_NS_URI
+import javax.xml.parsers.DocumentBuilder
+import javax.xml.parsers.DocumentBuilderFactory
+import javax.xml.transform.OutputKeys
+import javax.xml.transform.TransformerFactory
+import javax.xml.transform.dom.DOMSource
+import javax.xml.transform.stream.StreamResult
+import javax.xml.transform.stream.StreamSource
+import javax.xml.validation.Schema
+import javax.xml.validation.SchemaFactory
+import org.xml.sax.ErrorHandler as ErrHandler
+
+
+class NodeListIterator(private val nodeList: NodeList) : Iterator<Node> {
+    private var cursor: Int = 0
+    override fun hasNext(): Boolean {
+        return cursor < nodeList.length
+    }
+
+    override fun next(): Node {
+        return if (hasNext()) nodeList.item(cursor++) else throw NoSuchElementException()
+    }
+}
+
+class ElementIterator(parent: Element, name: String? = null) : Iterator<Element> {
+    private val it: NodeListIterator
+    private val name: String?
+    private var next: Element?
+
+    init {
+        it = NodeListIterator(parent.childNodes)
+        this.name = name
+        next = getNext()
+    }
+
+    override fun hasNext(): Boolean {
+        return next != null
+    }
+
+    override fun next(): Element {
+        val result = next ?: throw NoSuchElementException()
+        next = getNext()
+        return result
+    }
+
+    private fun getNext(): Element? {
+        var result: Element? = null
+        while (it.hasNext()) {
+            val node: Node = it.next()
+            if (node is Element && (name == null || name == node.tagName)) {
+                result = node
+                break
+            }
+        }
+        return result
+    }
+}
+
+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)
+        }
+
+        override fun warning(ex: SAXParseException) {
+            log.warn(
+                "Problem at {}:{}:{} parsing deployment configuration: {}",
+                fileURL, ex.lineNumber, ex.columnNumber, ex.message
+            )
+        }
+
+        override fun error(ex: SAXParseException) {
+            log.error(
+                "Problem at {}:{}:{} parsing deployment configuration: {}",
+                fileURL, ex.lineNumber, ex.columnNumber, ex.message
+            )
+            throw ex
+        }
+
+        override fun fatalError(ex: SAXParseException) {
+            log.error(
+                "Problem at {}:{}:{} parsing deployment configuration: {}",
+                fileURL, ex.lineNumber, ex.columnNumber, ex.message
+            )
+            throw ex
+        }
+    }
+
+    companion object {
+        fun Element.asIterable() = Iterable { ElementIterator(this, null) }
+        fun NodeList.asIterable() = Iterable { NodeListIterator(this) }
+
+        private fun disableProperty(dbf: DocumentBuilderFactory, propertyName: String) {
+            try {
+                dbf.setAttribute(propertyName, "")
+            } catch (iae: IllegalArgumentException) {
+                // Property not supported.
+            }
+        }
+
+        private fun disableProperty(sf: SchemaFactory, propertyName: String) {
+            try {
+                sf.setProperty(propertyName, "")
+            } catch (ex: SAXNotRecognizedException) {
+                // Property not supported.
+            } catch (ex: SAXNotSupportedException) {
+            }
+        }
+
+        fun getSchema(schema: URL): Schema {
+            val sf = SchemaFactory.newInstance(W3C_XML_SCHEMA_NS_URI)
+            sf.setFeature(FEATURE_SECURE_PROCESSING, false)
+//        disableProperty(sf, ACCESS_EXTERNAL_SCHEMA)
+//        disableProperty(sf, ACCESS_EXTERNAL_DTD)
+            sf.errorHandler = ErrorHandler(schema)
+            return sf.newSchema(schema)
+        }
+
+        fun getSchema(inputStream: InputStream): Schema {
+            val sf = SchemaFactory.newInstance(W3C_XML_SCHEMA_NS_URI)
+            sf.setFeature(FEATURE_SECURE_PROCESSING, true)
+//        disableProperty(sf, ACCESS_EXTERNAL_SCHEMA)
+//        disableProperty(sf, ACCESS_EXTERNAL_DTD)
+            return sf.newSchema(StreamSource(inputStream))
+        }
+
+        fun newDocumentBuilderFactory(schemaResourceURL: URL?): DocumentBuilderFactory {
+            val dbf = DocumentBuilderFactory.newInstance()
+            dbf.setFeature(FEATURE_SECURE_PROCESSING, false)
+//            disableProperty(dbf, ACCESS_EXTERNAL_SCHEMA)
+            dbf.setAttribute(ACCESS_EXTERNAL_SCHEMA, "all")
+            disableProperty(dbf, ACCESS_EXTERNAL_DTD)
+            dbf.isExpandEntityReferences = true
+            dbf.isIgnoringComments = true
+            dbf.isNamespaceAware = true
+            dbf.isValidating = false
+            dbf.setFeature("http://apache.org/xml/features/validation/schema", true);
+            schemaResourceURL?.let {
+                dbf.schema = getSchema(it)
+            }
+            return dbf
+        }
+
+    fun newDocumentBuilder(resource: URL, schemaResourceURL: URL?): DocumentBuilder {
+        val db = newDocumentBuilderFactory(schemaResourceURL).newDocumentBuilder()
+        db.setErrorHandler(ErrorHandler(resource))
+        return db
+    }
+
+    fun parseXmlResource(resource: URL, schemaResourceURL: URL?): Document {
+        val db = newDocumentBuilder(resource, schemaResourceURL)
+        return resource.openStream().use(db::parse)
+    }
+
+    fun parseXml(sourceURL : URL, sourceStream: InputStream? = null, schemaResourceURL: URL? = null): Document {
+        val db = newDocumentBuilder(sourceURL, schemaResourceURL)
+        return sourceStream?.let(db::parse) ?: sourceURL.openStream().use(db::parse)
+    }
+
+//
+//    fun newDocumentBuilder(resource: URL): DocumentBuilder {
+//        val db = newDocumentBuilderFactory(null).newDocumentBuilder()
+//        db.setErrorHandler(XmlErrorHandler(resource))
+//        return db
+//    }
+
+//    fun parseXmlResource(resource: URL): Document {
+//        val db = newDocumentBuilder(resource, null)
+//        return resource.openStream().use(db::parse)
+//    }
+
+        fun write(doc: Document, output: OutputStream) {
+            val transformerFactory = TransformerFactory.newInstance()
+            val transformer = transformerFactory.newTransformer()
+            transformer.setOutputProperty(OutputKeys.INDENT, "yes")
+//            val domImpl = doc.getImplementation()
+//            val docType = domImpl.createDocumentType(
+//                "plist",
+//                "-//Apple//DTD PLIST 1.0//EN",
+//                "http://www.apple.com/DTDs/PropertyList-1.0.dtd"
+//            )
+//            transformer.setOutputProperty(OutputKeys.DOCTYPE_PUBLIC, docType.getPublicId())
+//            transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, docType.getSystemId())
+//            val transformerFactory = TransformerFactory.newInstance()
+//            val transformer: Transformer = transformerFactory.newTransformer()
+            transformer.setOutputProperty(OutputKeys.INDENT, "yes")
+            transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4")
+            transformer.setOutputProperty(OutputKeys.STANDALONE, "yes")
+            transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8")
+            val source = DOMSource(doc)
+            val result = StreamResult(output)
+            transformer.transform(source, result)
+        }
+
+        fun of(namespaceURI: String, qualifiedName: String, schemaResourceURL: URL? = null, cb: Xml.(el: Element) -> Unit): Document {
+            val dbf = newDocumentBuilderFactory(schemaResourceURL)
+            val db = dbf.newDocumentBuilder()
+            val doc = db.newDocument()
+            val root = doc.createElementNS(namespaceURI, qualifiedName)
+                .also(doc::appendChild)
+            Xml(doc, root).cb(root)
+            return doc
+        }
+
+        fun of(doc: Document, el: Element, cb: Xml.(el: Element) -> Unit): Element {
+            Xml(doc, el).cb(el)
+            return el
+        }
+
+        fun Element.removeChildren() {
+            while (true) {
+                removeChild(firstChild ?: break)
+            }
+        }
+
+    }
+
+    fun node(
+        name: String,
+        namespaceURI : String? = null,
+        attrs: Map<String, String> = emptyMap(),
+        cb: Xml.(el: Element) -> Unit = {}
+    ): Element {
+        val child = doc.createElementNS(namespaceURI, name)
+        for ((key, value) in attrs) {
+            child.setAttribute(key, value)
+        }
+        return child
+            .also {
+                element.appendChild(it)
+                Xml(doc, it).cb(it)
+            }
+    }
+
+
+//    fun attrs(vararg attributes: Pair<String, String>) {
+//        for (attr in attributes) element.setAttribute(attr.first, attr.second)
+//    }
+//
+//    fun attrs(vararg attributes: Pair<Pair<String?, String>, String>) {
+//        for (attr in attributes) element.setAttributeNS(attr.first.first, attr.first.second, attr.second)
+//    }
+
+    fun attr(key: String, value: String, namespaceURI : String? = null) {
+        element.setAttributeNS(namespaceURI, key, value)
+    }
+
+    fun text(txt: String) {
+        element.appendChild(doc.createTextNode(txt))
+    }
+}