compute: Improvements to cloud compute model (v1)

This is the first of the pull requests in an attempt to improve the existing cloud compute model (see #86). This pull request restructures the compute API and splits the consumer and service interfaces into different modules:

- opendc-compute-api now defines the API interface for the OpenDC Compute module, which can be used by consumers of the OpenDC Compute service.
- opendc-compute-service hosts the service implementation for OpenDC Compute and contains all business logic regarding the IaaS platform (such as scheduling).
- opendc-compute-simulator implements a "compute driver" for the OpenDC Compute platform that simulates submitted workloads.
- Image is now a data-class and does not specify itself the workload to simulate. Instead, the workload should be passed via its tags currently (with key "workload"). In the future, the simulation backend will accept a mapper interface that maps Images to Workloads.

4 files changed, 75 insertions, 41 deletions

diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimBareMetalDriverTest.kt b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimBareMetalDriverTest.kt
index fb8a5f47..0d90376e 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimBareMetalDriverTest.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimBareMetalDriverTest.kt
@@ -30,8 +30,10 @@ import kotlinx.coroutines.withContext
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
-import org.opendc.compute.core.ServerEvent
-import org.opendc.compute.core.ServerState
+import org.junit.jupiter.api.assertAll
+import org.opendc.compute.api.Image
+import org.opendc.metal.NodeEvent
+import org.opendc.metal.NodeState
 import org.opendc.simulator.compute.SimMachineModel
 import org.opendc.simulator.compute.model.MemoryUnit
 import org.opendc.simulator.compute.model.ProcessingNode
@@ -59,22 +61,21 @@ internal class SimBareMetalDriverTest {
         val testScope = TestCoroutineScope()
         val clock = DelayControllerClockAdapter(testScope)
 
-        var finalState: ServerState = ServerState.BUILD
+        var finalState: NodeState = NodeState.UNKNOWN
         var finalTime = 0L
 
         testScope.launch {
             val driver = SimBareMetalDriver(this, clock, UUID.randomUUID(), "test", emptyMap(), machineModel)
-            val image = SimWorkloadImage(UUID.randomUUID(), "<unnamed>", emptyMap(), SimFlopsWorkload(4_000, utilization = 1.0))
-
+            val image = Image(UUID.randomUUID(), "<unnamed>", mapOf("workload" to SimFlopsWorkload(4_000, utilization = 1.0)))
             // Batch driver commands
             withContext(coroutineContext) {
                 driver.init()
                 driver.setImage(image)
-                val server = driver.start().server!!
-                server.events.collect { event ->
+                val node = driver.start()
+                node.events.collect { event ->
                     when (event) {
-                        is ServerEvent.StateChanged -> {
-                            finalState = event.server.state
+                        is NodeEvent.StateChanged -> {
+                            finalState = event.node.state
                             finalTime = clock.millis()
                         }
                     }
@@ -83,7 +84,9 @@ internal class SimBareMetalDriverTest {
         }
 
         testScope.advanceUntilIdle()
-        assertEquals(ServerState.SHUTOFF, finalState)
-        assertEquals(501, finalTime)
+        assertAll(
+            { assertEquals(NodeState.SHUTOFF, finalState) },
+            { assertEquals(501, finalTime) }
+        )
     }
 }
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimVirtDriverTest.kt b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimHostTest.kt
index 1831eae0..61bff39f 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimVirtDriverTest.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimHostTest.kt
@@ -24,6 +24,7 @@ package org.opendc.compute.simulator
 
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.emptyFlow
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
@@ -32,8 +33,14 @@ import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertAll
-import org.opendc.compute.core.Flavor
-import org.opendc.compute.core.virt.HypervisorEvent
+import org.opendc.compute.api.Flavor
+import org.opendc.compute.api.Image
+import org.opendc.compute.api.Server
+import org.opendc.compute.api.ServerState
+import org.opendc.compute.api.ServerWatcher
+import org.opendc.compute.service.driver.HostEvent
+import org.opendc.metal.Node
+import org.opendc.metal.NodeState
 import org.opendc.simulator.compute.SimFairShareHypervisorProvider
 import org.opendc.simulator.compute.SimMachineModel
 import org.opendc.simulator.compute.model.MemoryUnit
@@ -48,7 +55,7 @@ import java.util.UUID
  * Basic test-suite for the hypervisor.
  */
 @OptIn(ExperimentalCoroutinesApi::class)
-internal class SimVirtDriverTest {
+internal class SimHostTest {
     private lateinit var scope: TestCoroutineScope
     private lateinit var clock: Clock
     private lateinit var machineModel: SimMachineModel
@@ -75,35 +82,42 @@ internal class SimVirtDriverTest {
         var grantedWork = 0L
         var overcommittedWork = 0L
 
+        val node = Node(
+            UUID.randomUUID(), "name", emptyMap(), NodeState.SHUTOFF,
+            Flavor(machineModel.cpus.size, machineModel.memory.map { it.size }.sum()), Image.EMPTY, emptyFlow()
+        )
+
         scope.launch {
-            val virtDriver = SimVirtDriver(this, SimFairShareHypervisorProvider())
-            val vmm = SimWorkloadImage(UUID.randomUUID(), "vmm", emptyMap(), virtDriver)
+            val virtDriver = SimHost(node, this, SimFairShareHypervisorProvider())
+            val vmm = Image(UUID.randomUUID(), "vmm", mapOf("workload" to virtDriver))
             val duration = 5 * 60L
-            val vmImageA = SimWorkloadImage(
+            val vmImageA = Image(
                 UUID.randomUUID(),
                 "<unnamed>",
-                emptyMap(),
-                SimTraceWorkload(
-                    sequenceOf(
-                        SimTraceWorkload.Fragment(duration * 1000, 28.0, 2),
-                        SimTraceWorkload.Fragment(duration * 1000, 3500.0, 2),
-                        SimTraceWorkload.Fragment(duration * 1000, 0.0, 2),
-                        SimTraceWorkload.Fragment(duration * 1000, 183.0, 2)
-                    ),
+                mapOf(
+                    "workload" to SimTraceWorkload(
+                        sequenceOf(
+                            SimTraceWorkload.Fragment(duration * 1000, 28.0, 2),
+                            SimTraceWorkload.Fragment(duration * 1000, 3500.0, 2),
+                            SimTraceWorkload.Fragment(duration * 1000, 0.0, 2),
+                            SimTraceWorkload.Fragment(duration * 1000, 183.0, 2)
+                        ),
+                    )
                 )
             )
-            val vmImageB = SimWorkloadImage(
+            val vmImageB = Image(
                 UUID.randomUUID(),
                 "<unnamed>",
-                emptyMap(),
-                SimTraceWorkload(
-                    sequenceOf(
-                        SimTraceWorkload.Fragment(duration * 1000, 28.0, 2),
-                        SimTraceWorkload.Fragment(duration * 1000, 3100.0, 2),
-                        SimTraceWorkload.Fragment(duration * 1000, 0.0, 2),
-                        SimTraceWorkload.Fragment(duration * 1000, 73.0, 2)
+                mapOf(
+                    "workload" to SimTraceWorkload(
+                        sequenceOf(
+                            SimTraceWorkload.Fragment(duration * 1000, 28.0, 2),
+                            SimTraceWorkload.Fragment(duration * 1000, 3100.0, 2),
+                            SimTraceWorkload.Fragment(duration * 1000, 0.0, 2),
+                            SimTraceWorkload.Fragment(duration * 1000, 73.0, 2)
+                        )
                     )
-                ),
+                )
             )
 
             val metalDriver =
@@ -119,7 +133,7 @@ internal class SimVirtDriverTest {
             virtDriver.events
                 .onEach { event ->
                     when (event) {
-                        is HypervisorEvent.SliceFinished -> {
+                        is HostEvent.SliceFinished -> {
                             requestedWork += event.requestedBurst
                             grantedWork += event.grantedBurst
                             overcommittedWork += event.overcommissionedBurst
@@ -128,8 +142,8 @@ internal class SimVirtDriverTest {
                 }
                 .launchIn(this)
 
-            virtDriver.spawn("a", vmImageA, flavor)
-            virtDriver.spawn("b", vmImageB, flavor)
+            launch { virtDriver.spawn(MockServer(UUID.randomUUID(), "a", flavor, vmImageA)) }
+            launch { virtDriver.spawn(MockServer(UUID.randomUUID(), "b", flavor, vmImageB)) }
         }
 
         scope.advanceUntilIdle()
@@ -142,4 +156,20 @@ internal class SimVirtDriverTest {
             { assertEquals(1200006, scope.currentTime) }
         )
     }
+
+    private class MockServer(
+        override val uid: UUID,
+        override val name: String,
+        override val flavor: Flavor,
+        override val image: Image
+    ) : Server {
+        override val tags: Map<String, String> = emptyMap()
+        override val state: ServerState = ServerState.BUILD
+
+        override fun watch(watcher: ServerWatcher) {}
+
+        override fun unwatch(watcher: ServerWatcher) {}
+
+        override suspend fun refresh() {}
+    }
 }
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimProvisioningServiceTest.kt b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimProvisioningServiceTest.kt
index a33a4e5f..33b3db94 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimProvisioningServiceTest.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimProvisioningServiceTest.kt
@@ -29,7 +29,8 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.TestCoroutineScope
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.Test
-import org.opendc.compute.core.metal.service.SimpleProvisioningService
+import org.opendc.compute.api.Image
+import org.opendc.metal.service.SimpleProvisioningService
 import org.opendc.simulator.compute.SimMachineModel
 import org.opendc.simulator.compute.model.MemoryUnit
 import org.opendc.simulator.compute.model.ProcessingNode
@@ -64,7 +65,7 @@ internal class SimProvisioningServiceTest {
         val clock = DelayControllerClockAdapter(testScope)
 
         testScope.launch {
-            val image = SimWorkloadImage(UUID.randomUUID(), "<unnamed>", emptyMap(), SimFlopsWorkload(1000))
+            val image = Image(UUID.randomUUID(), "<unnamed>", mapOf("machine" to SimFlopsWorkload(1000)))
             val driver = SimBareMetalDriver(this, clock, UUID.randomUUID(), "test", emptyMap(), machineModel)
 
             val provisioner = SimpleProvisioningService()
@@ -72,7 +73,7 @@ internal class SimProvisioningServiceTest {
             delay(5)
             val nodes = provisioner.nodes()
             val node = provisioner.deploy(nodes.first(), image)
-            node.server!!.events.collect { println(it) }
+            node.events.collect { println(it) }
         }
 
         testScope.advanceUntilIdle()
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/power/CpuPowerModelTest.kt b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/power/CpuPowerModelTest.kt
index 7b0c7515..d4d88fb1 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/power/CpuPowerModelTest.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/power/CpuPowerModelTest.kt
@@ -7,9 +7,9 @@ import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.MethodSource
-import org.opendc.compute.core.metal.driver.BareMetalDriver
 import org.opendc.compute.simulator.power.api.CpuPowerModel
 import org.opendc.compute.simulator.power.models.*
+import org.opendc.metal.driver.BareMetalDriver
 import java.util.stream.Stream
 import kotlin.math.pow