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.

3 files changed, 47 insertions, 39 deletions

diff --git a/simulator/opendc-runner-web/src/main/kotlin/org/opendc/runner/web/Main.kt b/simulator/opendc-runner-web/src/main/kotlin/org/opendc/runner/web/Main.kt
index 533bf321..482fe754 100644
--- a/simulator/opendc-runner-web/src/main/kotlin/org/opendc/runner/web/Main.kt
+++ b/simulator/opendc-runner-web/src/main/kotlin/org/opendc/runner/web/Main.kt
@@ -40,6 +40,11 @@ import kotlinx.coroutines.test.TestCoroutineScope
 import mu.KotlinLogging
 import org.bson.Document
 import org.bson.types.ObjectId
+import org.opendc.compute.service.scheduler.AvailableCoreMemoryAllocationPolicy
+import org.opendc.compute.service.scheduler.AvailableMemoryAllocationPolicy
+import org.opendc.compute.service.scheduler.NumberOfActiveServersAllocationPolicy
+import org.opendc.compute.service.scheduler.ProvisionedCoresAllocationPolicy
+import org.opendc.compute.service.scheduler.RandomAllocationPolicy
 import org.opendc.compute.simulator.allocation.*
 import org.opendc.experiments.capelin.experiment.attachMonitor
 import org.opendc.experiments.capelin.experiment.createFailureDomain
@@ -242,7 +247,7 @@ public class RunnerCli : CliktCommand(name = "runner") {
         val tracer = EventTracer(clock)
 
         testScope.launch {
-            val (bareMetalProvisioner, scheduler) = createProvisioner(
+            val (bareMetalProvisioner, provisioner, scheduler) = createProvisioner(
                 this,
                 clock,
                 environment,
@@ -281,7 +286,8 @@ public class RunnerCli : CliktCommand(name = "runner") {
             logger.debug("FINISHED=${scheduler.finishedVms}")
 
             failureDomain?.cancel()
-            scheduler.terminate()
+            scheduler.close()
+            provisioner.close()
         }
 
         try {
diff --git a/simulator/opendc-runner-web/src/main/kotlin/org/opendc/runner/web/TopologyParser.kt b/simulator/opendc-runner-web/src/main/kotlin/org/opendc/runner/web/TopologyParser.kt
index f43d0869..2f11347d 100644
--- a/simulator/opendc-runner-web/src/main/kotlin/org/opendc/runner/web/TopologyParser.kt
+++ b/simulator/opendc-runner-web/src/main/kotlin/org/opendc/runner/web/TopologyParser.kt
@@ -32,9 +32,6 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import org.bson.Document
 import org.bson.types.ObjectId
-import org.opendc.compute.core.metal.NODE_CLUSTER
-import org.opendc.compute.core.metal.service.ProvisioningService
-import org.opendc.compute.core.metal.service.SimpleProvisioningService
 import org.opendc.compute.simulator.SimBareMetalDriver
 import org.opendc.compute.simulator.power.models.LinearPowerModel
 import org.opendc.core.Environment
@@ -42,6 +39,9 @@ import org.opendc.core.Platform
 import org.opendc.core.Zone
 import org.opendc.core.services.ServiceRegistry
 import org.opendc.format.environment.EnvironmentReader
+import org.opendc.metal.NODE_CLUSTER
+import org.opendc.metal.service.ProvisioningService
+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
diff --git a/simulator/opendc-runner-web/src/main/kotlin/org/opendc/runner/web/WebExperimentMonitor.kt b/simulator/opendc-runner-web/src/main/kotlin/org/opendc/runner/web/WebExperimentMonitor.kt
index f16f9b90..fe814c76 100644
--- a/simulator/opendc-runner-web/src/main/kotlin/org/opendc/runner/web/WebExperimentMonitor.kt
+++ b/simulator/opendc-runner-web/src/main/kotlin/org/opendc/runner/web/WebExperimentMonitor.kt
@@ -23,12 +23,14 @@
 package org.opendc.runner.web
 
 import mu.KotlinLogging
-import org.opendc.compute.core.Server
-import org.opendc.compute.core.ServerState
-import org.opendc.compute.core.virt.driver.VirtDriver
-import org.opendc.compute.core.virt.service.VirtProvisioningEvent
+import org.opendc.compute.api.Server
+import org.opendc.compute.api.ServerState
+import org.opendc.compute.service.ComputeServiceEvent
+import org.opendc.compute.service.driver.Host
 import org.opendc.experiments.capelin.monitor.ExperimentMonitor
 import org.opendc.experiments.capelin.telemetry.HostEvent
+import org.opendc.metal.Node
+import org.opendc.metal.NodeState
 import kotlin.math.max
 
 /**
@@ -36,10 +38,10 @@ import kotlin.math.max
  */
 public class WebExperimentMonitor : ExperimentMonitor {
     private val logger = KotlinLogging.logger {}
-    private val currentHostEvent = mutableMapOf<Server, HostEvent>()
+    private val currentHostEvent = mutableMapOf<Node, HostEvent>()
     private var startTime = -1L
 
-    override fun reportVmStateChange(time: Long, server: Server) {
+    override fun reportVmStateChange(time: Long, server: Server, newState: ServerState) {
         if (startTime < 0) {
             startTime = time
 
@@ -50,12 +52,12 @@ public class WebExperimentMonitor : ExperimentMonitor {
 
     override fun reportHostStateChange(
         time: Long,
-        driver: VirtDriver,
-        server: Server
+        driver: Host,
+        host: Node
     ) {
-        logger.debug { "Host ${server.uid} changed state ${server.state} [$time]" }
+        logger.debug { "Host ${host.uid} changed state ${host.state} [$time]" }
 
-        val previousEvent = currentHostEvent[server]
+        val previousEvent = currentHostEvent[host]
 
         val roundedTime = previousEvent?.let {
             val duration = time - it.timestamp
@@ -78,13 +80,13 @@ public class WebExperimentMonitor : ExperimentMonitor {
             0.0,
             0.0,
             0,
-            server
+            host
         )
     }
 
-    private val lastPowerConsumption = mutableMapOf<Server, Double>()
+    private val lastPowerConsumption = mutableMapOf<Node, Double>()
 
-    override fun reportPowerConsumption(host: Server, draw: Double) {
+    override fun reportPowerConsumption(host: Node, draw: Double) {
         lastPowerConsumption[host] = draw
     }
 
@@ -97,16 +99,16 @@ public class WebExperimentMonitor : ExperimentMonitor {
         cpuUsage: Double,
         cpuDemand: Double,
         numberOfDeployedImages: Int,
-        hostServer: Server,
+        host: Node,
         duration: Long
     ) {
-        val previousEvent = currentHostEvent[hostServer]
+        val previousEvent = currentHostEvent[host]
         when {
             previousEvent == null -> {
                 val event = HostEvent(
                     time,
                     5 * 60 * 1000L,
-                    hostServer,
+                    host,
                     numberOfDeployedImages,
                     requestedBurst,
                     grantedBurst,
@@ -114,17 +116,17 @@ public class WebExperimentMonitor : ExperimentMonitor {
                     interferedBurst,
                     cpuUsage,
                     cpuDemand,
-                    lastPowerConsumption[hostServer] ?: 200.0,
-                    hostServer.flavor.cpuCount
+                    lastPowerConsumption[host] ?: 200.0,
+                    host.flavor.cpuCount
                 )
 
-                currentHostEvent[hostServer] = event
+                currentHostEvent[host] = event
             }
             previousEvent.timestamp == time -> {
                 val event = HostEvent(
                     time,
                     previousEvent.duration,
-                    hostServer,
+                    host,
                     numberOfDeployedImages,
                     requestedBurst,
                     grantedBurst,
@@ -132,11 +134,11 @@ public class WebExperimentMonitor : ExperimentMonitor {
                     interferedBurst,
                     cpuUsage,
                     cpuDemand,
-                    lastPowerConsumption[hostServer] ?: 200.0,
-                    hostServer.flavor.cpuCount
+                    lastPowerConsumption[host] ?: 200.0,
+                    host.flavor.cpuCount
                 )
 
-                currentHostEvent[hostServer] = event
+                currentHostEvent[host] = event
             }
             else -> {
                 processHostEvent(previousEvent)
@@ -144,7 +146,7 @@ public class WebExperimentMonitor : ExperimentMonitor {
                 val event = HostEvent(
                     time,
                     time - previousEvent.timestamp,
-                    hostServer,
+                    host,
                     numberOfDeployedImages,
                     requestedBurst,
                     grantedBurst,
@@ -152,17 +154,17 @@ public class WebExperimentMonitor : ExperimentMonitor {
                     interferedBurst,
                     cpuUsage,
                     cpuDemand,
-                    lastPowerConsumption[hostServer] ?: 200.0,
-                    hostServer.flavor.cpuCount
+                    lastPowerConsumption[host] ?: 200.0,
+                    host.flavor.cpuCount
                 )
 
-                currentHostEvent[hostServer] = event
+                currentHostEvent[host] = event
             }
         }
     }
 
     private var hostAggregateMetrics: AggregateHostMetrics = AggregateHostMetrics()
-    private val hostMetrics: MutableMap<Server, HostMetrics> = mutableMapOf()
+    private val hostMetrics: MutableMap<Node, HostMetrics> = mutableMapOf()
 
     private fun processHostEvent(event: HostEvent) {
         val slices = event.duration / SLICE_LENGTH
@@ -173,14 +175,14 @@ public class WebExperimentMonitor : ExperimentMonitor {
             hostAggregateMetrics.totalOvercommittedBurst + event.overcommissionedBurst,
             hostAggregateMetrics.totalInterferedBurst + event.interferedBurst,
             hostAggregateMetrics.totalPowerDraw + (slices * (event.powerDraw / 12)),
-            hostAggregateMetrics.totalFailureSlices + if (event.host.state != ServerState.ACTIVE) slices.toLong() else 0,
-            hostAggregateMetrics.totalFailureVmSlices + if (event.host.state != ServerState.ACTIVE) event.vmCount * slices.toLong() else 0
+            hostAggregateMetrics.totalFailureSlices + if (event.node.state != NodeState.ACTIVE) slices.toLong() else 0,
+            hostAggregateMetrics.totalFailureVmSlices + if (event.node.state != NodeState.ACTIVE) event.vmCount * slices.toLong() else 0
         )
 
-        hostMetrics.compute(event.host) { key, prev ->
+        hostMetrics.compute(event.node) { _, prev ->
             HostMetrics(
-                (event.cpuUsage.takeIf { event.host.state == ServerState.ACTIVE } ?: 0.0) + (prev?.cpuUsage ?: 0.0),
-                (event.cpuDemand.takeIf { event.host.state == ServerState.ACTIVE } ?: 0.0) + (prev?.cpuDemand ?: 0.0),
+                (event.cpuUsage.takeIf { event.node.state == NodeState.ACTIVE } ?: 0.0) + (prev?.cpuUsage ?: 0.0),
+                (event.cpuDemand.takeIf { event.node.state == NodeState.ACTIVE } ?: 0.0) + (prev?.cpuDemand ?: 0.0),
                 event.vmCount + (prev?.vmCount ?: 0),
                 1 + (prev?.count ?: 0)
             )
@@ -208,7 +210,7 @@ public class WebExperimentMonitor : ExperimentMonitor {
 
     private var provisionerMetrics: AggregateProvisionerMetrics = AggregateProvisionerMetrics()
 
-    override fun reportProvisionerMetrics(time: Long, event: VirtProvisioningEvent.MetricsAvailable) {
+    override fun reportProvisionerMetrics(time: Long, event: ComputeServiceEvent.MetricsAvailable) {
         provisionerMetrics = AggregateProvisionerMetrics(
             max(event.totalVmCount, provisionerMetrics.vmTotalCount),
             max(event.waitingVmCount, provisionerMetrics.vmWaitingCount),