Updated package versions, updated web server tests. (#207)

* Updated all package versions including kotlin. Updated all web-server tests to run.

* Changed the java version of the tests. OpenDC now only supports java 19.

* small update

* test update

* new update

* updated docker version to 19

* updated docker version to 19

8 files changed, 118 insertions, 63 deletions

diff --git a/opendc-trace/opendc-trace-calcite/build.gradle.kts b/opendc-trace/opendc-trace-calcite/build.gradle.kts
index 2ffdac3c..848e00da 100644
--- a/opendc-trace/opendc-trace-calcite/build.gradle.kts
+++ b/opendc-trace/opendc-trace-calcite/build.gradle.kts
@@ -22,7 +22,7 @@
 
 description = "Apache Calcite (SQL) integration for the OpenDC trace library"
 
-/* Build configuration */
+// Build configuration
 plugins {
     `kotlin-library-conventions`
 }
diff --git a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceReaderEnumerator.kt b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceReaderEnumerator.kt
index 74bd188b..eed52ab3 100644
--- a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceReaderEnumerator.kt
+++ b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceReaderEnumerator.kt
@@ -36,7 +36,7 @@ import java.util.concurrent.atomic.AtomicBoolean
 internal class TraceReaderEnumerator<E>(
     private val reader: TableReader,
     private val columns: List<TableColumn>,
-    private val cancelFlag: AtomicBoolean
+    private val cancelFlag: AtomicBoolean,
 ) : Enumerator<E> {
     private val columnIndices = columns.map { reader.resolve(it.name) }.toIntArray()
     private var current: E? = null
@@ -80,7 +80,11 @@ internal class TraceReaderEnumerator<E>(
         return res
     }
 
-    private fun convertColumn(reader: TableReader, column: TableColumn, columnIndex: Int): Any? {
+    private fun convertColumn(
+        reader: TableReader,
+        column: TableColumn,
+        columnIndex: Int,
+    ): Any? {
         return when (column.type) {
             is TableColumnType.Boolean -> reader.getBoolean(columnIndex)
             is TableColumnType.Int -> reader.getInt(columnIndex)
diff --git a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceSchemaFactory.kt b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceSchemaFactory.kt
index 3c6badc8..cbf7ec43 100644
--- a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceSchemaFactory.kt
+++ b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceSchemaFactory.kt
@@ -36,7 +36,11 @@ import java.nio.file.Paths
  * This factory allows users to include a schema that references a trace in a `model.json` file.
  */
 public class TraceSchemaFactory : SchemaFactory {
-    override fun create(parentSchema: SchemaPlus, name: String, operand: Map<String, Any>): Schema {
+    override fun create(
+        parentSchema: SchemaPlus,
+        name: String,
+        operand: Map<String, Any>,
+    ): Schema {
         val base = operand[ModelHandler.ExtraOperand.BASE_DIRECTORY.camelName] as File?
         val pathParam = requireNotNull(operand["path"]) { "Trace path not specified" } as String
         val path = if (base != null) File(base, pathParam).toPath() else Paths.get(pathParam)
diff --git a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTable.kt b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTable.kt
index 2dd02710..e74d2ee8 100644
--- a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTable.kt
+++ b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTable.kt
@@ -71,7 +71,11 @@ internal class TraceTable(private val table: org.opendc.trace.Table) :
         return rowType
     }
 
-    override fun scan(root: DataContext, filters: MutableList<RexNode>, projects: IntArray?): Enumerable<Array<Any?>> {
+    override fun scan(
+        root: DataContext,
+        filters: MutableList<RexNode>,
+        projects: IntArray?,
+    ): Enumerable<Array<Any?>> {
         // Filters are currently not supported by the OpenDC trace API. By keeping the filters in the list, Calcite
         // assumes that they are declined and will perform the filters itself.
 
@@ -130,14 +134,18 @@ internal class TraceTable(private val table: org.opendc.trace.Table) :
         return rowCount
     }
 
-    override fun <T> asQueryable(queryProvider: QueryProvider, schema: SchemaPlus, tableName: String): Queryable<T> {
+    override fun <T> asQueryable(
+        queryProvider: QueryProvider,
+        schema: SchemaPlus,
+        tableName: String,
+    ): Queryable<T> {
         return object : AbstractTableQueryable<T>(queryProvider, schema, this@TraceTable, tableName) {
             override fun enumerator(): Enumerator<T> {
                 val cancelFlag = AtomicBoolean(false)
                 return TraceReaderEnumerator(
                     this@TraceTable.table.newReader(),
                     this@TraceTable.table.columns,
-                    cancelFlag
+                    cancelFlag,
                 )
             }
 
@@ -155,7 +163,7 @@ internal class TraceTable(private val table: org.opendc.trace.Table) :
         operation: TableModify.Operation,
         updateColumnList: MutableList<String>?,
         sourceExpressionList: MutableList<RexNode>?,
-        flattened: Boolean
+        flattened: Boolean,
     ): TableModify {
         cluster.planner.addRule(TraceTableModifyRule.DEFAULT.toRule())
 
@@ -166,7 +174,7 @@ internal class TraceTable(private val table: org.opendc.trace.Table) :
             operation,
             updateColumnList,
             sourceExpressionList,
-            flattened
+            flattened,
         )
     }
 
@@ -184,7 +192,10 @@ internal class TraceTable(private val table: org.opendc.trace.Table) :
         return typeFactory.createStructType(types, names)
     }
 
-    private fun mapType(typeFactory: JavaTypeFactory, type: TableColumnType): RelDataType {
+    private fun mapType(
+        typeFactory: JavaTypeFactory,
+        type: TableColumnType,
+    ): RelDataType {
         return when (type) {
             is TableColumnType.Boolean -> typeFactory.createSqlType(SqlTypeName.BOOLEAN)
             is TableColumnType.Int -> typeFactory.createSqlType(SqlTypeName.INTEGER)
diff --git a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTableModify.kt b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTableModify.kt
index cc23854f..eedff00d 100644
--- a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTableModify.kt
+++ b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTableModify.kt
@@ -59,7 +59,7 @@ internal class TraceTableModify(
     operation: Operation,
     updateColumnList: List<String>?,
     sourceExpressionList: List<RexNode>?,
-    flattened: Boolean
+    flattened: Boolean,
 ) : TableModify(cluster, traitSet, table, schema, input, operation, updateColumnList, sourceExpressionList, flattened),
     EnumerableRel {
     init {
@@ -67,7 +67,10 @@ internal class TraceTableModify(
         table.unwrap(ModifiableTable::class.java) ?: throw AssertionError() // TODO: user error in validator
     }
 
-    override fun copy(traitSet: RelTraitSet, inputs: List<RelNode>?): RelNode {
+    override fun copy(
+        traitSet: RelTraitSet,
+        inputs: List<RelNode>?,
+    ): RelNode {
         return TraceTableModify(
             cluster,
             traitSet,
@@ -77,40 +80,48 @@ internal class TraceTableModify(
             operation,
             updateColumnList,
             sourceExpressionList,
-            isFlattened
+            isFlattened,
         )
     }
 
-    override fun computeSelfCost(planner: RelOptPlanner, mq: RelMetadataQuery?): RelOptCost {
+    override fun computeSelfCost(
+        planner: RelOptPlanner,
+        mq: RelMetadataQuery?,
+    ): RelOptCost {
         // Prefer this plan compared to the standard EnumerableTableModify.
         return super.computeSelfCost(planner, mq)!!.multiplyBy(.1)
     }
 
-    override fun implement(implementor: EnumerableRelImplementor, pref: Prefer): EnumerableRel.Result {
+    override fun implement(
+        implementor: EnumerableRelImplementor,
+        pref: Prefer,
+    ): EnumerableRel.Result {
         val builder = BlockBuilder()
         val result = implementor.visitChild(this, 0, getInput() as EnumerableRel, pref)
         val childExp = builder.append("child", result.block)
-        val convertedChildExpr = if (getInput().rowType != rowType) {
-            val typeFactory = cluster.typeFactory as JavaTypeFactory
-            val format = EnumerableTableScan.deduceFormat(table)
-            val physType = PhysTypeImpl.of(typeFactory, table.rowType, format)
-            val childPhysType = result.physType
-            val o = Expressions.parameter(childPhysType.javaRowType, "o")
-            val expressionList = List(childPhysType.rowType.fieldCount) { i ->
-                childPhysType.fieldReference(o, i, physType.getJavaFieldType(i))
-            }
+        val convertedChildExpr =
+            if (getInput().rowType != rowType) {
+                val typeFactory = cluster.typeFactory as JavaTypeFactory
+                val format = EnumerableTableScan.deduceFormat(table)
+                val physType = PhysTypeImpl.of(typeFactory, table.rowType, format)
+                val childPhysType = result.physType
+                val o = Expressions.parameter(childPhysType.javaRowType, "o")
+                val expressionList =
+                    List(childPhysType.rowType.fieldCount) { i ->
+                        childPhysType.fieldReference(o, i, physType.getJavaFieldType(i))
+                    }
 
-            builder.append(
-                "convertedChild",
-                Expressions.call(
-                    childExp,
-                    BuiltInMethod.SELECT.method,
-                    Expressions.lambda<org.apache.calcite.linq4j.function.Function<*>>(physType.record(expressionList), o)
+                builder.append(
+                    "convertedChild",
+                    Expressions.call(
+                        childExp,
+                        BuiltInMethod.SELECT.method,
+                        Expressions.lambda<org.apache.calcite.linq4j.function.Function<*>>(physType.record(expressionList), o),
+                    ),
                 )
-            )
-        } else {
-            childExp
-        }
+            } else {
+                childExp
+            }
 
         if (!isInsert) {
             throw UnsupportedOperationException("Deletion and update not supported")
@@ -126,10 +137,10 @@ internal class TraceTableModify(
                         Long::class.java,
                         expression,
                         INSERT_METHOD,
-                        convertedChildExpr
-                    )
-                )
-            )
+                        convertedChildExpr,
+                    ),
+                ),
+            ),
         )
 
         val rowFormat = if (pref === Prefer.ARRAY) JavaRowFormat.ARRAY else JavaRowFormat.SCALAR
diff --git a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTableModifyRule.kt b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTableModifyRule.kt
index 7572e381..9c560984 100644
--- a/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTableModifyRule.kt
+++ b/opendc-trace/opendc-trace-calcite/src/main/kotlin/org/opendc/trace/calcite/TraceTableModifyRule.kt
@@ -52,14 +52,20 @@ internal class TraceTableModifyRule(config: Config) : ConverterRule(config) {
             modify.operation,
             modify.updateColumnList,
             modify.sourceExpressionList,
-            modify.isFlattened
+            modify.isFlattened,
         )
     }
 
     companion object {
         /** Default configuration.  */
-        val DEFAULT: Config = Config.INSTANCE
-            .withConversion(LogicalTableModify::class.java, Convention.NONE, EnumerableConvention.INSTANCE, "TraceTableModificationRule")
-            .withRuleFactory { config: Config -> TraceTableModifyRule(config) }
+        val DEFAULT: Config =
+            Config.INSTANCE
+                .withConversion(
+                    LogicalTableModify::class.java,
+                    Convention.NONE,
+                    EnumerableConvention.INSTANCE,
+                    "TraceTableModificationRule",
+                )
+                .withRuleFactory { config: Config -> TraceTableModifyRule(config) }
     }
 }
diff --git a/opendc-trace/opendc-trace-calcite/src/test/kotlin/org/opendc/trace/calcite/CalciteTest.kt b/opendc-trace/opendc-trace-calcite/src/test/kotlin/org/opendc/trace/calcite/CalciteTest.kt
index 64bb31c9..93b15e5f 100644
--- a/opendc-trace/opendc-trace-calcite/src/test/kotlin/org/opendc/trace/calcite/CalciteTest.kt
+++ b/opendc-trace/opendc-trace-calcite/src/test/kotlin/org/opendc/trace/calcite/CalciteTest.kt
@@ -71,7 +71,7 @@ class CalciteTest {
                 { assertEquals("1052", rs.getString("id")) },
                 { assertTrue(rs.next()) },
                 { assertEquals("1073", rs.getString("id")) },
-                { assertFalse(rs.next()) }
+                { assertFalse(rs.next()) },
             )
         }
     }
@@ -86,7 +86,7 @@ class CalciteTest {
                 { assertEquals(300000, rs.getLong("duration")) },
                 { assertEquals(0.0, rs.getDouble("cpu_usage")) },
                 { assertTrue(rs.next()) },
-                { assertEquals("1019", rs.getString("id")) }
+                { assertEquals("1019", rs.getString("id")) },
             )
         }
     }
@@ -98,7 +98,7 @@ class CalciteTest {
                 { assertTrue(rs.next()) },
                 { assertArrayEquals(arrayOf("1019", "1023", "1052"), rs.getArray("members").array as Array<*>) },
                 { assertEquals(0.0, rs.getDouble("target")) },
-                { assertEquals(0.8830158730158756, rs.getDouble("score")) }
+                { assertEquals(0.8830158730158756, rs.getDouble("score")) },
             )
         }
     }
@@ -109,7 +109,7 @@ class CalciteTest {
             assertAll(
                 { assertTrue(rs.next()) },
                 { assertEquals(249.59993808, rs.getDouble("max_cpu_usage")) },
-                { assertEquals(5.387240309118493, rs.getDouble("avg_cpu_usage")) }
+                { assertEquals(5.387240309118493, rs.getDouble("avg_cpu_usage")) },
             )
         }
     }
@@ -120,12 +120,13 @@ class CalciteTest {
         val newTrace = Trace.create(tmp, "opendc-vm")
 
         runStatement(newTrace) { stmt ->
-            val count = stmt.executeUpdate(
-                """
-                INSERT INTO trace.resources (id, start_time, stop_time, cpu_count, cpu_capacity, mem_capacity)
-                VALUES (1234, '2013-08-12 13:35:46.0', '2013-09-11 13:39:58.0', 1, 2926.0, 1024.0)
-                """.trimIndent()
-            )
+            val count =
+                stmt.executeUpdate(
+                    """
+                    INSERT INTO trace.resources (id, start_time, stop_time, cpu_count, cpu_capacity, mem_capacity)
+                    VALUES (1234, '2013-08-12 13:35:46.0', '2013-09-11 13:39:58.0', 1, 2926.0, 1024.0)
+                    """.trimIndent(),
+                )
             assertEquals(1, count)
         }
 
@@ -136,7 +137,7 @@ class CalciteTest {
                 { assertEquals(1, rs.getInt("cpu_count")) },
                 { assertEquals(Timestamp.valueOf("2013-08-12 13:35:46.0"), rs.getTimestamp("start_time")) },
                 { assertEquals(2926.0, rs.getDouble("cpu_capacity")) },
-                { assertEquals(1024.0, rs.getDouble("mem_capacity")) }
+                { assertEquals(1024.0, rs.getDouble("mem_capacity")) },
             )
         }
     }
@@ -145,9 +146,10 @@ class CalciteTest {
     fun testUUID() {
         val trace = mockk<Trace>()
         every { trace.tables } returns listOf(TABLE_RESOURCES)
-        every { trace.getTable(TABLE_RESOURCES)!!.columns } returns listOf(
-            TableColumn("id", TableColumnType.UUID)
-        )
+        every { trace.getTable(TABLE_RESOURCES)!!.columns } returns
+            listOf(
+                TableColumn("id", TableColumnType.UUID),
+            )
         every { trace.getTable(TABLE_RESOURCES)!!.newReader() } answers {
             object : TableReader {
                 override fun nextRow(): Boolean = true
@@ -195,15 +197,25 @@ class CalciteTest {
                     TODO("not implemented")
                 }
 
-                override fun <T> getList(index: Int, elementType: Class<T>): List<T>? {
+                override fun <T> getList(
+                    index: Int,
+                    elementType: Class<T>,
+                ): List<T>? {
                     TODO("not implemented")
                 }
 
-                override fun <T> getSet(index: Int, elementType: Class<T>): Set<T>? {
+                override fun <T> getSet(
+                    index: Int,
+                    elementType: Class<T>,
+                ): Set<T>? {
                     TODO("not implemented")
                 }
 
-                override fun <K, V> getMap(index: Int, keyType: Class<K>, valueType: Class<V>): Map<K, V>? {
+                override fun <K, V> getMap(
+                    index: Int,
+                    keyType: Class<K>,
+                    valueType: Class<V>,
+                ): Map<K, V>? {
                     TODO("not implemented")
                 }
 
@@ -214,7 +226,7 @@ class CalciteTest {
         runQuery(trace, "SELECT id FROM trace.resources") { rs ->
             assertAll(
                 { assertTrue(rs.next()) },
-                { assertArrayEquals(byteArrayOf(0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2), rs.getBytes("id")) }
+                { assertArrayEquals(byteArrayOf(0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2), rs.getBytes("id")) },
             )
         }
     }
@@ -222,7 +234,11 @@ class CalciteTest {
     /**
      * Helper function to run statement for the specified trace.
      */
-    private fun runQuery(trace: Trace, query: String, block: (ResultSet) -> Unit) {
+    private fun runQuery(
+        trace: Trace,
+        query: String,
+        block: (ResultSet) -> Unit,
+    ) {
         runStatement(trace) { stmt ->
             val rs = stmt.executeQuery(query)
             rs.use { block(rs) }
@@ -232,7 +248,10 @@ class CalciteTest {
     /**
      * Helper function to run statement for the specified trace.
      */
-    private fun runStatement(trace: Trace, block: (Statement) -> Unit) {
+    private fun runStatement(
+        trace: Trace,
+        block: (Statement) -> Unit,
+    ) {
         val info = Properties()
         info.setProperty("lex", "JAVA")
         val connection = DriverManager.getConnection("jdbc:calcite:", info).unwrap(CalciteConnection::class.java)
diff --git a/opendc-trace/opendc-trace-calcite/src/test/kotlin/org/opendc/trace/calcite/TraceSchemaFactoryTest.kt b/opendc-trace/opendc-trace-calcite/src/test/kotlin/org/opendc/trace/calcite/TraceSchemaFactoryTest.kt
index 735cedce..eb4bc769 100644
--- a/opendc-trace/opendc-trace-calcite/src/test/kotlin/org/opendc/trace/calcite/TraceSchemaFactoryTest.kt
+++ b/opendc-trace/opendc-trace-calcite/src/test/kotlin/org/opendc/trace/calcite/TraceSchemaFactoryTest.kt
@@ -48,7 +48,7 @@ class TraceSchemaFactoryTest {
                 { assertEquals("1019", rs.getString("id")) },
                 { assertEquals(1, rs.getInt("cpu_count")) },
                 { assertEquals(Timestamp.valueOf("2013-08-12 13:40:46.0"), rs.getTimestamp("start_time")) },
-                { assertEquals(181352.0, rs.getDouble("mem_capacity")) }
+                { assertEquals(181352.0, rs.getDouble("mem_capacity")) },
             )
         } finally {
             rs.close()