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.

14 files changed, 86 insertions, 242 deletions

diff --git a/simulator/opendc-compute/opendc-compute-core/src/main/kotlin/org/opendc/compute/core/metal/Node.kt b/simulator/opendc-compute/opendc-compute-core/src/main/kotlin/org/opendc/compute/core/metal/Node.kt
index 6d9506f1..480bc224 100644
--- a/simulator/opendc-compute/opendc-compute-core/src/main/kotlin/org/opendc/compute/core/metal/Node.kt
+++ b/simulator/opendc-compute/opendc-compute-core/src/main/kotlin/org/opendc/compute/core/metal/Node.kt
@@ -23,7 +23,7 @@
 package org.opendc.compute.core.metal
 
 import kotlinx.coroutines.flow.Flow
-import org.opendc.compute.core.Server
+import org.opendc.compute.core.Flavor
 import org.opendc.compute.core.image.Image
 import org.opendc.core.Identity
 import java.util.UUID
@@ -53,14 +53,14 @@ public data class Node(
     public val state: NodeState,
 
     /**
-     * The boot image of the node.
+     * The flavor of the node.
      */
-    public val image: Image,
+    public val flavor: Flavor,
 
     /**
-     * The server instance that is running on the node or `null` if no server is running.
+     * The boot image of the node.
      */
-    public val server: Server?,
+    public val image: Image,
 
     /**
      * The events that are emitted by the node.
diff --git a/simulator/opendc-compute/opendc-compute-core/src/main/kotlin/org/opendc/compute/core/virt/HypervisorEvent.kt b/simulator/opendc-compute/opendc-compute-core/src/main/kotlin/org/opendc/compute/core/virt/HypervisorEvent.kt
index 9fb437de..d1c8d790 100644
--- a/simulator/opendc-compute/opendc-compute-core/src/main/kotlin/org/opendc/compute/core/virt/HypervisorEvent.kt
+++ b/simulator/opendc-compute/opendc-compute-core/src/main/kotlin/org/opendc/compute/core/virt/HypervisorEvent.kt
@@ -22,7 +22,7 @@
 
 package org.opendc.compute.core.virt
 
-import org.opendc.compute.core.Server
+import org.opendc.compute.core.metal.Node
 import org.opendc.compute.core.virt.driver.VirtDriver
 
 /**
@@ -71,6 +71,6 @@ public sealed class HypervisorEvent {
         public val cpuUsage: Double,
         public val cpuDemand: Double,
         public val numberOfDeployedImages: Int,
-        public val hostServer: Server
+        public val host: Node
     ) : HypervisorEvent()
 }
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/ComputeSimExecutionContext.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/ComputeSimExecutionContext.kt
deleted file mode 100644
index 153a86b3..00000000
--- a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/ComputeSimExecutionContext.kt
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) 2020 AtLarge Research
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package org.opendc.compute.simulator
-
-import org.opendc.compute.core.Server
-import org.opendc.simulator.compute.SimExecutionContext
-
-/**
- * Extended [SimExecutionContext] in which workloads within the OpenDC Compute module run.
- */
-public interface ComputeSimExecutionContext : SimExecutionContext {
-    /**
-     * The server on which the image runs.
-     */
-    public val server: Server
-}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/HypervisorView.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/HypervisorView.kt
index 1a79523e..cf2747cd 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/HypervisorView.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/HypervisorView.kt
@@ -22,13 +22,13 @@
 
 package org.opendc.compute.simulator
 
-import org.opendc.compute.core.Server
+import org.opendc.compute.core.metal.Node
 import org.opendc.compute.core.virt.driver.VirtDriver
 import java.util.UUID
 
 public class HypervisorView(
     public val uid: UUID,
-    public var server: Server,
+    public var node: Node,
     public var numberOfActiveServers: Int,
     public var availableMemory: Long,
     public var provisionedCores: Int
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimBareMetalDriver.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimBareMetalDriver.kt
index 8af45616..a27c331d 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimBareMetalDriver.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimBareMetalDriver.kt
@@ -25,9 +25,6 @@ package org.opendc.compute.simulator
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.Flow
 import org.opendc.compute.core.Flavor
-import org.opendc.compute.core.Server
-import org.opendc.compute.core.ServerEvent
-import org.opendc.compute.core.ServerState
 import org.opendc.compute.core.image.Image
 import org.opendc.compute.core.metal.Node
 import org.opendc.compute.core.metal.NodeEvent
@@ -36,18 +33,14 @@ import org.opendc.compute.core.metal.driver.BareMetalDriver
 import org.opendc.compute.simulator.power.api.CpuPowerModel
 import org.opendc.compute.simulator.power.api.Powerable
 import org.opendc.compute.simulator.power.models.ConstantPowerModel
-import org.opendc.core.services.ServiceRegistry
 import org.opendc.simulator.compute.SimBareMetalMachine
-import org.opendc.simulator.compute.SimExecutionContext
 import org.opendc.simulator.compute.SimMachineModel
-import org.opendc.simulator.compute.workload.SimResourceCommand
 import org.opendc.simulator.compute.workload.SimWorkload
 import org.opendc.simulator.failures.FailureDomain
 import org.opendc.utils.flow.EventFlow
 import org.opendc.utils.flow.StateFlow
 import java.time.Clock
 import java.util.UUID
-import kotlin.random.Random
 
 /**
  * A basic implementation of the [BareMetalDriver] that simulates an [Image] running on a bare-metal machine.
@@ -87,7 +80,7 @@ public class SimBareMetalDriver(
      * The machine state.
      */
     private val nodeState =
-        StateFlow(Node(uid, name, metadata + ("driver" to this), NodeState.SHUTOFF, Image.EMPTY, null, events))
+        StateFlow(Node(uid, name, metadata + ("driver" to this), NodeState.SHUTOFF, flavor, Image.EMPTY, events))
 
     /**
      * The [SimBareMetalMachine] we use to run the workload.
@@ -102,20 +95,10 @@ public class SimBareMetalDriver(
     override val powerDraw: Flow<Double> = cpuPowerModel.getPowerDraw(this)
 
     /**
-     * The internal random instance.
-     */
-    private val random = Random(uid.leastSignificantBits xor uid.mostSignificantBits)
-
-    /**
      * The [Job] that runs the simulated workload.
      */
     private var job: Job? = null
 
-    /**
-     * The event stream to publish to for the server.
-     */
-    private var serverEvents: EventFlow<ServerEvent>? = null
-
     override suspend fun init(): Node {
         return nodeState.value
     }
@@ -126,51 +109,13 @@ public class SimBareMetalDriver(
             return node
         }
 
-        val events = EventFlow<ServerEvent>()
-        serverEvents = events
-        val server = Server(
-            UUID(random.nextLong(), random.nextLong()),
-            node.name,
-            emptyMap(),
-            flavor,
-            node.image,
-            ServerState.BUILD,
-            ServiceRegistry().put(BareMetalDriver, this@SimBareMetalDriver),
-            events
-        )
-
-        val delegate = node.image.tags["workload"] as SimWorkload
-        // Wrap the workload to pass in a ComputeSimExecutionContext
-        val workload = object : SimWorkload {
-            lateinit var wrappedCtx: ComputeSimExecutionContext
-
-            override fun onStart(ctx: SimExecutionContext) {
-                wrappedCtx = object : ComputeSimExecutionContext, SimExecutionContext by ctx {
-                    override val server: Server
-                        get() = nodeState.value.server!!
-
-                    override fun toString(): String = "WrappedSimExecutionContext"
-                }
-
-                delegate.onStart(wrappedCtx)
-            }
-
-            override fun onStart(ctx: SimExecutionContext, cpu: Int): SimResourceCommand {
-                return delegate.onStart(wrappedCtx, cpu)
-            }
-
-            override fun onNext(ctx: SimExecutionContext, cpu: Int, remainingWork: Double): SimResourceCommand {
-                return delegate.onNext(wrappedCtx, cpu, remainingWork)
-            }
-
-            override fun toString(): String = "SimWorkloadWrapper(delegate=$delegate)"
-        }
+        val workload = node.image.tags["workload"] as SimWorkload
 
         job = coroutineScope.launch {
             delay(1) // TODO Introduce boot time
             initMachine()
             try {
-                machine.run(workload)
+                machine.run(workload, mapOf("driver" to this@SimBareMetalDriver, "node" to node))
                 exitMachine(null)
             } catch (_: CancellationException) {
                 // Ignored
@@ -179,31 +124,21 @@ public class SimBareMetalDriver(
             }
         }
 
-        setNode(node.copy(state = NodeState.BOOT, server = server))
+        setNode(node.copy(state = NodeState.BOOT))
         return nodeState.value
     }
 
     private fun initMachine() {
-        val server = nodeState.value.server?.copy(state = ServerState.ACTIVE)
-        setNode(nodeState.value.copy(state = NodeState.ACTIVE, server = server))
+        setNode(nodeState.value.copy(state = NodeState.ACTIVE))
     }
 
     private fun exitMachine(cause: Throwable?) {
-        val newServerState =
-            if (cause == null)
-                ServerState.SHUTOFF
-            else
-                ServerState.ERROR
         val newNodeState =
             if (cause == null)
-                nodeState.value.state
+                NodeState.SHUTOFF
             else
                 NodeState.ERROR
-        val server = nodeState.value.server?.copy(state = newServerState)
-        setNode(nodeState.value.copy(state = newNodeState, server = server))
-
-        serverEvents?.close()
-        serverEvents = null
+        setNode(nodeState.value.copy(state = newNodeState))
     }
 
     override suspend fun stop(): Node {
@@ -213,7 +148,7 @@ public class SimBareMetalDriver(
         }
 
         job?.cancelAndJoin()
-        setNode(node.copy(state = NodeState.SHUTOFF, server = null))
+        setNode(node.copy(state = NodeState.SHUTOFF))
         return node
     }
 
@@ -235,13 +170,6 @@ public class SimBareMetalDriver(
             events.emit(NodeEvent.StateChanged(value, field.state))
         }
 
-        val oldServer = field.server
-        val newServer = value.server
-
-        if (oldServer != null && newServer != null && oldServer.state != newServer.state) {
-            serverEvents?.emit(ServerEvent.StateChanged(newServer, oldServer.state))
-        }
-
         nodeState.value = value
     }
 
@@ -249,13 +177,11 @@ public class SimBareMetalDriver(
         get() = coroutineScope
 
     override suspend fun fail() {
-        val server = nodeState.value.server?.copy(state = ServerState.ERROR)
-        setNode(nodeState.value.copy(state = NodeState.ERROR, server = server))
+        setNode(nodeState.value.copy(state = NodeState.ERROR))
     }
 
     override suspend fun recover() {
-        val server = nodeState.value.server?.copy(state = ServerState.ACTIVE)
-        setNode(nodeState.value.copy(state = NodeState.ACTIVE, server = server))
+        setNode(nodeState.value.copy(state = NodeState.ACTIVE))
     }
 
     override fun toString(): String = "SimBareMetalDriver(node = ${nodeState.value.uid})"
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtDriver.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtDriver.kt
index 86a671fc..d28b2f0d 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtDriver.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtDriver.kt
@@ -29,6 +29,7 @@ import kotlinx.coroutines.launch
 import org.opendc.compute.core.*
 import org.opendc.compute.core.Flavor
 import org.opendc.compute.core.image.Image
+import org.opendc.compute.core.metal.Node
 import org.opendc.compute.core.virt.HypervisorEvent
 import org.opendc.compute.core.virt.driver.InsufficientMemoryOnServerException
 import org.opendc.compute.core.virt.driver.VirtDriver
@@ -45,17 +46,20 @@ import java.util.*
 /**
  * A [VirtDriver] that is simulates virtual machines on a physical machine using [SimHypervisor].
  */
-public class SimVirtDriver(private val coroutineScope: CoroutineScope, hypervisor: SimHypervisorProvider) : VirtDriver, SimWorkload {
+public class SimVirtDriver(
+    private val coroutineScope: CoroutineScope,
+    hypervisor: SimHypervisorProvider
+) : VirtDriver, SimWorkload {
     /**
      * The execution context in which the [VirtDriver] runs.
      */
-    private lateinit var ctx: ComputeSimExecutionContext
+    private lateinit var ctx: SimExecutionContext
 
     /**
-     * The server hosting this hypervisor.
+     * The node on which the hypervisor runs.
      */
-    public val server: Server
-        get() = ctx.server
+    public val node: Node
+        get() = ctx.meta["node"] as Node
 
     /**
      * The [EventFlow] to emit the events.
@@ -93,7 +97,7 @@ public class SimVirtDriver(private val coroutineScope: CoroutineScope, hyperviso
                         cpuUsage,
                         cpuDemand,
                         vms.size,
-                        ctx.server
+                        node
                     )
                 )
             }
@@ -153,13 +157,13 @@ public class SimVirtDriver(private val coroutineScope: CoroutineScope, hyperviso
     }
 
     private fun vmStarted(vm: VirtualMachine) {
-        vms.forEach { it ->
+        vms.forEach {
             vm.performanceInterferenceModel?.onStart(it.server.image.name)
         }
     }
 
     private fun vmStopped(vm: VirtualMachine) {
-        vms.forEach { it ->
+        vms.forEach {
             vm.performanceInterferenceModel?.onStop(it.server.image.name)
         }
     }
@@ -171,37 +175,12 @@ public class SimVirtDriver(private val coroutineScope: CoroutineScope, hyperviso
         val performanceInterferenceModel: PerformanceInterferenceModel? = server.image.tags[IMAGE_PERF_INTERFERENCE_MODEL] as? PerformanceInterferenceModel?
 
         val job = coroutineScope.launch {
-            val delegate = server.image.tags["workload"] as SimWorkload
-            // Wrap the workload to pass in a ComputeSimExecutionContext
-            val workload = object : SimWorkload {
-                lateinit var wrappedCtx: ComputeSimExecutionContext
-
-                override fun onStart(ctx: SimExecutionContext) {
-                    wrappedCtx = object : ComputeSimExecutionContext, SimExecutionContext by ctx {
-                        override val server: Server
-                            get() = server
-
-                        override fun toString(): String = "WrappedSimExecutionContext"
-                    }
-
-                    delegate.onStart(wrappedCtx)
-                }
-
-                override fun onStart(ctx: SimExecutionContext, cpu: Int): SimResourceCommand {
-                    return delegate.onStart(wrappedCtx, cpu)
-                }
-
-                override fun onNext(ctx: SimExecutionContext, cpu: Int, remainingWork: Double): SimResourceCommand {
-                    return delegate.onNext(wrappedCtx, cpu, remainingWork)
-                }
-
-                override fun toString(): String = "SimWorkloadWrapper(delegate=$delegate)"
-            }
+            val workload = server.image.tags["workload"] as SimWorkload
 
             delay(1) // TODO Introduce boot time
             init()
             try {
-                machine.run(workload)
+                machine.run(workload, mapOf("driver" to this@SimVirtDriver, "server" to server))
                 exit(null)
             } catch (cause: Throwable) {
                 exit(cause)
@@ -239,7 +218,7 @@ public class SimVirtDriver(private val coroutineScope: CoroutineScope, hyperviso
     }
 
     override fun onStart(ctx: SimExecutionContext) {
-        this.ctx = ctx as ComputeSimExecutionContext
+        this.ctx = ctx
         this.availableMemory = ctx.machine.memory.map { it.size }.sum()
         this.hypervisor.onStart(ctx)
     }
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtProvisioningService.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtProvisioningService.kt
index 50ab7788..18afd0c2 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtProvisioningService.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtProvisioningService.kt
@@ -32,6 +32,9 @@ import org.opendc.compute.core.Server
 import org.opendc.compute.core.ServerEvent
 import org.opendc.compute.core.ServerState
 import org.opendc.compute.core.image.Image
+import org.opendc.compute.core.metal.Node
+import org.opendc.compute.core.metal.NodeEvent
+import org.opendc.compute.core.metal.NodeState
 import org.opendc.compute.core.metal.service.ProvisioningService
 import org.opendc.compute.core.virt.HypervisorEvent
 import org.opendc.compute.core.virt.driver.InsufficientMemoryOnServerException
@@ -68,7 +71,7 @@ public class SimVirtProvisioningService(
     /**
      * The hypervisors that have been launched by the service.
      */
-    private val hypervisors: MutableMap<Server, HypervisorView> = mutableMapOf()
+    private val hypervisors: MutableMap<Node, HypervisorView> = mutableMapOf()
 
     /**
      * The available hypervisors.
@@ -118,22 +121,12 @@ public class SimVirtProvisioningService(
                 val workload = SimVirtDriver(coroutineScope, hypervisor)
                 val hypervisorImage = Image(UUID.randomUUID(), "vmm", mapOf("workload" to workload))
                 launch {
-                    var init = false
                     val deployedNode = provisioningService.deploy(node, hypervisorImage)
-                    val server = deployedNode.server!!
-                    server.events.onEach { event ->
+                    deployedNode.events.onEach { event ->
                         when (event) {
-                            is ServerEvent.StateChanged -> {
-                                if (!init) {
-                                    init = true
-                                }
-                                stateChanged(event.server)
-                            }
+                            is NodeEvent.StateChanged -> stateChanged(event.node, workload)
                         }
                     }.launchIn(this)
-
-                    delay(1)
-                    onHypervisorAvailable(server, workload)
                 }
             }
         }
@@ -229,7 +222,7 @@ public class SimVirtProvisioningService(
             }
 
             try {
-                logger.info { "[${clock.millis()}] Spawning ${imageInstance.image} on ${selectedHv.server.uid} ${selectedHv.server.name} ${selectedHv.server.flavor}" }
+                logger.info { "[${clock.millis()}] Spawning ${imageInstance.image} on ${selectedHv.node.uid} ${selectedHv.node.name} ${selectedHv.node.flavor}" }
                 incomingImages.poll()
 
                 // Speculatively update the hypervisor view information to prevent other images in the queue from
@@ -308,28 +301,38 @@ public class SimVirtProvisioningService(
         }
     }
 
-    private fun stateChanged(server: Server) {
-        when (server.state) {
-            ServerState.ACTIVE -> {
-                logger.debug { "[${clock.millis()}] Server ${server.uid} available: ${server.state}" }
+    private fun stateChanged(node: Node, hypervisor: SimVirtDriver) {
+        when (node.state) {
+            NodeState.ACTIVE -> {
+                logger.debug { "[${clock.millis()}] Server ${node.uid} available: ${node.state}" }
 
-                if (server in hypervisors) {
+                if (node in hypervisors) {
                     // Corner case for when the hypervisor already exists
-                    availableHypervisors += hypervisors.getValue(server)
+                    availableHypervisors += hypervisors.getValue(node)
                 } else {
                     val hv = HypervisorView(
-                        server.uid,
-                        server,
+                        node.uid,
+                        node,
                         0,
-                        server.flavor.memorySize,
+                        node.flavor.memorySize,
                         0
                     )
-                    maxCores = max(maxCores, server.flavor.cpuCount)
-                    maxMemory = max(maxMemory, server.flavor.memorySize)
-                    hypervisors[server] = hv
+                    hv.driver = hypervisor
+                    hv.driver.events
+                        .onEach { event ->
+                            if (event is HypervisorEvent.VmsUpdated) {
+                                hv.numberOfActiveServers = event.numberOfActiveServers
+                                hv.availableMemory = event.availableMemory
+                            }
+                        }.launchIn(coroutineScope)
+
+                    maxCores = max(maxCores, node.flavor.cpuCount)
+                    maxMemory = max(maxMemory, node.flavor.memorySize)
+                    hypervisors[node] = hv
+                    availableHypervisors += hv
                 }
 
-                tracer.commit(HypervisorAvailableEvent(server.uid))
+                tracer.commit(HypervisorAvailableEvent(node.uid))
 
                 eventFlow.emit(
                     VirtProvisioningEvent.MetricsAvailable(
@@ -349,9 +352,9 @@ public class SimVirtProvisioningService(
                     requestCycle()
                 }
             }
-            ServerState.SHUTOFF, ServerState.ERROR -> {
-                logger.debug { "[${clock.millis()}] Server ${server.uid} unavailable: ${server.state}" }
-                val hv = hypervisors[server] ?: return
+            NodeState.SHUTOFF, NodeState.ERROR -> {
+                logger.debug { "[${clock.millis()}] Server ${node.uid} unavailable: ${node.state}" }
+                val hv = hypervisors[node] ?: return
                 availableHypervisors -= hv
 
                 tracer.commit(HypervisorUnavailableEvent(hv.uid))
@@ -377,37 +380,6 @@ public class SimVirtProvisioningService(
         }
     }
 
-    private fun onHypervisorAvailable(server: Server, hypervisor: SimVirtDriver) {
-        val hv = hypervisors[server] ?: return
-        hv.driver = hypervisor
-        availableHypervisors += hv
-
-        tracer.commit(HypervisorAvailableEvent(hv.uid))
-
-        eventFlow.emit(
-            VirtProvisioningEvent.MetricsAvailable(
-                this@SimVirtProvisioningService,
-                hypervisors.size,
-                availableHypervisors.size,
-                submittedVms,
-                runningVms,
-                finishedVms,
-                queuedVms,
-                unscheduledVms
-            )
-        )
-
-        hv.driver.events
-            .onEach { event ->
-                if (event is HypervisorEvent.VmsUpdated) {
-                    hv.numberOfActiveServers = event.numberOfActiveServers
-                    hv.availableMemory = event.availableMemory
-                }
-            }.launchIn(coroutineScope)
-
-        requestCycle()
-    }
-
     public data class ImageView(
         public val name: String,
         public val image: Image,
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/AvailableCoreMemoryAllocationPolicy.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/AvailableCoreMemoryAllocationPolicy.kt
index 38a07b2b..5e044282 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/AvailableCoreMemoryAllocationPolicy.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/AvailableCoreMemoryAllocationPolicy.kt
@@ -32,7 +32,7 @@ import org.opendc.compute.simulator.HypervisorView
 public class AvailableCoreMemoryAllocationPolicy(private val reversed: Boolean = false) : AllocationPolicy {
     override fun invoke(): AllocationPolicy.Logic = object : ComparableAllocationPolicyLogic {
         override val comparator: Comparator<HypervisorView> =
-            compareBy<HypervisorView> { -it.availableMemory / it.server.flavor.cpuCount }
+            compareBy<HypervisorView> { -it.availableMemory / it.node.flavor.cpuCount }
                 .run { if (reversed) reversed() else this }
     }
 }
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ComparableAllocationPolicyLogic.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ComparableAllocationPolicyLogic.kt
index 4470eab9..04a181a6 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ComparableAllocationPolicyLogic.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ComparableAllocationPolicyLogic.kt
@@ -41,9 +41,9 @@ public interface ComparableAllocationPolicyLogic : AllocationPolicy.Logic {
         return hypervisors.asSequence()
             .filter { hv ->
                 val fitsMemory = hv.availableMemory >= (image.flavor.memorySize)
-                val fitsCpu = hv.server.flavor.cpuCount >= image.flavor.cpuCount
+                val fitsCpu = hv.node.flavor.cpuCount >= image.flavor.cpuCount
                 fitsMemory && fitsCpu
             }
-            .minWithOrNull(comparator.thenBy { it.server.uid })
+            .minWithOrNull(comparator.thenBy { it.node.uid })
     }
 }
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ProvisionedCoresAllocationPolicy.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ProvisionedCoresAllocationPolicy.kt
index 4344d979..91441ecd 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ProvisionedCoresAllocationPolicy.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ProvisionedCoresAllocationPolicy.kt
@@ -34,7 +34,7 @@ import org.opendc.compute.simulator.HypervisorView
 public class ProvisionedCoresAllocationPolicy(private val reversed: Boolean = false) : AllocationPolicy {
     override fun invoke(): AllocationPolicy.Logic = object : ComparableAllocationPolicyLogic {
         override val comparator: Comparator<HypervisorView> =
-            compareBy<HypervisorView> { it.provisionedCores / it.server.flavor.cpuCount }
+            compareBy<HypervisorView> { it.provisionedCores / it.node.flavor.cpuCount }
                 .run { if (reversed) reversed() else this }
     }
 }
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/RandomAllocationPolicy.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/RandomAllocationPolicy.kt
index ac34f410..9a89fccd 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/RandomAllocationPolicy.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/RandomAllocationPolicy.kt
@@ -39,7 +39,7 @@ public class RandomAllocationPolicy(private val random: Random = Random(0)) : Al
             return hypervisors.asIterable()
                 .filter { hv ->
                     val fitsMemory = hv.availableMemory >= (image.image.tags["required-memory"] as Long)
-                    val fitsCpu = hv.server.flavor.cpuCount >= image.flavor.cpuCount
+                    val fitsCpu = hv.node.flavor.cpuCount >= image.flavor.cpuCount
                     fitsMemory && fitsCpu
                 }
                 .randomOrNull(random)
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ReplayAllocationPolicy.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ReplayAllocationPolicy.kt
index 5312f4da..582fe817 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ReplayAllocationPolicy.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/allocation/ReplayAllocationPolicy.kt
@@ -42,7 +42,7 @@ public class ReplayAllocationPolicy(private val vmPlacements: Map<String, String
         ): HypervisorView? {
             val clusterName = vmPlacements[image.name]
                 ?: throw IllegalStateException("Could not find placement data in VM placement file for VM ${image.name}")
-            val machinesInCluster = hypervisors.filter { it.server.name.contains(clusterName) }
+            val machinesInCluster = hypervisors.filter { it.node.name.contains(clusterName) }
 
             if (machinesInCluster.isEmpty()) {
                 logger.info { "Could not find any machines belonging to cluster $clusterName for image ${image.name}, assigning randomly." }
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 03981feb..3ca9a0a3 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,9 +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.core.image.Image
+import org.opendc.compute.core.metal.NodeEvent
+import org.opendc.compute.core.metal.NodeState
 import org.opendc.simulator.compute.SimMachineModel
 import org.opendc.simulator.compute.model.MemoryUnit
 import org.opendc.simulator.compute.model.ProcessingNode
@@ -60,7 +61,7 @@ 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 {
@@ -70,11 +71,11 @@ internal class SimBareMetalDriverTest {
             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/SimProvisioningServiceTest.kt b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimProvisioningServiceTest.kt
index dad31298..eb46c335 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
@@ -73,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()