merge: Standardize simulator metrics

This pull request standardizes the metrics emitted by the simulator based on OpenTelemetry conventions. 
From now on, all metrics exposed by the simulator are exported through OpenTelemetry 
following the recommended practices for naming, collection, etc.

**Implementation Notes**

- Improve ParquetDataWriter implementation 
- Simplify CoroutineMetricReader
- Create separate MeterProvider per service/host
- Standardize compute scheduler metrics 
- Standardize SimHost metrics 
- Use logical types for Parquet output columns 

**External Dependencies**

- Update to OpenTelemetry 1.6.0

**Breaking API Changes**

- Instead of supplying a `Meter` instances, key classes are now responsible for constructing 
   a `Meter` instance from the supplied `MeterProvider`.
- Export format has been changed to suit the outputted metrics
- Energy experiments shell has been removed

5 files changed, 149 insertions, 122 deletions

diff --git a/opendc-compute/opendc-compute-service/src/main/kotlin/org/opendc/compute/service/ComputeService.kt b/opendc-compute/opendc-compute-service/src/main/kotlin/org/opendc/compute/service/ComputeService.kt
index 1873eb99..2a1fbaa0 100644
--- a/opendc-compute/opendc-compute-service/src/main/kotlin/org/opendc/compute/service/ComputeService.kt
+++ b/opendc-compute/opendc-compute-service/src/main/kotlin/org/opendc/compute/service/ComputeService.kt
@@ -23,11 +23,13 @@
 package org.opendc.compute.service
 
 import io.opentelemetry.api.metrics.Meter
+import io.opentelemetry.api.metrics.MeterProvider
 import org.opendc.compute.api.ComputeClient
 import org.opendc.compute.service.driver.Host
 import org.opendc.compute.service.internal.ComputeServiceImpl
 import org.opendc.compute.service.scheduler.ComputeScheduler
 import java.time.Clock
+import java.time.Duration
 import kotlin.coroutines.CoroutineContext
 
 /**
@@ -70,16 +72,18 @@ public interface ComputeService : AutoCloseable {
          *
          * @param context The [CoroutineContext] to use in the service.
          * @param clock The clock instance to use.
+         * @param meterProvider The [MeterProvider] for creating a [Meter] for the service.
          * @param scheduler The scheduler implementation to use.
+         * @param schedulingQuantum The interval between scheduling cycles.
          */
         public operator fun invoke(
             context: CoroutineContext,
             clock: Clock,
-            meter: Meter,
+            meterProvider: MeterProvider,
             scheduler: ComputeScheduler,
-            schedulingQuantum: Long = 300000,
+            schedulingQuantum: Duration = Duration.ofMinutes(5),
         ): ComputeService {
-            return ComputeServiceImpl(context, clock, meter, scheduler, schedulingQuantum)
+            return ComputeServiceImpl(context, clock, meterProvider, scheduler, schedulingQuantum)
         }
     }
 }
diff --git a/opendc-compute/opendc-compute-service/src/main/kotlin/org/opendc/compute/service/internal/ComputeServiceImpl.kt b/opendc-compute/opendc-compute-service/src/main/kotlin/org/opendc/compute/service/internal/ComputeServiceImpl.kt
index f1c055d4..57e70fcd 100644
--- a/opendc-compute/opendc-compute-service/src/main/kotlin/org/opendc/compute/service/internal/ComputeServiceImpl.kt
+++ b/opendc-compute/opendc-compute-service/src/main/kotlin/org/opendc/compute/service/internal/ComputeServiceImpl.kt
@@ -22,9 +22,10 @@
 
 package org.opendc.compute.service.internal
 
+import io.opentelemetry.api.common.AttributeKey
 import io.opentelemetry.api.common.Attributes
 import io.opentelemetry.api.metrics.Meter
-import io.opentelemetry.semconv.resource.attributes.ResourceAttributes
+import io.opentelemetry.api.metrics.MeterProvider
 import kotlinx.coroutines.*
 import mu.KotlinLogging
 import org.opendc.compute.api.*
@@ -35,6 +36,7 @@ import org.opendc.compute.service.driver.HostState
 import org.opendc.compute.service.scheduler.ComputeScheduler
 import org.opendc.utils.TimerScheduler
 import java.time.Clock
+import java.time.Duration
 import java.util.*
 import kotlin.coroutines.CoroutineContext
 import kotlin.math.max
@@ -42,15 +44,18 @@ import kotlin.math.max
 /**
  * Internal implementation of the OpenDC Compute service.
  *
- * @param context The [CoroutineContext] to use.
- * @param clock The clock instance to keep track of time.
+ * @param context The [CoroutineContext] to use in the service.
+ * @param clock The clock instance to use.
+ * @param meterProvider The [MeterProvider] for creating a [Meter] for the service.
+ * @param scheduler The scheduler implementation to use.
+ * @param schedulingQuantum The interval between scheduling cycles.
  */
 internal class ComputeServiceImpl(
     private val context: CoroutineContext,
     private val clock: Clock,
-    private val meter: Meter,
+    meterProvider: MeterProvider,
     private val scheduler: ComputeScheduler,
-    private val schedulingQuantum: Long
+    private val schedulingQuantum: Duration
 ) : ComputeService, HostListener {
     /**
      * The [CoroutineScope] of the service bounded by the lifecycle of the service.
@@ -63,6 +68,11 @@ internal class ComputeServiceImpl(
     private val logger = KotlinLogging.logger {}
 
     /**
+     * The [Meter] to track metrics of the [ComputeService].
+     */
+    private val meter = meterProvider.get("org.opendc.compute.service")
+
+    /**
      * The [Random] instance used to generate unique identifiers for the objects.
      */
     private val random = Random(0)
@@ -106,69 +116,37 @@ internal class ComputeServiceImpl(
     private var maxMemory = 0L
 
     /**
-     * The number of servers that have been submitted to the service for provisioning.
-     */
-    private val _submittedServers = meter.counterBuilder("servers.submitted")
-        .setDescription("Number of start requests")
-        .setUnit("1")
-        .build()
-
-    /**
-     * The number of servers that failed to be scheduled.
-     */
-    private val _unscheduledServers = meter.counterBuilder("servers.unscheduled")
-        .setDescription("Number of unscheduled servers")
-        .setUnit("1")
-        .build()
-
-    /**
-     * The number of servers that are waiting to be provisioned.
-     */
-    private val _waitingServers = meter.upDownCounterBuilder("servers.waiting")
-        .setDescription("Number of servers waiting to be provisioned")
-        .setUnit("1")
-        .build()
-
-    /**
-     * The number of servers that are waiting to be provisioned.
-     */
-    private val _runningServers = meter.upDownCounterBuilder("servers.active")
-        .setDescription("Number of servers currently running")
-        .setUnit("1")
-        .build()
-
-    /**
-     * The number of servers that have finished running.
+     * The number of scheduling attempts.
      */
-    private val _finishedServers = meter.counterBuilder("servers.finished")
-        .setDescription("Number of servers that finished running")
+    private val _schedulingAttempts = meter.counterBuilder("scheduler.attempts")
+        .setDescription("Number of scheduling attempts")
         .setUnit("1")
         .build()
+    private val _schedulingAttemptsSuccess = _schedulingAttempts
+        .bind(Attributes.of(AttributeKey.stringKey("result"), "success"))
+    private val _schedulingAttemptsFailure = _schedulingAttempts
+        .bind(Attributes.of(AttributeKey.stringKey("result"), "failure"))
+    private val _schedulingAttemptsError = _schedulingAttempts
+        .bind(Attributes.of(AttributeKey.stringKey("result"), "error"))
 
     /**
-     * The number of hosts registered at the compute service.
+     * The response time of the service.
      */
-    private val _hostCount = meter.upDownCounterBuilder("hosts.total")
-        .setDescription("Number of hosts")
-        .setUnit("1")
+    private val _schedulingLatency = meter.histogramBuilder("scheduler.latency")
+        .setDescription("End to end latency for a server to be scheduled (in multiple attempts)")
+        .ofLongs()
+        .setUnit("ms")
         .build()
 
     /**
-     * The number of available hosts registered at the compute service.
+     * The number of servers that are pending.
      */
-    private val _availableHostCount = meter.upDownCounterBuilder("hosts.available")
-        .setDescription("Number of available hosts")
+    private val _servers = meter.upDownCounterBuilder("scheduler.servers")
+        .setDescription("Number of servers managed by the scheduler")
         .setUnit("1")
         .build()
-
-    /**
-     * The response time of the service.
-     */
-    private val _schedulerDuration = meter.histogramBuilder("scheduler.duration")
-        .setDescription("End to end latency for a server to be scheduled (in multiple attempts)")
-        .ofLongs()
-        .setUnit("ms")
-        .build()
+    private val _serversPending = _servers.bind(Attributes.of(AttributeKey.stringKey("state"), "pending"))
+    private val _serversActive = _servers.bind(Attributes.of(AttributeKey.stringKey("state"), "active"))
 
     /**
      * The [TimerScheduler] to use for scheduling the scheduler cycles.
@@ -181,6 +159,22 @@ internal class ComputeServiceImpl(
     override val hostCount: Int
         get() = hostToView.size
 
+    init {
+        val upState = Attributes.of(AttributeKey.stringKey("state"), "up")
+        val downState = Attributes.of(AttributeKey.stringKey("state"), "down")
+
+        meter.upDownCounterBuilder("scheduler.hosts")
+            .setDescription("Number of hosts registered with the scheduler")
+            .setUnit("1")
+            .buildWithCallback { result ->
+                val total = hostCount
+                val available = availableHosts.size.toLong()
+
+                result.observe(available, upState)
+                result.observe(total - available, downState)
+            }
+    }
+
     override fun newClient(): ComputeClient {
         check(scope.isActive) { "Service is already closed" }
         return object : ComputeClient {
@@ -308,24 +302,19 @@ internal class ComputeServiceImpl(
         hostToView[host] = hv
 
         if (host.state == HostState.UP) {
-            _availableHostCount.add(1)
             availableHosts += hv
         }
 
         scheduler.addHost(hv)
-        _hostCount.add(1)
         host.addListener(this)
     }
 
     override fun removeHost(host: Host) {
         val view = hostToView.remove(host)
         if (view != null) {
-            if (availableHosts.remove(view)) {
-                _availableHostCount.add(-1)
-            }
+            availableHosts.remove(view)
             scheduler.removeHost(view)
             host.removeListener(this)
-            _hostCount.add(-1)
         }
     }
 
@@ -338,8 +327,7 @@ internal class ComputeServiceImpl(
 
         val request = SchedulingRequest(server, clock.millis())
         queue.add(request)
-        _submittedServers.add(1)
-        _waitingServers.add(1)
+        _serversPending.add(1)
         requestSchedulingCycle()
         return request
     }
@@ -365,10 +353,12 @@ internal class ComputeServiceImpl(
             return
         }
 
+        val quantum = schedulingQuantum.toMillis()
+
         // We assume that the provisioner runs at a fixed slot every time quantum (e.g t=0, t=60, t=120).
         // This is important because the slices of the VMs need to be aligned.
         // We calculate here the delay until the next scheduling slot.
-        val delay = schedulingQuantum - (clock.millis() % schedulingQuantum)
+        val delay = quantum - (clock.millis() % quantum)
 
         timerScheduler.startSingleTimer(Unit, delay) {
             doSchedule()
@@ -385,7 +375,7 @@ internal class ComputeServiceImpl(
 
             if (request.isCancelled) {
                 queue.poll()
-                _waitingServers.add(-1)
+                _serversPending.add(-1)
                 continue
             }
 
@@ -397,10 +387,10 @@ internal class ComputeServiceImpl(
                 if (server.flavor.memorySize > maxMemory || server.flavor.cpuCount > maxCores) {
                     // Remove the incoming image
                     queue.poll()
-                    _waitingServers.add(-1)
-                    _unscheduledServers.add(1)
+                    _serversPending.add(-1)
+                    _schedulingAttemptsFailure.add(1)
 
-                    logger.warn("Failed to spawn $server: does not fit [${clock.millis()}]")
+                    logger.warn { "Failed to spawn $server: does not fit [${clock.instant()}]" }
 
                     server.state = ServerState.TERMINATED
                     continue
@@ -413,8 +403,8 @@ internal class ComputeServiceImpl(
 
             // Remove request from queue
             queue.poll()
-            _waitingServers.add(-1)
-            _schedulerDuration.record(now - request.submitTime, Attributes.of(ResourceAttributes.HOST_ID, server.uid.toString()))
+            _serversPending.add(-1)
+            _schedulingLatency.record(now - request.submitTime, server.attributes)
 
             logger.info { "Assigned server $server to host $host." }
 
@@ -429,12 +419,17 @@ internal class ComputeServiceImpl(
                     server.host = host
                     host.spawn(server)
                     activeServers[server] = host
+
+                    _serversActive.add(1)
+                    _schedulingAttemptsSuccess.add(1)
                 } catch (e: Throwable) {
-                    logger.error("Failed to deploy VM", e)
+                    logger.error(e) { "Failed to deploy VM" }
 
                     hv.instanceCount--
                     hv.provisionedCores -= server.flavor.cpuCount
                     hv.availableMemory += server.flavor.memorySize
+
+                    _schedulingAttemptsError.add(1)
                 }
             }
         }
@@ -453,24 +448,22 @@ internal class ComputeServiceImpl(
     override fun onStateChanged(host: Host, newState: HostState) {
         when (newState) {
             HostState.UP -> {
-                logger.debug { "[${clock.millis()}] Host ${host.uid} state changed: $newState" }
+                logger.debug { "[${clock.instant()}] Host ${host.uid} state changed: $newState" }
 
                 val hv = hostToView[host]
                 if (hv != null) {
                     // Corner case for when the hypervisor already exists
                     availableHosts += hv
-                    _availableHostCount.add(1)
                 }
 
                 // Re-schedule on the new machine
                 requestSchedulingCycle()
             }
             HostState.DOWN -> {
-                logger.debug { "[${clock.millis()}] Host ${host.uid} state changed: $newState" }
+                logger.debug { "[${clock.instant()}] Host ${host.uid} state changed: $newState" }
 
                 val hv = hostToView[host] ?: return
                 availableHosts -= hv
-                _availableHostCount.add(-1)
 
                 requestSchedulingCycle()
             }
@@ -488,16 +481,12 @@ internal class ComputeServiceImpl(
 
         server.state = newState
 
-        if (newState == ServerState.RUNNING) {
-            _runningServers.add(1)
-        } else if (newState == ServerState.ERROR) {
-            _runningServers.add(-1)
-        } else if (newState == ServerState.TERMINATED || newState == ServerState.DELETED) {
-            logger.info { "[${clock.millis()}] Server ${server.uid} ${server.name} ${server.flavor} finished." }
+        if (newState == ServerState.TERMINATED || newState == ServerState.DELETED) {
+            logger.info { "[${clock.instant()}] Server ${server.uid} ${server.name} ${server.flavor} finished." }
 
-            activeServers -= server
-            _runningServers.add(-1)
-            _finishedServers.add(1)
+            if (activeServers.remove(server) != null) {
+                _serversActive.add(-1)
+            }
 
             val hv = hostToView[host]
             if (hv != null) {
diff --git a/opendc-compute/opendc-compute-service/src/main/kotlin/org/opendc/compute/service/internal/InternalServer.kt b/opendc-compute/opendc-compute-service/src/main/kotlin/org/opendc/compute/service/internal/InternalServer.kt
index d9d0f3fc..05a7e1bf 100644
--- a/opendc-compute/opendc-compute-service/src/main/kotlin/org/opendc/compute/service/internal/InternalServer.kt
+++ b/opendc-compute/opendc-compute-service/src/main/kotlin/org/opendc/compute/service/internal/InternalServer.kt
@@ -22,6 +22,9 @@
 
 package org.opendc.compute.service.internal
 
+import io.opentelemetry.api.common.AttributeKey
+import io.opentelemetry.api.common.Attributes
+import io.opentelemetry.semconv.resource.attributes.ResourceAttributes
 import mu.KotlinLogging
 import org.opendc.compute.api.*
 import org.opendc.compute.service.driver.Host
@@ -50,6 +53,21 @@ internal class InternalServer(
     private val watchers = mutableListOf<ServerWatcher>()
 
     /**
+     * The attributes of a server.
+     */
+    internal val attributes: Attributes = Attributes.builder()
+        .put(ResourceAttributes.HOST_NAME, name)
+        .put(ResourceAttributes.HOST_ID, uid.toString())
+        .put(ResourceAttributes.HOST_TYPE, flavor.name)
+        .put(AttributeKey.longKey("host.num_cpus"), flavor.cpuCount.toLong())
+        .put(AttributeKey.longKey("host.mem_capacity"), flavor.memorySize)
+        .put(AttributeKey.stringArrayKey("host.labels"), labels.map { (k, v) -> "$k:$v" })
+        .put(ResourceAttributes.HOST_ARCH, ResourceAttributes.HostArchValues.AMD64)
+        .put(ResourceAttributes.HOST_IMAGE_NAME, image.name)
+        .put(ResourceAttributes.HOST_IMAGE_ID, image.uid.toString())
+        .build()
+
+    /**
      * The [Host] that has been assigned to host the server.
      */
     internal var host: Host? = null
diff --git a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ComputeServiceTest.kt b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ComputeServiceTest.kt
index d036ec00..564f9493 100644
--- a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ComputeServiceTest.kt
+++ b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ComputeServiceTest.kt
@@ -61,8 +61,7 @@ internal class ComputeServiceTest {
             filters = listOf(ComputeFilter(), VCpuFilter(allocationRatio = 1.0), RamFilter(allocationRatio = 1.0)),
             weighers = listOf(RamWeigher())
         )
-        val meter = MeterProvider.noop().get("opendc-compute")
-        service = ComputeService(scope.coroutineContext, clock, meter, computeScheduler)
+        service = ComputeService(scope.coroutineContext, clock, MeterProvider.noop(), computeScheduler)
     }
 
     @Test
diff --git a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/InternalServerTest.kt b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/InternalServerTest.kt
index 28fd8217..dfd3bc67 100644
--- a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/InternalServerTest.kt
+++ b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/InternalServerTest.kt
@@ -47,8 +47,9 @@ class InternalServerTest {
     fun testEquality() {
         val service = mockk<ComputeServiceImpl>()
         val uid = UUID.randomUUID()
-        val flavor = mockk<InternalFlavor>()
-        val image = mockk<InternalImage>()
+        val flavor = mockFlavor()
+        val image = mockImage()
+
         val a = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
         val b = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
 
@@ -59,8 +60,8 @@ class InternalServerTest {
     fun testEqualityWithDifferentType() {
         val service = mockk<ComputeServiceImpl>()
         val uid = UUID.randomUUID()
-        val flavor = mockk<InternalFlavor>()
-        val image = mockk<InternalImage>()
+        val flavor = mockFlavor()
+        val image = mockImage()
         val a = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
 
         val b = mockk<Server>(relaxUnitFun = true)
@@ -73,8 +74,8 @@ class InternalServerTest {
     fun testInequalityWithDifferentType() {
         val service = mockk<ComputeServiceImpl>()
         val uid = UUID.randomUUID()
-        val flavor = mockk<InternalFlavor>()
-        val image = mockk<InternalImage>()
+        val flavor = mockFlavor()
+        val image = mockImage()
         val a = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
 
         val b = mockk<Server>(relaxUnitFun = true)
@@ -87,8 +88,8 @@ class InternalServerTest {
     fun testInequalityWithIncorrectType() {
         val service = mockk<ComputeServiceImpl>()
         val uid = UUID.randomUUID()
-        val flavor = mockk<InternalFlavor>()
-        val image = mockk<InternalImage>()
+        val flavor = mockFlavor()
+        val image = mockImage()
         val a = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
 
         assertNotEquals(a, Unit)
@@ -98,8 +99,8 @@ class InternalServerTest {
     fun testStartTerminatedServer() = runBlockingSimulation {
         val service = mockk<ComputeServiceImpl>()
         val uid = UUID.randomUUID()
-        val flavor = mockk<InternalFlavor>()
-        val image = mockk<InternalImage>()
+        val flavor = mockFlavor()
+        val image = mockImage()
         val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
 
         every { service.schedule(any()) } answers { ComputeServiceImpl.SchedulingRequest(it.invocation.args[0] as InternalServer, 0) }
@@ -114,8 +115,8 @@ class InternalServerTest {
     fun testStartDeletedServer() = runBlockingSimulation {
         val service = mockk<ComputeServiceImpl>()
         val uid = UUID.randomUUID()
-        val flavor = mockk<InternalFlavor>()
-        val image = mockk<InternalImage>()
+        val flavor = mockFlavor()
+        val image = mockImage()
         val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
 
         server.state = ServerState.DELETED
@@ -127,8 +128,8 @@ class InternalServerTest {
     fun testStartProvisioningServer() = runBlockingSimulation {
         val service = mockk<ComputeServiceImpl>()
         val uid = UUID.randomUUID()
-        val flavor = mockk<InternalFlavor>()
-        val image = mockk<InternalImage>()
+        val flavor = mockFlavor()
+        val image = mockImage()
         val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
 
         server.state = ServerState.PROVISIONING
@@ -142,8 +143,8 @@ class InternalServerTest {
     fun testStartRunningServer() = runBlockingSimulation {
         val service = mockk<ComputeServiceImpl>()
         val uid = UUID.randomUUID()
-        val flavor = mockk<InternalFlavor>()
-        val image = mockk<InternalImage>()
+        val flavor = mockFlavor()
+        val image = mockImage()
         val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
 
         server.state = ServerState.RUNNING
@@ -157,8 +158,8 @@ class InternalServerTest {
     fun testStopProvisioningServer() = runBlockingSimulation {
         val service = mockk<ComputeServiceImpl>()
         val uid = UUID.randomUUID()
-        val flavor = mockk<InternalFlavor>()
-        val image = mockk<InternalImage>()
+        val flavor = mockFlavor()
+        val image = mockImage()
         val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
         val request = ComputeServiceImpl.SchedulingRequest(server, 0)
 
@@ -175,8 +176,8 @@ class InternalServerTest {
     fun testStopTerminatedServer() = runBlockingSimulation {
         val service = mockk<ComputeServiceImpl>()
         val uid = UUID.randomUUID()
-        val flavor = mockk<InternalFlavor>()
-        val image = mockk<InternalImage>()
+        val flavor = mockFlavor()
+        val image = mockImage()
         val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
 
         server.state = ServerState.TERMINATED
@@ -189,8 +190,8 @@ class InternalServerTest {
     fun testStopDeletedServer() = runBlockingSimulation {
         val service = mockk<ComputeServiceImpl>()
         val uid = UUID.randomUUID()
-        val flavor = mockk<InternalFlavor>()
-        val image = mockk<InternalImage>()
+        val flavor = mockFlavor()
+        val image = mockImage()
         val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
 
         server.state = ServerState.DELETED
@@ -203,8 +204,8 @@ class InternalServerTest {
     fun testStopRunningServer() = runBlockingSimulation {
         val service = mockk<ComputeServiceImpl>()
         val uid = UUID.randomUUID()
-        val flavor = mockk<InternalFlavor>()
-        val image = mockk<InternalImage>()
+        val flavor = mockFlavor()
+        val image = mockImage()
         val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
         val host = mockk<Host>(relaxUnitFun = true)
 
@@ -220,8 +221,8 @@ class InternalServerTest {
     fun testDeleteProvisioningServer() = runBlockingSimulation {
         val service = mockk<ComputeServiceImpl>(relaxUnitFun = true)
         val uid = UUID.randomUUID()
-        val flavor = mockk<InternalFlavor>()
-        val image = mockk<InternalImage>()
+        val flavor = mockFlavor()
+        val image = mockImage()
         val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
         val request = ComputeServiceImpl.SchedulingRequest(server, 0)
 
@@ -239,8 +240,8 @@ class InternalServerTest {
     fun testDeleteTerminatedServer() = runBlockingSimulation {
         val service = mockk<ComputeServiceImpl>(relaxUnitFun = true)
         val uid = UUID.randomUUID()
-        val flavor = mockk<InternalFlavor>()
-        val image = mockk<InternalImage>()
+        val flavor = mockFlavor()
+        val image = mockImage()
         val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
 
         server.state = ServerState.TERMINATED
@@ -255,8 +256,8 @@ class InternalServerTest {
     fun testDeleteDeletedServer() = runBlockingSimulation {
         val service = mockk<ComputeServiceImpl>(relaxUnitFun = true)
         val uid = UUID.randomUUID()
-        val flavor = mockk<InternalFlavor>()
-        val image = mockk<InternalImage>()
+        val flavor = mockFlavor()
+        val image = mockImage()
         val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
 
         server.state = ServerState.DELETED
@@ -269,8 +270,8 @@ class InternalServerTest {
     fun testDeleteRunningServer() = runBlockingSimulation {
         val service = mockk<ComputeServiceImpl>(relaxUnitFun = true)
         val uid = UUID.randomUUID()
-        val flavor = mockk<InternalFlavor>()
-        val image = mockk<InternalImage>()
+        val flavor = mockFlavor()
+        val image = mockImage()
         val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
         val host = mockk<Host>(relaxUnitFun = true)
 
@@ -282,4 +283,20 @@ class InternalServerTest {
         coVerify { host.delete(server) }
         verify { service.delete(server) }
     }
+
+    private fun mockFlavor(): InternalFlavor {
+        val flavor = mockk<InternalFlavor>()
+        every { flavor.name } returns "c5.large"
+        every { flavor.uid } returns UUID.randomUUID()
+        every { flavor.cpuCount } returns 2
+        every { flavor.memorySize } returns 4096
+        return flavor
+    }
+
+    private fun mockImage(): InternalImage {
+        val image = mockk<InternalImage>()
+        every { image.name } returns "ubuntu-20.04"
+        every { image.uid } returns UUID.randomUUID()
+        return image
+    }
 }