TH2-3857

README.md

@@ -1,5 +1,5 @@
-# Codec Xml via Xsd
-![version](https://img.shields.io/badge/version-0.0.3-blue.svg)
+# Codec Xml via Xsd (0.0.5)
+![version](https://img.shields.io/badge/version-0.0.4-blue.svg)
 
 # How it works:
 
@@ -57,13 +57,18 @@ Error from validation process can be disabled for test purposes by `dirtyValidat
 ### Configuration example
 
 * typePointer - Path to message type value for decode (null by default)
+* encodeValidation - This flag determines if messages are validated
+during encoding (false by default). Note: this validation will significantly 
+slow down the performance and requires an archive of XSDs
+
+## Temporary disabled
 * dirtyValidation - Disable/enable error during validation phase. If disabled all errors will be only visible in log  (false by default)
 * expectsDeclaration - Disable/enable validation of declaration - is it exist or not (true by default)
 
 ```yaml
 typePointer: /root/node/node2/type
-dirtyValidation: false
-expectsDeclaration: false
+#dirtyValidation: false
+#expectsDeclaration: false
 ```
 
 For example:
@@ -77,7 +82,7 @@ spec:
   custom-config:
     codecSettings:
       typePointer: /root/node/node2/type
-      dirtyValidation: false
+#      dirtyValidation: false
 ```
 
 ## Required pins
@@ -142,6 +147,18 @@ spec:
 
 ## Changelog
 
+### v0.0.5
+
+* Migrate to StAX parser
+* Migrated from common:3.31.5 to common:3.40.0
+* Migrated from bom:3.1.0 to common:3.2.0
+
+### v0.0.4
+
+#### Feature:
+
+* Self-closing tags are ignored by the codec
+
 ### v0.0.3
 
 #### Feature:
@@ -159,4 +176,4 @@ spec:
 
 #### Feature:
 
-* First realization using underscore library as parser for json
+* First realization using underscore library as parser for json

build.gradle

@@ -22,7 +22,6 @@ plugins {
 
 ext {
     sharedDir = file("${project.rootDir}/shared")
-    sailfishVersion = '3.2.1752'
 }
 
 group = 'com.exactpro.th2'
@@ -67,22 +66,22 @@ jar {
 }
 
 dependencies {
-    api platform('com.exactpro.th2:bom:3.1.0')
-    implementation 'com.exactpro.th2:common:3.31.5'
-    implementation 'com.exactpro.th2:codec:4.2.0'
-    implementation 'com.exactpro.th2:sailfish-utils:3.12.3'
-
-    implementation "com.exactpro.sf:sailfish-core:${sailfishVersion}"
+    api platform('com.exactpro.th2:bom:3.2.0')
+    implementation 'com.exactpro.th2:common:3.40.0'
+    implementation 'com.exactpro.th2:codec:4.7.2'
 
     implementation 'org.slf4j:slf4j-log4j12'
     implementation 'org.slf4j:slf4j-api'
 
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:${kotlin_version}"
     implementation "org.jetbrains.kotlin:kotlin-reflect:${kotlin_version}"
+    implementation 'io.github.microutils:kotlin-logging:2.1.21'
 
     implementation 'com.fasterxml.jackson.core:jackson-core:2.13.1'
     implementation 'com.github.javadev:underscore:1.69'
-
+
+    implementation group: 'org.apache.ws.xmlschema', name: 'xmlschema-core', version: '2.3.0'
+
     testImplementation "org.jetbrains.kotlin:kotlin-test-junit5:${kotlin_version}"
     testImplementation "org.junit.jupiter:junit-jupiter-api:${junitVersion}"
     testImplementation "org.junit.jupiter:junit-jupiter-params:${junitVersion}"

gradle.properties

@@ -13,8 +13,8 @@
 # limitations under the License.
 #
 
-release_version=0.0.3
-kotlin_version=1.5.31
+release_version=0.0.5
+kotlin_version=1.5.32
 description = 'th2 codec xml via xsd'
 
 vcs_url=https://github.com/th2-net/th2-codec-xml-via-xsd

src/main/kotlin/com/exactpro/th2/codec/xml/NodeContent.kt

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2022 Exactpro (Exactpro Systems Limited)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.exactpro.th2.codec.xml
+
+import com.exactpro.th2.common.grpc.Message
+import com.exactpro.th2.common.grpc.MessageMetadata
+import com.exactpro.th2.common.grpc.Value
+import com.exactpro.th2.common.message.addField
+import com.exactpro.th2.common.value.toValue
+import javax.xml.namespace.QName
+
+class NodeContent(
+    private val nodeName: QName,
+    decorator: XmlCodecStreamReader
+) {
+    private val messageBuilder = Message.newBuilder().apply {
+        metadata = MessageMetadata.getDefaultInstance() //FIXME: remove
+    }
+    private val textSB = StringBuilder()
+
+    private val childNodes: MutableMap<QName, MutableList<NodeContent>> = mutableMapOf()
+    private var isMessage: Boolean = false
+    private val isEmpty: Boolean
+        get() = !isMessage && textSB.isEmpty()
+
+    val name: String = nodeName.toNodeName()
+
+    init {
+        decorator.namespaceCount.let { size ->
+            if (size > 0) {
+                for (i in 0 until size) {
+                    decorator.getNamespaceURI(i).also { value ->
+                        val uri = value ?: ""
+                        val prefix = decorator.namespaceContext.getPrefix(uri) ?: ""
+
+                        messageBuilder.addField(makeFieldName(NAMESPACE, prefix, true), uri)
+                    }
+                }
+                isMessage = true
+            }
+        }
+        decorator.attributeCount.let { size ->
+            if (size > 0) {
+                for (i in 0 until size) {
+                    val localPart = decorator.getAttributeLocalName(i)
+                    val prefix = decorator.getAttributePrefix(i)
+
+                    messageBuilder.addField(makeFieldName(prefix, localPart, true), decorator.getAttributeValue(i))
+                }
+                isMessage = true
+            }
+        }
+    }
+
+    fun putChild(name: QName, node: NodeContent) {
+        childNodes.compute(name) { _, value ->
+            value
+                ?.apply { add(node) }
+                ?: mutableListOf(node)
+        }
+        isMessage = true
+    }
+
+    fun appendText(text: String) {
+        if (text.isNotBlank()) {
+            textSB.append(text)
+        }
+    }
+
+    fun release() {
+        if (isMessage) {
+            childNodes.forEach { (name, values) ->
+                try {
+                    val notEmptyValues = values.filterNot(NodeContent::isEmpty)
+
+                    if (notEmptyValues.isNotEmpty()) {
+                        val first = notEmptyValues.first()
+                        when (values.size) { // Clarefy type of element: list or single
+                            0 -> error("Sub element $name hasn't got values")
+                            1 -> messageBuilder.addField(first.name, first.toValue())
+                            else -> messageBuilder.addField(
+                                first.name,
+                                notEmptyValues.asSequence()
+                                    .map(NodeContent::toValue)
+                                    .toListValue()
+                            )
+                        }
+                    }
+                } catch (e: RuntimeException) {
+                    throw IllegalStateException("The `$name` field can't be released in the `$nodeName` node", e)
+                }
+            }
+            if(textSB.isNotBlank()) {
+                messageBuilder.addField(TEXT_FIELD_NAME, textSB.toValue())
+            }
+        }
+    }
+
+    fun toMessage(): Message {
+        check(isMessage) {
+            "The $nodeName node isn't message"
+        }
+        return messageBuilder.build()
+    }
+
+    override fun toString(): String {
+        return "NodeContent(nodeName=$nodeName, childNodes=$childNodes, text=$textSB)"
+    }
+
+    private fun Sequence<Value>.toListValue(): Value = Value.newBuilder().apply {
+        listValueBuilder.apply {
+            forEach(::addValues)
+        }
+    }.build()
+
+    private fun toValue(): Value = if (isMessage) {
+        messageBuilder.toValue()
+    } else {
+        textSB.toValue()
+    }
+
+    companion object {
+        private const val NAMESPACE = "xmlns"
+        private const val TEXT_FIELD_NAME = "#text"
+
+        private fun QName.toNodeName(): String = makeFieldName(prefix, localPart)
+
+        private fun makeFieldName(first: String, second: String, isAttribute: Boolean = false): String {
+            return "${if (isAttribute) "-" else ""}$first${if (first.isNotBlank() && second.isNotBlank()) ":" else ""}$second"
+        }
+    }
+}

src/main/kotlin/com/exactpro/th2/codec/xml/XmlCodecStreamReader.kt

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2022 Exactpro (Exactpro Systems Limited)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.exactpro.th2.codec.xml
+
+import com.exactpro.th2.common.grpc.Message
+import com.exactpro.th2.common.grpc.RawMessage
+import com.exactpro.th2.common.grpc.Value
+import com.exactpro.th2.common.message.addField
+import com.exactpro.th2.common.message.direction
+import com.exactpro.th2.common.message.getField
+import com.exactpro.th2.common.message.message
+import com.exactpro.th2.common.message.sequence
+import com.exactpro.th2.common.message.sessionAlias
+import com.exactpro.th2.common.value.toValue
+import com.google.protobuf.TextFormat
+import java.io.ByteArrayInputStream
+import java.util.*
+import javax.xml.stream.XMLInputFactory
+import javax.xml.stream.XMLStreamException
+import javax.xml.stream.util.StreamReaderDelegate
+
+class XmlCodecStreamReader(
+    private val rawMessage: RawMessage,
+    private val pointer: List<String>
+)
+    : StreamReaderDelegate(
+        XML_INPUT_FACTORY.createXMLStreamReader(
+            ByteArrayInputStream(rawMessage.body.toByteArray())
+        )
+) {
+    private lateinit var rootNode: NodeContent
+    private lateinit var messageType: String
+
+    private val elements = Stack<NodeContent>()
+
+    @Throws(XMLStreamException::class)
+    override fun next(): Int = super.next().also { eventCode ->
+        when (eventCode) {
+            START_ELEMENT -> {
+                val qName = name
+                NodeContent(qName, this).also { nodeContent ->
+                    if (elements.isNotEmpty()) {
+                        elements.peek()
+                            .putChild(qName, nodeContent)
+                    }
+
+                    elements.push(nodeContent)
+
+                    if (!this::messageType.isInitialized) {
+                        messageType = localName
+                    }
+                    if (!this::rootNode.isInitialized) {
+                        rootNode = nodeContent
+                    }
+                }
+            }
+            CHARACTERS -> elements.peek().appendText(text)
+            END_ELEMENT -> elements.pop().also(NodeContent::release)
+        }
+    }
+
+    fun getMessage(): Message {
+        check(elements.isEmpty()) {
+            "Some of XML nodes of ${TextFormat.shortDebugString(rawMessage.metadata.id)} message aren't closed ${elements.joinToString { it.name }}"
+        }
+
+        return message().apply {
+            val rawMetadata = rawMessage.metadata
+
+            if (rawMessage.hasParentEventId()) {
+                parentEventId = rawMessage.parentEventId
+            }
+
+            addField(rootNode.name, rootNode.toMessage().toValue())
+
+            metadataBuilder.apply {
+                putAllProperties(rawMetadata.propertiesMap)
+                id = rawMetadata.id
+                timestamp = rawMetadata.timestamp
+                protocol = rawMetadata.protocol
+                messageType = extractMessageType([email protected])
+            }
+        }.build()
+    }
+
+    private fun Message.Builder.extractMessageType(defaultMessageType: String): String {
+        if (pointer.isEmpty()) return defaultMessageType
+
+        var currentNode = this.toValue()
+        pointer.forEachIndexed { index, element ->
+            check(currentNode.hasMessageValue()) {
+                "The `${pointer.take(index)}` node (${currentNode.kindCase}) isn't message in the th2 message $sessionAlias:$direction$sequence"
+            }
+            currentNode = requireNotNull(currentNode.messageValue.getField(element)) {
+                "The `${pointer.take(index + 1)}` element isn't found in message $sessionAlias:$direction$sequence"
+            }
+        }
+        check(currentNode.kindCase == Value.KindCase.SIMPLE_VALUE) {
+            "The `$pointer` node (${currentNode.kindCase}) isn't simple value in the th2 message $sessionAlias:$direction$sequence"
+        }
+
+        return currentNode.simpleValue
+    }
+
+    companion object {
+        private val XML_INPUT_FACTORY = XMLInputFactory.newInstance()
+    }
+}