compute: Separate cloud compute layer from bare-metal layer

This change separates the cloud compute layer in OpenDC (e.g., Server)
from the bare-metal layer (e.g., Node), such that Node and
BareMetalDriver are unaware of the existence of Server and co.

1 files changed, 29 insertions, 28 deletions

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..b7a26d34 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
@@ -24,7 +24,8 @@ 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.metal.Node
+import org.opendc.compute.core.metal.NodeState
 import org.opendc.compute.core.virt.driver.VirtDriver
 import org.opendc.compute.core.virt.service.VirtProvisioningEvent
 import org.opendc.experiments.capelin.monitor.ExperimentMonitor
@@ -36,7 +37,7 @@ 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) {
@@ -51,11 +52,11 @@ public class WebExperimentMonitor : ExperimentMonitor {
     override fun reportHostStateChange(
         time: Long,
         driver: VirtDriver,
-        server: Server
+        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 +79,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 +98,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 +115,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 +133,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 +145,7 @@ public class WebExperimentMonitor : ExperimentMonitor {
                 val event = HostEvent(
                     time,
                     time - previousEvent.timestamp,
-                    hostServer,
+                    host,
                     numberOfDeployedImages,
                     requestedBurst,
                     grantedBurst,
@@ -152,17 +153,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 +174,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)
             )