merge: Clean up compute service (v1)

This pull request is one in a series of changes that attempt to clean up the 
warts of the OpenDC Compute Service. These changes should make the
API more robust for future developments.

## Implementation Notes :hammer_and_pick:

* Do not suspend in compute API
* Expose state directly to clients
* Do not split interface and implementation

## External Dependencies :four_leaf_clover:

* N/A

## Breaking API Changes :warning:

* The methods of `ComputeClient` do not have the suspend modifier anymore.
* Changes to the classes of `ComputeClient` are now immediately visible on the server side.
   It is not necessary to call `refresh` anymore.
* `ComputeService` must be constructed via its builder class now.

5 files changed, 82 insertions, 152 deletions

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 b5685aba..4dc1cfa8 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
@@ -50,6 +50,7 @@ import org.opendc.compute.service.scheduler.filters.VCpuFilter
 import org.opendc.compute.service.scheduler.weights.RamWeigher
 import org.opendc.simulator.kotlin.SimulationCoroutineScope
 import org.opendc.simulator.kotlin.runSimulation
+import java.time.Duration
 import java.util.UUID
 
 /**
@@ -66,7 +67,7 @@ internal class ComputeServiceTest {
             filters = listOf(ComputeFilter(), VCpuFilter(allocationRatio = 1.0), RamFilter(allocationRatio = 1.0)),
             weighers = listOf(RamWeigher())
         )
-        service = ComputeService(scope.dispatcher, computeScheduler)
+        service = ComputeService(scope.dispatcher, computeScheduler, Duration.ofMinutes(5))
     }
 
     @Test
@@ -170,7 +171,7 @@ internal class ComputeServiceTest {
 
         server.start()
         delay(5L * 60 * 1000)
-        server.refresh()
+        server.reload()
         assertEquals(ServerState.TERMINATED, server.state)
     }
 
@@ -183,7 +184,7 @@ internal class ComputeServiceTest {
 
         server.start()
         delay(5L * 60 * 1000)
-        server.refresh()
+        server.reload()
         assertEquals(ServerState.TERMINATED, server.state)
     }
 
@@ -196,7 +197,7 @@ internal class ComputeServiceTest {
 
         server.start()
         delay(5L * 60 * 1000)
-        server.refresh()
+        server.reload()
         assertEquals(ServerState.TERMINATED, server.state)
     }
 
@@ -210,7 +211,7 @@ internal class ComputeServiceTest {
         server.start()
         server.stop()
         delay(5L * 60 * 1000)
-        server.refresh()
+        server.reload()
         assertEquals(ServerState.TERMINATED, server.state)
     }
 
@@ -231,7 +232,7 @@ internal class ComputeServiceTest {
 
         server.start()
         delay(10L * 60 * 1000)
-        server.refresh()
+        server.reload()
         assertEquals(ServerState.PROVISIONING, server.state)
 
         verify { host.canFit(server) }
@@ -262,7 +263,7 @@ internal class ComputeServiceTest {
         listeners.forEach { it.onStateChanged(host, HostState.UP) }
 
         delay(5L * 60 * 1000)
-        server.refresh()
+        server.reload()
         assertEquals(ServerState.PROVISIONING, server.state)
 
         verify { host.canFit(server) }
@@ -293,36 +294,13 @@ internal class ComputeServiceTest {
 
         server.start()
         delay(5L * 60 * 1000)
-        server.refresh()
+        server.reload()
         assertEquals(ServerState.PROVISIONING, server.state)
 
         verify(exactly = 0) { host.canFit(server) }
     }
 
     @Test
-    fun testServerInvalidType() = scope.runSimulation {
-        val host = mockk<Host>(relaxUnitFun = true)
-        val listeners = mutableListOf<HostListener>()
-
-        every { host.uid } returns UUID.randomUUID()
-        every { host.model } returns HostModel(4 * 2600.0, 4, 2048)
-        every { host.state } returns HostState.UP
-        every { host.canFit(any()) } returns true
-        every { host.addListener(any()) } answers { listeners.add(it.invocation.args[0] as HostListener) }
-
-        service.addHost(host)
-
-        val client = service.newClient()
-        val flavor = client.newFlavor("test", 1, 1024)
-        val image = client.newImage("test")
-        val server = client.newServer("test", image, flavor, start = false)
-
-        assertThrows<IllegalArgumentException> {
-            listeners.forEach { it.onStateChanged(host, server, ServerState.RUNNING) }
-        }
-    }
-
-    @Test
     fun testServerDeploy() = scope.runSimulation {
         val host = mockk<Host>(relaxUnitFun = true)
         val listeners = mutableListOf<HostListener>()
@@ -351,7 +329,7 @@ internal class ComputeServiceTest {
 
         listeners.forEach { it.onStateChanged(host, slot.captured, ServerState.RUNNING) }
 
-        server.refresh()
+        server.reload()
         assertEquals(ServerState.RUNNING, server.state)
 
         verify { watcher.onStateChanged(server, ServerState.RUNNING) }
@@ -359,7 +337,7 @@ internal class ComputeServiceTest {
         // Stop server
         listeners.forEach { it.onStateChanged(host, slot.captured, ServerState.TERMINATED) }
 
-        server.refresh()
+        server.reload()
         assertEquals(ServerState.TERMINATED, server.state)
 
         verify { watcher.onStateChanged(server, ServerState.TERMINATED) }
@@ -387,7 +365,7 @@ internal class ComputeServiceTest {
         server.start()
         delay(5L * 60 * 1000)
 
-        server.refresh()
+        server.reload()
         assertEquals(ServerState.PROVISIONING, server.state)
     }
 }
diff --git a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/InternalFlavorTest.kt b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceFlavorTest.kt
index fe92f7f2..7938f789 100644
--- a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/InternalFlavorTest.kt
+++ b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceFlavorTest.kt
@@ -28,41 +28,27 @@ import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertNotEquals
 import org.junit.jupiter.api.Test
 import org.opendc.compute.api.Flavor
-import org.opendc.compute.service.internal.ComputeServiceImpl
-import org.opendc.compute.service.internal.InternalFlavor
 import java.util.UUID
 
 /**
- * Test suite for the [InternalFlavor] implementation.
+ * Test suite for the [ServiceFlavor] implementation.
  */
-class InternalFlavorTest {
+class ServiceFlavorTest {
     @Test
     fun testEquality() {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
-        val a = InternalFlavor(service, uid, "test", 1, 1024, mutableMapOf(), mutableMapOf())
-        val b = InternalFlavor(service, uid, "test", 1, 1024, mutableMapOf(), mutableMapOf())
-
-        assertEquals(a, b)
-    }
-
-    @Test
-    fun testEqualityWithDifferentType() {
-        val service = mockk<ComputeServiceImpl>()
-        val uid = UUID.randomUUID()
-        val a = InternalFlavor(service, uid, "test", 1, 1024, mutableMapOf(), mutableMapOf())
-
-        val b = mockk<Flavor>(relaxUnitFun = true)
-        every { b.uid } returns uid
+        val a = ServiceFlavor(service, uid, "test", 1, 1024, mutableMapOf(), mutableMapOf<String, Any>())
+        val b = ServiceFlavor(service, uid, "test", 1, 1024, mutableMapOf(), mutableMapOf<String, Any>())
 
         assertEquals(a, b)
     }
 
     @Test
     fun testInequalityWithDifferentType() {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
-        val a = InternalFlavor(service, uid, "test", 1, 1024, mutableMapOf(), mutableMapOf())
+        val a = ServiceFlavor(service, uid, "test", 1, 1024, mutableMapOf(), mutableMapOf<String, Any>())
 
         val b = mockk<Flavor>(relaxUnitFun = true)
         every { b.uid } returns UUID.randomUUID()
@@ -72,9 +58,9 @@ class InternalFlavorTest {
 
     @Test
     fun testInequalityWithIncorrectType() {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
-        val a = InternalFlavor(service, uid, "test", 1, 1024, mutableMapOf(), mutableMapOf())
+        val a = ServiceFlavor(service, uid, "test", 1, 1024, mutableMapOf(), mutableMapOf<String, Any>())
 
         assertNotEquals(a, Unit)
     }
diff --git a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/InternalImageTest.kt b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceImageTest.kt
index d60aa628..c36d75f4 100644
--- a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/InternalImageTest.kt
+++ b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceImageTest.kt
@@ -28,42 +28,27 @@ import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Assertions.assertNotEquals
 import org.junit.jupiter.api.Test
 import org.opendc.compute.api.Image
-import org.opendc.compute.service.internal.ComputeServiceImpl
-import org.opendc.compute.service.internal.InternalFlavor
-import org.opendc.compute.service.internal.InternalImage
 import java.util.UUID
 
 /**
- * Test suite for the [InternalFlavor] implementation.
+ * Test suite for the [ServiceFlavor] implementation.
  */
-class InternalImageTest {
+class ServiceImageTest {
     @Test
     fun testEquality() {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
-        val a = InternalImage(service, uid, "test", mutableMapOf(), mutableMapOf())
-        val b = InternalImage(service, uid, "test", mutableMapOf(), mutableMapOf())
-
-        assertEquals(a, b)
-    }
-
-    @Test
-    fun testEqualityWithDifferentType() {
-        val service = mockk<ComputeServiceImpl>()
-        val uid = UUID.randomUUID()
-        val a = InternalImage(service, uid, "test", mutableMapOf(), mutableMapOf())
-
-        val b = mockk<Image>(relaxUnitFun = true)
-        every { b.uid } returns uid
+        val a = ServiceImage(service, uid, "test", mutableMapOf(), mutableMapOf<String, Any>())
+        val b = ServiceImage(service, uid, "test", mutableMapOf(), mutableMapOf<String, Any>())
 
         assertEquals(a, b)
     }
 
     @Test
     fun testInequalityWithDifferentType() {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
-        val a = InternalImage(service, uid, "test", mutableMapOf(), mutableMapOf())
+        val a = ServiceImage(service, uid, "test", mutableMapOf(), mutableMapOf<String, Any>())
 
         val b = mockk<Image>(relaxUnitFun = true)
         every { b.uid } returns UUID.randomUUID()
@@ -73,9 +58,9 @@ class InternalImageTest {
 
     @Test
     fun testInequalityWithIncorrectType() {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
-        val a = InternalImage(service, uid, "test", mutableMapOf(), mutableMapOf())
+        val a = ServiceImage(service, uid, "test", mutableMapOf(), mutableMapOf<String, Any>())
 
         assertNotEquals(a, Unit)
     }
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/ServiceServerTest.kt
index 05a8160e..f9fcd27b 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/ServiceServerTest.kt
@@ -22,7 +22,6 @@
 
 package org.opendc.compute.service
 
-import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.mockk
 import io.mockk.verify
@@ -35,51 +34,33 @@ import org.junit.jupiter.api.assertThrows
 import org.opendc.compute.api.Server
 import org.opendc.compute.api.ServerState
 import org.opendc.compute.service.driver.Host
-import org.opendc.compute.service.internal.ComputeServiceImpl
-import org.opendc.compute.service.internal.InternalFlavor
-import org.opendc.compute.service.internal.InternalImage
-import org.opendc.compute.service.internal.InternalServer
 import org.opendc.simulator.kotlin.runSimulation
 import java.util.UUID
 
 /**
- * Test suite for the [InternalServer] implementation.
+ * Test suite for the [ServiceServer] implementation.
  */
-class InternalServerTest {
+class ServiceServerTest {
     @Test
     fun testEquality() {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
         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())
-
-        assertEquals(a, b)
-    }
-
-    @Test
-    fun testEqualityWithDifferentType() {
-        val service = mockk<ComputeServiceImpl>()
-        val uid = UUID.randomUUID()
-        val flavor = mockFlavor()
-        val image = mockImage()
-        val a = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
-
-        val b = mockk<Server>(relaxUnitFun = true)
-        every { b.uid } returns uid
+        val a = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+        val b = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
         assertEquals(a, b)
     }
 
     @Test
     fun testInequalityWithDifferentType() {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
         val flavor = mockFlavor()
         val image = mockImage()
-        val a = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
+        val a = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
         val b = mockk<Server>(relaxUnitFun = true)
         every { b.uid } returns UUID.randomUUID()
@@ -89,24 +70,24 @@ class InternalServerTest {
 
     @Test
     fun testInequalityWithIncorrectType() {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
         val flavor = mockFlavor()
         val image = mockImage()
-        val a = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
+        val a = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
         assertNotEquals(a, Unit)
     }
 
     @Test
     fun testStartTerminatedServer() = runSimulation {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
         val flavor = mockFlavor()
         val image = mockImage()
-        val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
+        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
-        every { service.schedule(any()) } answers { ComputeServiceImpl.SchedulingRequest(it.invocation.args[0] as InternalServer, 0) }
+        every { service.schedule(any()) } answers { ComputeService.SchedulingRequest(it.invocation.args[0] as ServiceServer, 0) }
 
         server.start()
 
@@ -116,26 +97,26 @@ class InternalServerTest {
 
     @Test
     fun testStartDeletedServer() = runSimulation {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
         val flavor = mockFlavor()
         val image = mockImage()
-        val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
+        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
-        server.state = ServerState.DELETED
+        server.setState(ServerState.DELETED)
 
         assertThrows<IllegalStateException> { server.start() }
     }
 
     @Test
     fun testStartProvisioningServer() = runSimulation {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
         val flavor = mockFlavor()
         val image = mockImage()
-        val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
+        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
-        server.state = ServerState.PROVISIONING
+        server.setState(ServerState.PROVISIONING)
 
         server.start()
 
@@ -144,13 +125,13 @@ class InternalServerTest {
 
     @Test
     fun testStartRunningServer() = runSimulation {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
         val flavor = mockFlavor()
         val image = mockImage()
-        val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
+        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
-        server.state = ServerState.RUNNING
+        server.setState(ServerState.RUNNING)
 
         server.start()
 
@@ -159,12 +140,12 @@ class InternalServerTest {
 
     @Test
     fun testStopProvisioningServer() = runSimulation {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
         val flavor = mockFlavor()
         val image = mockImage()
-        val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
-        val request = ComputeServiceImpl.SchedulingRequest(server, 0)
+        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+        val request = ComputeService.SchedulingRequest(server, 0)
 
         every { service.schedule(any()) } returns request
 
@@ -177,13 +158,13 @@ class InternalServerTest {
 
     @Test
     fun testStopTerminatedServer() = runSimulation {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
         val flavor = mockFlavor()
         val image = mockImage()
-        val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
+        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
-        server.state = ServerState.TERMINATED
+        server.setState(ServerState.TERMINATED)
         server.stop()
 
         assertEquals(ServerState.TERMINATED, server.state)
@@ -191,13 +172,13 @@ class InternalServerTest {
 
     @Test
     fun testStopDeletedServer() = runSimulation {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
         val flavor = mockFlavor()
         val image = mockImage()
-        val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
+        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
-        server.state = ServerState.DELETED
+        server.setState(ServerState.DELETED)
         server.stop()
 
         assertEquals(ServerState.DELETED, server.state)
@@ -205,29 +186,29 @@ class InternalServerTest {
 
     @Test
     fun testStopRunningServer() = runSimulation {
-        val service = mockk<ComputeServiceImpl>()
+        val service = mockk<ComputeService>()
         val uid = UUID.randomUUID()
         val flavor = mockFlavor()
         val image = mockImage()
-        val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
+        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
         val host = mockk<Host>(relaxUnitFun = true)
 
-        server.state = ServerState.RUNNING
+        server.setState(ServerState.RUNNING)
         server.host = host
         server.stop()
         yield()
 
-        coVerify { host.stop(server) }
+        verify { host.stop(server) }
     }
 
     @Test
     fun testDeleteProvisioningServer() = runSimulation {
-        val service = mockk<ComputeServiceImpl>(relaxUnitFun = true)
+        val service = mockk<ComputeService>(relaxUnitFun = true)
         val uid = UUID.randomUUID()
         val flavor = mockFlavor()
         val image = mockImage()
-        val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
-        val request = ComputeServiceImpl.SchedulingRequest(server, 0)
+        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+        val request = ComputeService.SchedulingRequest(server, 0)
 
         every { service.schedule(any()) } returns request
 
@@ -241,13 +222,13 @@ class InternalServerTest {
 
     @Test
     fun testDeleteTerminatedServer() = runSimulation {
-        val service = mockk<ComputeServiceImpl>(relaxUnitFun = true)
+        val service = mockk<ComputeService>(relaxUnitFun = true)
         val uid = UUID.randomUUID()
         val flavor = mockFlavor()
         val image = mockImage()
-        val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
+        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
-        server.state = ServerState.TERMINATED
+        server.setState(ServerState.TERMINATED)
         server.delete()
 
         assertEquals(ServerState.DELETED, server.state)
@@ -257,13 +238,13 @@ class InternalServerTest {
 
     @Test
     fun testDeleteDeletedServer() = runSimulation {
-        val service = mockk<ComputeServiceImpl>(relaxUnitFun = true)
+        val service = mockk<ComputeService>(relaxUnitFun = true)
         val uid = UUID.randomUUID()
         val flavor = mockFlavor()
         val image = mockImage()
-        val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
+        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
 
-        server.state = ServerState.DELETED
+        server.setState(ServerState.DELETED)
         server.delete()
 
         assertEquals(ServerState.DELETED, server.state)
@@ -271,24 +252,24 @@ class InternalServerTest {
 
     @Test
     fun testDeleteRunningServer() = runSimulation {
-        val service = mockk<ComputeServiceImpl>(relaxUnitFun = true)
+        val service = mockk<ComputeService>(relaxUnitFun = true)
         val uid = UUID.randomUUID()
         val flavor = mockFlavor()
         val image = mockImage()
-        val server = InternalServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf())
+        val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
         val host = mockk<Host>(relaxUnitFun = true)
 
-        server.state = ServerState.RUNNING
+        server.setState(ServerState.RUNNING)
         server.host = host
         server.delete()
         yield()
 
-        coVerify { host.delete(server) }
+        verify { host.delete(server) }
         verify { service.delete(server) }
     }
 
-    private fun mockFlavor(): InternalFlavor {
-        val flavor = mockk<InternalFlavor>()
+    private fun mockFlavor(): ServiceFlavor {
+        val flavor = mockk<ServiceFlavor>()
         every { flavor.name } returns "c5.large"
         every { flavor.uid } returns UUID.randomUUID()
         every { flavor.cpuCount } returns 2
@@ -296,8 +277,8 @@ class InternalServerTest {
         return flavor
     }
 
-    private fun mockImage(): InternalImage {
-        val image = mockk<InternalImage>()
+    private fun mockImage(): ServiceImage {
+        val image = mockk<ServiceImage>()
         every { image.name } returns "ubuntu-20.04"
         every { image.uid } returns UUID.randomUUID()
         return image
diff --git a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/scheduler/FilterSchedulerTest.kt b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/scheduler/FilterSchedulerTest.kt
index 4608bf37..4af6f7ec 100644
--- a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/scheduler/FilterSchedulerTest.kt
+++ b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/scheduler/FilterSchedulerTest.kt
@@ -30,9 +30,9 @@ import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertAll
 import org.junit.jupiter.api.assertThrows
 import org.opendc.compute.api.Server
+import org.opendc.compute.service.HostView
 import org.opendc.compute.service.driver.HostModel
 import org.opendc.compute.service.driver.HostState
-import org.opendc.compute.service.internal.HostView
 import org.opendc.compute.service.scheduler.filters.ComputeFilter
 import org.opendc.compute.service.scheduler.filters.DifferentHostFilter
 import org.opendc.compute.service.scheduler.filters.InstanceCountFilter