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

11 files changed, 341 insertions, 307 deletions

diff --git a/opendc-experiments/opendc-experiments-capelin/src/jmh/kotlin/org/opendc/experiments/capelin/CapelinBenchmarks.kt b/opendc-experiments/opendc-experiments-capelin/src/jmh/kotlin/org/opendc/experiments/capelin/CapelinBenchmarks.kt
index 06f8265c..f0084ec5 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/jmh/kotlin/org/opendc/experiments/capelin/CapelinBenchmarks.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/jmh/kotlin/org/opendc/experiments/capelin/CapelinBenchmarks.kt
@@ -72,22 +72,24 @@ class CapelinBenchmarks {
     }
 
     @Benchmark
-    fun benchmarkCapelin() = runSimulation {
-        val serviceDomain = "compute.opendc.org"
+    fun benchmarkCapelin() =
+        runSimulation {
+            val serviceDomain = "compute.opendc.org"
 
-        Provisioner(dispatcher, seed = 0).use { provisioner ->
-            val computeScheduler = FilterScheduler(
-                filters = listOf(ComputeFilter(), VCpuFilter(16.0), RamFilter(1.0)),
-                weighers = listOf(CoreRamWeigher(multiplier = 1.0))
-            )
+            Provisioner(dispatcher, seed = 0).use { provisioner ->
+                val computeScheduler =
+                    FilterScheduler(
+                        filters = listOf(ComputeFilter(), VCpuFilter(16.0), RamFilter(1.0)),
+                        weighers = listOf(CoreRamWeigher(multiplier = 1.0)),
+                    )
 
-            provisioner.runSteps(
-                setupComputeService(serviceDomain, { computeScheduler }),
-                setupHosts(serviceDomain, topology, optimize = isOptimized)
-            )
+                provisioner.runSteps(
+                    setupComputeService(serviceDomain, { computeScheduler }),
+                    setupHosts(serviceDomain, topology, optimize = isOptimized),
+                )
 
-            val service = provisioner.registry.resolve(serviceDomain, ComputeService::class.java)!!
-            service.replay(timeSource, vms, 0L, interference = true)
+                val service = provisioner.registry.resolve(serviceDomain, ComputeService::class.java)!!
+                service.replay(timeSource, vms, 0L, interference = true)
+            }
         }
-    }
 }
diff --git a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/CapelinCli.kt b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/CapelinCli.kt
index ac0bd506..5bec8c6d 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/CapelinCli.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/CapelinCli.kt
@@ -114,7 +114,7 @@ internal class CapelinCommand : CliktCommand(name = "capelin") {
             "hor-ver" to { HorVerPortfolio() },
             "more-hpc" to { MoreHpcPortfolio() },
             "more-velocity" to { MoreVelocityPortfolio() },
-            "op-phen" to { OperationalPhenomenaPortfolio() }
+            "op-phen" to { OperationalPhenomenaPortfolio() },
         )
 
     /**
@@ -140,12 +140,17 @@ internal class CapelinCommand : CliktCommand(name = "capelin") {
     /**
      * Run a single scenario.
      */
-    private fun runScenario(runner: CapelinRunner, pool: ForkJoinPool, scenario: Scenario) {
-        val pb = ProgressBarBuilder()
-            .setInitialMax(repeats.toLong())
-            .setStyle(ProgressBarStyle.ASCII)
-            .setTaskName("Simulating...")
-            .build()
+    private fun runScenario(
+        runner: CapelinRunner,
+        pool: ForkJoinPool,
+        scenario: Scenario,
+    ) {
+        val pb =
+            ProgressBarBuilder()
+                .setInitialMax(repeats.toLong())
+                .setStyle(ProgressBarStyle.ASCII)
+                .setTaskName("Simulating...")
+                .build()
 
         pool.submit {
             LongStream.range(0, repeats.toLong())
diff --git a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/CapelinRunner.kt b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/CapelinRunner.kt
index b97b7f94..0de72afa 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/CapelinRunner.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/CapelinRunner.kt
@@ -50,7 +50,7 @@ import kotlin.math.roundToLong
 public class CapelinRunner(
     private val envPath: File,
     tracePath: File,
-    private val outputPath: File?
+    private val outputPath: File?,
 ) {
     /**
      * The [ComputeWorkloadLoader] to use for loading the traces.
@@ -60,14 +60,17 @@ public class CapelinRunner(
     /**
      * Run a single [scenario] with the specified seed.
      */
-    fun runScenario(scenario: Scenario, seed: Long) = runSimulation {
+    fun runScenario(
+        scenario: Scenario,
+        seed: Long,
+    ) = runSimulation {
         val serviceDomain = "compute.opendc.org"
         val topology = clusterTopology(File(envPath, "${scenario.topology.name}.txt"))
 
         Provisioner(dispatcher, seed).use { provisioner ->
             provisioner.runSteps(
                 setupComputeService(serviceDomain, { createComputeScheduler(scenario.allocationPolicy, Random(it.seeder.nextLong())) }),
-                setupHosts(serviceDomain, topology, optimize = true)
+                setupHosts(serviceDomain, topology, optimize = true),
             )
 
             if (outputPath != null) {
@@ -80,9 +83,9 @@ public class CapelinRunner(
                         ParquetComputeMonitor(
                             outputPath,
                             partition,
-                            bufferSize = 4096
-                        )
-                    )
+                            bufferSize = 4096,
+                        ),
+                    ),
                 )
             }
 
diff --git a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/CompositeWorkloadPortfolio.kt b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/CompositeWorkloadPortfolio.kt
index 40e3801f..140f0480 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/CompositeWorkloadPortfolio.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/CompositeWorkloadPortfolio.kt
@@ -34,46 +34,49 @@ import org.opendc.experiments.base.portfolio.model.Workload
  * A [Portfolio] that explores the effect of a composite workload.
  */
 public class CompositeWorkloadPortfolio : Portfolio {
-    private val topologies = listOf(
-        Topology("base"),
-        Topology("exp-vol-hor-hom"),
-        Topology("exp-vol-ver-hom"),
-        Topology("exp-vel-ver-hom")
-    )
-    private val workloads = listOf(
-        Workload(
-            "all-azure",
-            composite(trace("solvinity-short") to 0.0, trace("azure") to 1.0)
-        ),
-        Workload(
-            "solvinity-25-azure-75",
-            composite(trace("solvinity-short") to 0.25, trace("azure") to 0.75)
-        ),
-        Workload(
-            "solvinity-50-azure-50",
-            composite(trace("solvinity-short") to 0.5, trace("azure") to 0.5)
-        ),
-        Workload(
-            "solvinity-75-azure-25",
-            composite(trace("solvinity-short") to 0.75, trace("azure") to 0.25)
-        ),
-        Workload(
-            "all-solvinity",
-            composite(trace("solvinity-short") to 1.0, trace("azure") to 0.0)
+    private val topologies =
+        listOf(
+            Topology("base"),
+            Topology("exp-vol-hor-hom"),
+            Topology("exp-vol-ver-hom"),
+            Topology("exp-vel-ver-hom"),
+        )
+    private val workloads =
+        listOf(
+            Workload(
+                "all-azure",
+                composite(trace("solvinity-short") to 0.0, trace("azure") to 1.0),
+            ),
+            Workload(
+                "solvinity-25-azure-75",
+                composite(trace("solvinity-short") to 0.25, trace("azure") to 0.75),
+            ),
+            Workload(
+                "solvinity-50-azure-50",
+                composite(trace("solvinity-short") to 0.5, trace("azure") to 0.5),
+            ),
+            Workload(
+                "solvinity-75-azure-25",
+                composite(trace("solvinity-short") to 0.75, trace("azure") to 0.25),
+            ),
+            Workload(
+                "all-solvinity",
+                composite(trace("solvinity-short") to 1.0, trace("azure") to 0.0),
+            ),
         )
-    )
     private val operationalPhenomena = OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = false)
     private val allocationPolicy = "active-servers"
 
-    override val scenarios: Iterable<Scenario> = topologies.flatMap { topology ->
-        workloads.map { workload ->
-            Scenario(
-                topology,
-                workload,
-                operationalPhenomena,
-                allocationPolicy,
-                mapOf("topology" to topology.name, "workload" to workload.name)
-            )
+    override val scenarios: Iterable<Scenario> =
+        topologies.flatMap { topology ->
+            workloads.map { workload ->
+                Scenario(
+                    topology,
+                    workload,
+                    operationalPhenomena,
+                    allocationPolicy,
+                    mapOf("topology" to topology.name, "workload" to workload.name),
+                )
+            }
         }
-    }
 }
diff --git a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/HorVerPortfolio.kt b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/HorVerPortfolio.kt
index 1d68836c..da884f35 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/HorVerPortfolio.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/HorVerPortfolio.kt
@@ -34,36 +34,39 @@ import org.opendc.experiments.base.portfolio.model.Workload
  * A [Portfolio] that explores the difference between horizontal and vertical scaling.
  */
 public class HorVerPortfolio : Portfolio {
-    private val topologies = listOf(
-        Topology("base"),
-        Topology("rep-vol-hor-hom"),
-        Topology("rep-vol-hor-het"),
-        Topology("rep-vol-ver-hom"),
-        Topology("rep-vol-ver-het"),
-        Topology("exp-vol-hor-hom"),
-        Topology("exp-vol-hor-het"),
-        Topology("exp-vol-ver-hom"),
-        Topology("exp-vol-ver-het")
-    )
+    private val topologies =
+        listOf(
+            Topology("base"),
+            Topology("rep-vol-hor-hom"),
+            Topology("rep-vol-hor-het"),
+            Topology("rep-vol-ver-hom"),
+            Topology("rep-vol-ver-het"),
+            Topology("exp-vol-hor-hom"),
+            Topology("exp-vol-hor-het"),
+            Topology("exp-vol-ver-hom"),
+            Topology("exp-vol-ver-het"),
+        )
 
-    private val workloads = listOf(
-        Workload("solvinity-10%", trace("solvinity").sampleByLoad(0.1)),
-        Workload("solvinity-25%", trace("solvinity").sampleByLoad(0.25)),
-        Workload("solvinity-50%", trace("solvinity").sampleByLoad(0.5)),
-        Workload("solvinity-100%", trace("solvinity").sampleByLoad(1.0))
-    )
+    private val workloads =
+        listOf(
+            Workload("solvinity-10%", trace("solvinity").sampleByLoad(0.1)),
+            Workload("solvinity-25%", trace("solvinity").sampleByLoad(0.25)),
+            Workload("solvinity-50%", trace("solvinity").sampleByLoad(0.5)),
+            Workload("solvinity-100%", trace("solvinity").sampleByLoad(1.0)),
+        )
     private val operationalPhenomena = OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true)
     private val allocationPolicy = "active-servers"
 
-    override val scenarios: Iterable<Scenario> = topologies.flatMap { topology ->
-        workloads.map { workload ->
-            Scenario(
-                topology,
-                workload,
-                operationalPhenomena,
-                allocationPolicy,
-                mapOf("topology" to topology.name, "workload" to workload.name)
-            )
+    override val scenarios: Iterable<Scenario> =
+        topologies.flatMap { topology ->
+            workloads.map { workload ->
+                Scenario(
+                    topology,
+                    workload,
+                    operationalPhenomena,
+                    allocationPolicy,
+                    mapOf("topology" to topology.name, "workload" to workload.name),
+                )
+            }
         }
-    }
 }
diff --git a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/MoreHpcPortfolio.kt b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/MoreHpcPortfolio.kt
index 1c222ae8..e060ff14 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/MoreHpcPortfolio.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/MoreHpcPortfolio.kt
@@ -35,34 +35,37 @@ import org.opendc.experiments.base.portfolio.model.Workload
  * A [Portfolio] to explore the effect of HPC workloads.
  */
 public class MoreHpcPortfolio : Portfolio {
-    private val topologies = listOf(
-        Topology("base"),
-        Topology("exp-vol-hor-hom"),
-        Topology("exp-vol-ver-hom"),
-        Topology("exp-vel-ver-hom")
-    )
-    private val workloads = listOf(
-        Workload("hpc-0%", trace("solvinity").sampleByHpc(0.0)),
-        Workload("hpc-25%", trace("solvinity").sampleByHpc(0.25)),
-        Workload("hpc-50%", trace("solvinity").sampleByHpc(0.5)),
-        Workload("hpc-100%", trace("solvinity").sampleByHpc(1.0)),
-        Workload("hpc-load-25%", trace("solvinity").sampleByHpcLoad(0.25)),
-        Workload("hpc-load-50%", trace("solvinity").sampleByHpcLoad(0.5)),
-        Workload("hpc-load-100%", trace("solvinity").sampleByHpcLoad(1.0))
-    )
+    private val topologies =
+        listOf(
+            Topology("base"),
+            Topology("exp-vol-hor-hom"),
+            Topology("exp-vol-ver-hom"),
+            Topology("exp-vel-ver-hom"),
+        )
+    private val workloads =
+        listOf(
+            Workload("hpc-0%", trace("solvinity").sampleByHpc(0.0)),
+            Workload("hpc-25%", trace("solvinity").sampleByHpc(0.25)),
+            Workload("hpc-50%", trace("solvinity").sampleByHpc(0.5)),
+            Workload("hpc-100%", trace("solvinity").sampleByHpc(1.0)),
+            Workload("hpc-load-25%", trace("solvinity").sampleByHpcLoad(0.25)),
+            Workload("hpc-load-50%", trace("solvinity").sampleByHpcLoad(0.5)),
+            Workload("hpc-load-100%", trace("solvinity").sampleByHpcLoad(1.0)),
+        )
 
     private val operationalPhenomena = OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true)
     private val allocationPolicy: String = "active-servers"
 
-    override val scenarios: Iterable<Scenario> = topologies.flatMap { topology ->
-        workloads.map { workload ->
-            Scenario(
-                topology,
-                workload,
-                operationalPhenomena,
-                allocationPolicy,
-                mapOf("topology" to topology.name, "workload" to workload.name)
-            )
+    override val scenarios: Iterable<Scenario> =
+        topologies.flatMap { topology ->
+            workloads.map { workload ->
+                Scenario(
+                    topology,
+                    workload,
+                    operationalPhenomena,
+                    allocationPolicy,
+                    mapOf("topology" to topology.name, "workload" to workload.name),
+                )
+            }
         }
-    }
 }
diff --git a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/MoreVelocityPortfolio.kt b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/MoreVelocityPortfolio.kt
index b2a751a3..0d6e190c 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/MoreVelocityPortfolio.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/MoreVelocityPortfolio.kt
@@ -34,33 +34,36 @@ import org.opendc.experiments.base.portfolio.model.Workload
  * A [Portfolio] that explores the effect of adding more velocity to a cluster (e.g., faster machines).
  */
 public class MoreVelocityPortfolio : Portfolio {
-    private val topologies = listOf(
-        Topology("base"),
-        Topology("rep-vel-ver-hom"),
-        Topology("rep-vel-ver-het"),
-        Topology("exp-vel-ver-hom"),
-        Topology("exp-vel-ver-het")
-    )
+    private val topologies =
+        listOf(
+            Topology("base"),
+            Topology("rep-vel-ver-hom"),
+            Topology("rep-vel-ver-het"),
+            Topology("exp-vel-ver-hom"),
+            Topology("exp-vel-ver-het"),
+        )
 
-    private val workloads = listOf(
-        Workload("solvinity-10%", trace("solvinity").sampleByLoad(0.1)),
-        Workload("solvinity-25%", trace("solvinity").sampleByLoad(0.25)),
-        Workload("solvinity-50%", trace("solvinity").sampleByLoad(0.5)),
-        Workload("solvinity-100%", trace("solvinity").sampleByLoad(1.0))
-    )
+    private val workloads =
+        listOf(
+            Workload("solvinity-10%", trace("solvinity").sampleByLoad(0.1)),
+            Workload("solvinity-25%", trace("solvinity").sampleByLoad(0.25)),
+            Workload("solvinity-50%", trace("solvinity").sampleByLoad(0.5)),
+            Workload("solvinity-100%", trace("solvinity").sampleByLoad(1.0)),
+        )
 
     private val operationalPhenomena = OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true)
     private val allocationPolicy = "active-servers"
 
-    override val scenarios: Iterable<Scenario> = topologies.flatMap { topology ->
-        workloads.map { workload ->
-            Scenario(
-                topology,
-                workload,
-                operationalPhenomena,
-                allocationPolicy,
-                mapOf("topology" to topology.name, "workload" to workload.name)
-            )
+    override val scenarios: Iterable<Scenario> =
+        topologies.flatMap { topology ->
+            workloads.map { workload ->
+                Scenario(
+                    topology,
+                    workload,
+                    operationalPhenomena,
+                    allocationPolicy,
+                    mapOf("topology" to topology.name, "workload" to workload.name),
+                )
+            }
         }
-    }
 }
diff --git a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/OperationalPhenomenaPortfolio.kt b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/OperationalPhenomenaPortfolio.kt
index b8c60b67..17c8bb48 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/OperationalPhenomenaPortfolio.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/OperationalPhenomenaPortfolio.kt
@@ -35,29 +35,32 @@ import org.opendc.experiments.base.portfolio.model.Workload
  */
 public class OperationalPhenomenaPortfolio : Portfolio {
     private val topology = Topology("base")
-    private val workloads = listOf(
-        Workload("solvinity-10%", trace("solvinity").sampleByLoad(0.1)),
-        Workload("solvinity-25%", trace("solvinity").sampleByLoad(0.25)),
-        Workload("solvinity-50%", trace("solvinity").sampleByLoad(0.5)),
-        Workload("solvinity-100%", trace("solvinity").sampleByLoad(1.0))
-    )
+    private val workloads =
+        listOf(
+            Workload("solvinity-10%", trace("solvinity").sampleByLoad(0.1)),
+            Workload("solvinity-25%", trace("solvinity").sampleByLoad(0.25)),
+            Workload("solvinity-50%", trace("solvinity").sampleByLoad(0.5)),
+            Workload("solvinity-100%", trace("solvinity").sampleByLoad(1.0)),
+        )
 
-    private val phenomenas = listOf(
-        OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true),
-        OperationalPhenomena(failureFrequency = 0.0, hasInterference = true),
-        OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = false),
-        OperationalPhenomena(failureFrequency = 0.0, hasInterference = false)
-    )
+    private val phenomenas =
+        listOf(
+            OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true),
+            OperationalPhenomena(failureFrequency = 0.0, hasInterference = true),
+            OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = false),
+            OperationalPhenomena(failureFrequency = 0.0, hasInterference = false),
+        )
 
-    private val allocationPolicies = listOf(
-        "mem",
-        "mem-inv",
-        "core-mem",
-        "core-mem-inv",
-        "active-servers",
-        "active-servers-inv",
-        "random"
-    )
+    private val allocationPolicies =
+        listOf(
+            "mem",
+            "mem-inv",
+            "core-mem",
+            "core-mem-inv",
+            "active-servers",
+            "active-servers-inv",
+            "random",
+        )
 
     override val scenarios: Iterable<Scenario> =
         workloads.flatMap { workload ->
@@ -68,7 +71,7 @@ public class OperationalPhenomenaPortfolio : Portfolio {
                         workload,
                         operationalPhenomena,
                         allocationPolicy,
-                        mapOf("workload" to workload.name, "scheduler" to allocationPolicy, "phenomena" to index.toString())
+                        mapOf("workload" to workload.name, "scheduler" to allocationPolicy, "phenomena" to index.toString()),
                     )
                 }
             }
diff --git a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/TestPortfolio.kt b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/TestPortfolio.kt
index f7314802..729fb017 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/TestPortfolio.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/main/kotlin/org/opendc/experiments/capelin/portfolios/TestPortfolio.kt
@@ -34,12 +34,13 @@ import org.opendc.experiments.base.portfolio.model.Workload
  * A [Portfolio] to perform a simple test run.
  */
 public class TestPortfolio : Portfolio {
-    override val scenarios: Iterable<Scenario> = listOf(
-        Scenario(
-            Topology("single"),
-            Workload("bitbrains-small", trace("trace").sampleByLoad(1.0)),
-            OperationalPhenomena(failureFrequency = 0.0, hasInterference = true),
-            "active-servers"
+    override val scenarios: Iterable<Scenario> =
+        listOf(
+            Scenario(
+                Topology("single"),
+                Workload("bitbrains-small", trace("trace").sampleByLoad(1.0)),
+                OperationalPhenomena(failureFrequency = 0.0, hasInterference = true),
+                "active-servers",
+            ),
         )
-    )
 }
diff --git a/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/CapelinIntegrationTest.kt b/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/CapelinIntegrationTest.kt
index 26cdb36e..6b538240 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/CapelinIntegrationTest.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/CapelinIntegrationTest.kt
@@ -77,10 +77,11 @@ class CapelinIntegrationTest {
     @BeforeEach
     fun setUp() {
         monitor = TestComputeMonitor()
-        computeScheduler = FilterScheduler(
-            filters = listOf(ComputeFilter(), VCpuFilter(16.0), RamFilter(1.0)),
-            weighers = listOf(CoreRamWeigher(multiplier = 1.0))
-        )
+        computeScheduler =
+            FilterScheduler(
+                filters = listOf(ComputeFilter(), VCpuFilter(16.0), RamFilter(1.0)),
+                weighers = listOf(CoreRamWeigher(multiplier = 1.0)),
+            )
         workloadLoader = ComputeWorkloadLoader(File("src/test/resources/trace"))
     }
 
@@ -88,159 +89,166 @@ class CapelinIntegrationTest {
      * Test a large simulation setup.
      */
     @Test
-    fun testLarge() = runSimulation {
-        val seed = 0L
-        val workload = createTestWorkload(1.0, seed)
-        val topology = createTopology()
-        val monitor = monitor
+    fun testLarge() =
+        runSimulation {
+            val seed = 0L
+            val workload = createTestWorkload(1.0, seed)
+            val topology = createTopology()
+            val monitor = monitor
 
-        Provisioner(dispatcher, seed).use { provisioner ->
-            provisioner.runSteps(
-                setupComputeService(serviceDomain = "compute.opendc.org", { computeScheduler }),
-                registerComputeMonitor(serviceDomain = "compute.opendc.org", monitor),
-                setupHosts(serviceDomain = "compute.opendc.org", topology)
-            )
+            Provisioner(dispatcher, seed).use { provisioner ->
+                provisioner.runSteps(
+                    setupComputeService(serviceDomain = "compute.opendc.org", { computeScheduler }),
+                    registerComputeMonitor(serviceDomain = "compute.opendc.org", monitor),
+                    setupHosts(serviceDomain = "compute.opendc.org", topology),
+                )
 
-            val service = provisioner.registry.resolve("compute.opendc.org", ComputeService::class.java)!!
-            service.replay(timeSource, workload, seed)
-        }
+                val service = provisioner.registry.resolve("compute.opendc.org", ComputeService::class.java)!!
+                service.replay(timeSource, workload, seed)
+            }
 
-        println(
-            "Scheduler " +
-                "Success=${monitor.attemptsSuccess} " +
-                "Failure=${monitor.attemptsFailure} " +
-                "Error=${monitor.attemptsError} " +
-                "Pending=${monitor.serversPending} " +
-                "Active=${monitor.serversActive}"
-        )
+            println(
+                "Scheduler " +
+                    "Success=${monitor.attemptsSuccess} " +
+                    "Failure=${monitor.attemptsFailure} " +
+                    "Error=${monitor.attemptsError} " +
+                    "Pending=${monitor.serversPending} " +
+                    "Active=${monitor.serversActive}",
+            )
 
-        // Note that these values have been verified beforehand
-        assertAll(
-            { assertEquals(50, monitor.attemptsSuccess, "The scheduler should schedule 50 VMs") },
-            { assertEquals(0, monitor.serversActive, "All VMs should finish after a run") },
-            { assertEquals(0, monitor.attemptsFailure, "No VM should be unscheduled") },
-            { assertEquals(0, monitor.serversPending, "No VM should not be in the queue") },
-            { assertEquals(223379991650, monitor.idleTime) { "Incorrect idle time" } },
-            { assertEquals(66977091124, monitor.activeTime) { "Incorrect active time" } },
-            { assertEquals(3160267873, monitor.stealTime) { "Incorrect steal time" } },
-            { assertEquals(0, monitor.lostTime) { "Incorrect lost time" } },
-            { assertEquals(5.8407E9, monitor.energyUsage, 1E4) { "Incorrect power draw" } }
-        )
-    }
+            // Note that these values have been verified beforehand
+            assertAll(
+                { assertEquals(50, monitor.attemptsSuccess, "The scheduler should schedule 50 VMs") },
+                { assertEquals(0, monitor.serversActive, "All VMs should finish after a run") },
+                { assertEquals(0, monitor.attemptsFailure, "No VM should be unscheduled") },
+                { assertEquals(0, monitor.serversPending, "No VM should not be in the queue") },
+                { assertEquals(223379991650, monitor.idleTime) { "Incorrect idle time" } },
+                { assertEquals(66977091124, monitor.activeTime) { "Incorrect active time" } },
+                { assertEquals(3160267873, monitor.stealTime) { "Incorrect steal time" } },
+                { assertEquals(0, monitor.lostTime) { "Incorrect lost time" } },
+                { assertEquals(5.8407E9, monitor.energyUsage, 1E4) { "Incorrect power draw" } },
+            )
+        }
 
     /**
      * Test a small simulation setup.
      */
     @Test
-    fun testSmall() = runSimulation {
-        val seed = 1L
-        val workload = createTestWorkload(0.25, seed)
-        val topology = createTopology("single")
-        val monitor = monitor
+    fun testSmall() =
+        runSimulation {
+            val seed = 1L
+            val workload = createTestWorkload(0.25, seed)
+            val topology = createTopology("single")
+            val monitor = monitor
 
-        Provisioner(dispatcher, seed).use { provisioner ->
-            provisioner.runSteps(
-                setupComputeService(serviceDomain = "compute.opendc.org", { computeScheduler }),
-                registerComputeMonitor(serviceDomain = "compute.opendc.org", monitor),
-                setupHosts(serviceDomain = "compute.opendc.org", topology)
-            )
+            Provisioner(dispatcher, seed).use { provisioner ->
+                provisioner.runSteps(
+                    setupComputeService(serviceDomain = "compute.opendc.org", { computeScheduler }),
+                    registerComputeMonitor(serviceDomain = "compute.opendc.org", monitor),
+                    setupHosts(serviceDomain = "compute.opendc.org", topology),
+                )
 
-            val service = provisioner.registry.resolve("compute.opendc.org", ComputeService::class.java)!!
-            service.replay(timeSource, workload, seed)
-        }
+                val service = provisioner.registry.resolve("compute.opendc.org", ComputeService::class.java)!!
+                service.replay(timeSource, workload, seed)
+            }
 
-        println(
-            "Scheduler " +
-                "Success=${monitor.attemptsSuccess} " +
-                "Failure=${monitor.attemptsFailure} " +
-                "Error=${monitor.attemptsError} " +
-                "Pending=${monitor.serversPending} " +
-                "Active=${monitor.serversActive}"
-        )
+            println(
+                "Scheduler " +
+                    "Success=${monitor.attemptsSuccess} " +
+                    "Failure=${monitor.attemptsFailure} " +
+                    "Error=${monitor.attemptsError} " +
+                    "Pending=${monitor.serversPending} " +
+                    "Active=${monitor.serversActive}",
+            )
 
-        // Note that these values have been verified beforehand
-        assertAll(
-            { assertEquals(10996730092, monitor.idleTime) { "Idle time incorrect" } },
-            { assertEquals(9741285381, monitor.activeTime) { "Active time incorrect" } },
-            { assertEquals(152, monitor.stealTime) { "Steal time incorrect" } },
-            { assertEquals(0, monitor.lostTime) { "Lost time incorrect" } },
-            { assertEquals(7.0109E8, monitor.energyUsage, 1E4) { "Incorrect power draw" } }
-        )
-    }
+            // Note that these values have been verified beforehand
+            assertAll(
+                { assertEquals(10996730092, monitor.idleTime) { "Idle time incorrect" } },
+                { assertEquals(9741285381, monitor.activeTime) { "Active time incorrect" } },
+                { assertEquals(152, monitor.stealTime) { "Steal time incorrect" } },
+                { assertEquals(0, monitor.lostTime) { "Lost time incorrect" } },
+                { assertEquals(7.0109E8, monitor.energyUsage, 1E4) { "Incorrect power draw" } },
+            )
+        }
 
     /**
      * Test a small simulation setup with interference.
      */
     @Test
-    fun testInterference() = runSimulation {
-        val seed = 0L
-        val workload = createTestWorkload(1.0, seed)
-        val topology = createTopology("single")
+    fun testInterference() =
+        runSimulation {
+            val seed = 0L
+            val workload = createTestWorkload(1.0, seed)
+            val topology = createTopology("single")
 
-        Provisioner(dispatcher, seed).use { provisioner ->
-            provisioner.runSteps(
-                setupComputeService(serviceDomain = "compute.opendc.org", { computeScheduler }),
-                registerComputeMonitor(serviceDomain = "compute.opendc.org", monitor),
-                setupHosts(serviceDomain = "compute.opendc.org", topology)
-            )
+            Provisioner(dispatcher, seed).use { provisioner ->
+                provisioner.runSteps(
+                    setupComputeService(serviceDomain = "compute.opendc.org", { computeScheduler }),
+                    registerComputeMonitor(serviceDomain = "compute.opendc.org", monitor),
+                    setupHosts(serviceDomain = "compute.opendc.org", topology),
+                )
 
-            val service = provisioner.registry.resolve("compute.opendc.org", ComputeService::class.java)!!
-            service.replay(timeSource, workload, seed, interference = true)
-        }
+                val service = provisioner.registry.resolve("compute.opendc.org", ComputeService::class.java)!!
+                service.replay(timeSource, workload, seed, interference = true)
+            }
 
-        println(
-            "Scheduler " +
-                "Success=${monitor.attemptsSuccess} " +
-                "Failure=${monitor.attemptsFailure} " +
-                "Error=${monitor.attemptsError} " +
-                "Pending=${monitor.serversPending} " +
-                "Active=${monitor.serversActive}"
-        )
+            println(
+                "Scheduler " +
+                    "Success=${monitor.attemptsSuccess} " +
+                    "Failure=${monitor.attemptsFailure} " +
+                    "Error=${monitor.attemptsError} " +
+                    "Pending=${monitor.serversPending} " +
+                    "Active=${monitor.serversActive}",
+            )
 
-        // Note that these values have been verified beforehand
-        assertAll(
-            { assertEquals(42814948316, monitor.idleTime) { "Idle time incorrect" } },
-            { assertEquals(40138266225, monitor.activeTime) { "Active time incorrect" } },
-            { assertEquals(23489356981, monitor.stealTime) { "Steal time incorrect" } },
-            { assertEquals(424267131, monitor.lostTime) { "Lost time incorrect" } }
-        )
-    }
+            // Note that these values have been verified beforehand
+            assertAll(
+                { assertEquals(42814948316, monitor.idleTime) { "Idle time incorrect" } },
+                { assertEquals(40138266225, monitor.activeTime) { "Active time incorrect" } },
+                { assertEquals(23489356981, monitor.stealTime) { "Steal time incorrect" } },
+                { assertEquals(424267131, monitor.lostTime) { "Lost time incorrect" } },
+            )
+        }
 
     /**
      * Test a small simulation setup with failures.
      */
     @Test
-    fun testFailures() = runSimulation {
-        val seed = 0L
-        val topology = createTopology("single")
-        val workload = createTestWorkload(0.25, seed)
-        val monitor = monitor
+    fun testFailures() =
+        runSimulation {
+            val seed = 0L
+            val topology = createTopology("single")
+            val workload = createTestWorkload(0.25, seed)
+            val monitor = monitor
 
-        Provisioner(dispatcher, seed).use { provisioner ->
-            provisioner.runSteps(
-                setupComputeService(serviceDomain = "compute.opendc.org", { computeScheduler }),
-                registerComputeMonitor(serviceDomain = "compute.opendc.org", monitor),
-                setupHosts(serviceDomain = "compute.opendc.org", topology)
-            )
+            Provisioner(dispatcher, seed).use { provisioner ->
+                provisioner.runSteps(
+                    setupComputeService(serviceDomain = "compute.opendc.org", { computeScheduler }),
+                    registerComputeMonitor(serviceDomain = "compute.opendc.org", monitor),
+                    setupHosts(serviceDomain = "compute.opendc.org", topology),
+                )
 
-            val service = provisioner.registry.resolve("compute.opendc.org", ComputeService::class.java)!!
-            service.replay(timeSource, workload, seed, failureModel = grid5000(Duration.ofDays(7)))
-        }
+                val service = provisioner.registry.resolve("compute.opendc.org", ComputeService::class.java)!!
+                service.replay(timeSource, workload, seed, failureModel = grid5000(Duration.ofDays(7)))
+            }
 
-        // Note that these values have been verified beforehand
-        assertAll(
-            { assertEquals(1404277711, monitor.idleTime) { "Idle time incorrect" } },
-            { assertEquals(1478675712, monitor.activeTime) { "Active time incorrect" } },
-            { assertEquals(152, monitor.stealTime) { "Steal time incorrect" } },
-            { assertEquals(0, monitor.lostTime) { "Lost time incorrect" } },
-            { assertEquals(360369187, monitor.uptime) { "Uptime incorrect" } }
-        )
-    }
+            // Note that these values have been verified beforehand
+            assertAll(
+                { assertEquals(1404277711, monitor.idleTime) { "Idle time incorrect" } },
+                { assertEquals(1478675712, monitor.activeTime) { "Active time incorrect" } },
+                { assertEquals(152, monitor.stealTime) { "Steal time incorrect" } },
+                { assertEquals(0, monitor.lostTime) { "Lost time incorrect" } },
+                { assertEquals(360369187, monitor.uptime) { "Uptime incorrect" } },
+            )
+        }
 
     /**
      * Obtain the trace reader for the test.
      */
-    private fun createTestWorkload(fraction: Double, seed: Long): List<VirtualMachine> {
+    private fun createTestWorkload(
+        fraction: Double,
+        seed: Long,
+    ): List<VirtualMachine> {
         val source = trace("bitbrains-small").sampleByLoad(fraction)
         return source.resolve(workloadLoader, Random(seed))
     }
diff --git a/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/CapelinRunnerTest.kt b/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/CapelinRunnerTest.kt
index 7354e7a5..32d53aee 100644
--- a/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/CapelinRunnerTest.kt
+++ b/opendc-experiments/opendc-experiments-capelin/src/test/kotlin/org/opendc/experiments/capelin/CapelinRunnerTest.kt
@@ -46,20 +46,20 @@ class CapelinRunnerTest {
     private val tracePath = File("src/test/resources/trace")
 
     /**
-     * Smoke test with output.
+     * Smoke test with output. fixme: Fix failures and enable Test
      */
-//    @Test // fixme: Fix failures and enable
     fun testSmoke() {
         val outputPath = Files.createTempDirectory("output").toFile()
 
         try {
             val runner = CapelinRunner(envPath, tracePath, outputPath)
-            val scenario = Scenario(
-                Topology("topology"),
-                Workload("bitbrains-small", trace("bitbrains-small")),
-                OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true),
-                "active-servers"
-            )
+            val scenario =
+                Scenario(
+                    Topology("topology"),
+                    Workload("bitbrains-small", trace("bitbrains-small")),
+                    OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true),
+                    "active-servers",
+                )
 
             assertDoesNotThrow { runner.runScenario(scenario, seed = 0L) }
         } finally {
@@ -68,17 +68,17 @@ class CapelinRunnerTest {
     }
 
     /**
-     * Smoke test without output.
+     * Smoke test without output. fixme: Fix failures and enable Test
      */
-//    @Test // fixme: Fix failures and enable
     fun testSmokeNoOutput() {
         val runner = CapelinRunner(envPath, tracePath, null)
-        val scenario = Scenario(
-            Topology("topology"),
-            Workload("bitbrains-small", trace("bitbrains-small")),
-            OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true),
-            "active-servers"
-        )
+        val scenario =
+            Scenario(
+                Topology("topology"),
+                Workload("bitbrains-small", trace("bitbrains-small")),
+                OperationalPhenomena(failureFrequency = 24.0 * 7, hasInterference = true),
+                "active-servers",
+            )
 
         assertDoesNotThrow { runner.runScenario(scenario, seed = 0L) }
     }