Renamed input files and internally server is changed to task (#246)

* Updated SimTrace to use a single ArrayDeque instead of three separate lists for deadline, cpuUsage, and coreCount

* Renamed input files to tasks.parquet and fragments.parquet. Renamed server to task. OpenDC nows exports tasks.parquet instead of server.parquet

3 files changed, 317 insertions, 173 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 32d01660..e48244f0 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
@@ -36,9 +36,9 @@ import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
 import org.opendc.compute.api.Flavor
 import org.opendc.compute.api.Image
-import org.opendc.compute.api.Server
-import org.opendc.compute.api.ServerState
-import org.opendc.compute.api.ServerWatcher
+import org.opendc.compute.api.Task
+import org.opendc.compute.api.TaskState
+import org.opendc.compute.api.TaskWatcher
 import org.opendc.compute.service.driver.Host
 import org.opendc.compute.service.driver.HostListener
 import org.opendc.compute.service.driver.HostModel
@@ -78,21 +78,21 @@ internal class ComputeServiceTest {
 
             assertEquals(emptyList<Flavor>(), client.queryFlavors())
             assertEquals(emptyList<Image>(), client.queryImages())
-            assertEquals(emptyList<Server>(), client.queryServers())
+            assertEquals(emptyList<Task>(), client.queryTasks())
 
             client.close()
 
             assertThrows<IllegalStateException> { client.queryFlavors() }
             assertThrows<IllegalStateException> { client.queryImages() }
-            assertThrows<IllegalStateException> { client.queryServers() }
+            assertThrows<IllegalStateException> { client.queryTasks() }
 
             assertThrows<IllegalStateException> { client.findFlavor(UUID.randomUUID()) }
             assertThrows<IllegalStateException> { client.findImage(UUID.randomUUID()) }
-            assertThrows<IllegalStateException> { client.findServer(UUID.randomUUID()) }
+            assertThrows<IllegalStateException> { client.findTask(UUID.randomUUID()) }
 
             assertThrows<IllegalStateException> { client.newFlavor("test", 1, 2) }
             assertThrows<IllegalStateException> { client.newImage("test") }
-            assertThrows<IllegalStateException> { client.newServer("test", mockk(), mockk()) }
+            assertThrows<IllegalStateException> { client.newTask("test", mockk(), mockk()) }
         }
 
     @Test
@@ -106,12 +106,12 @@ internal class ComputeServiceTest {
             val image = client.newImage("test")
             assertEquals(listOf(image), client.queryImages())
             assertEquals(image, client.findImage(image.uid))
-            val server = client.newServer("test", image, flavor, start = false)
-            assertEquals(listOf(server), client.queryServers())
-            assertEquals(server, client.findServer(server.uid))
+            val server = client.newTask("test", image, flavor, start = false)
+            assertEquals(listOf(server), client.queryTasks())
+            assertEquals(server, client.findTask(server.uid))
 
             server.delete()
-            assertNull(client.findServer(server.uid))
+            assertNull(client.findTask(server.uid))
 
             image.delete()
             assertNull(client.findImage(image.uid))
@@ -174,12 +174,12 @@ internal class ComputeServiceTest {
             val client = service.newClient()
             val flavor = client.newFlavor("test", 1, 0)
             val image = client.newImage("test")
-            val server = client.newServer("test", image, flavor, start = false)
+            val server = client.newTask("test", image, flavor, start = false)
 
             server.start()
             delay(5L * 60 * 1000)
             server.reload()
-            assertEquals(ServerState.TERMINATED, server.state)
+            assertEquals(TaskState.TERMINATED, server.state)
         }
 
     @Test
@@ -188,12 +188,12 @@ internal class ComputeServiceTest {
             val client = service.newClient()
             val flavor = client.newFlavor("test", 0, 1024)
             val image = client.newImage("test")
-            val server = client.newServer("test", image, flavor, start = false)
+            val server = client.newTask("test", image, flavor, start = false)
 
             server.start()
             delay(5L * 60 * 1000)
             server.reload()
-            assertEquals(ServerState.TERMINATED, server.state)
+            assertEquals(TaskState.TERMINATED, server.state)
         }
 
     @Test
@@ -202,12 +202,12 @@ internal class ComputeServiceTest {
             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)
+            val server = client.newTask("test", image, flavor, start = false)
 
             server.start()
             delay(5L * 60 * 1000)
             server.reload()
-            assertEquals(ServerState.TERMINATED, server.state)
+            assertEquals(TaskState.TERMINATED, server.state)
         }
 
     @Test
@@ -216,13 +216,13 @@ internal class ComputeServiceTest {
             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)
+            val server = client.newTask("test", image, flavor, start = false)
 
             server.start()
             server.stop()
             delay(5L * 60 * 1000)
             server.reload()
-            assertEquals(ServerState.TERMINATED, server.state)
+            assertEquals(TaskState.TERMINATED, server.state)
         }
 
     @Test
@@ -239,12 +239,12 @@ internal class ComputeServiceTest {
             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)
+            val server = client.newTask("test", image, flavor, start = false)
 
             server.start()
             delay(10L * 60 * 1000)
             server.reload()
-            assertEquals(ServerState.PROVISIONING, server.state)
+            assertEquals(TaskState.PROVISIONING, server.state)
 
             verify { host.canFit(server) }
         }
@@ -266,7 +266,7 @@ internal class ComputeServiceTest {
             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)
+            val server = client.newTask("test", image, flavor, start = false)
 
             server.start()
             delay(5L * 60 * 1000)
@@ -276,7 +276,7 @@ internal class ComputeServiceTest {
 
             delay(5L * 60 * 1000)
             server.reload()
-            assertEquals(ServerState.PROVISIONING, server.state)
+            assertEquals(TaskState.PROVISIONING, server.state)
 
             verify { host.canFit(server) }
         }
@@ -298,7 +298,7 @@ internal class ComputeServiceTest {
             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)
+            val server = client.newTask("test", image, flavor, start = false)
 
             delay(5L * 60 * 1000)
 
@@ -308,7 +308,7 @@ internal class ComputeServiceTest {
             server.start()
             delay(5L * 60 * 1000)
             server.reload()
-            assertEquals(ServerState.PROVISIONING, server.state)
+            assertEquals(TaskState.PROVISIONING, server.state)
 
             verify(exactly = 0) { host.canFit(server) }
         }
@@ -330,10 +330,10 @@ internal class ComputeServiceTest {
             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)
-            val slot = slot<Server>()
+            val server = client.newTask("test", image, flavor, start = false)
+            val slot = slot<Task>()
 
-            val watcher = mockk<ServerWatcher>(relaxUnitFun = true)
+            val watcher = mockk<TaskWatcher>(relaxUnitFun = true)
             server.watch(watcher)
 
             // Start server
@@ -341,20 +341,20 @@ internal class ComputeServiceTest {
             delay(5L * 60 * 1000)
             coVerify { host.spawn(capture(slot)) }
 
-            listeners.forEach { it.onStateChanged(host, slot.captured, ServerState.RUNNING) }
+            listeners.forEach { it.onStateChanged(host, slot.captured, TaskState.RUNNING) }
 
             server.reload()
-            assertEquals(ServerState.RUNNING, server.state)
+            assertEquals(TaskState.RUNNING, server.state)
 
-            verify { watcher.onStateChanged(server, ServerState.RUNNING) }
+            verify { watcher.onStateChanged(server, TaskState.RUNNING) }
 
             // Stop server
-            listeners.forEach { it.onStateChanged(host, slot.captured, ServerState.TERMINATED) }
+            listeners.forEach { it.onStateChanged(host, slot.captured, TaskState.TERMINATED) }
 
             server.reload()
-            assertEquals(ServerState.TERMINATED, server.state)
+            assertEquals(TaskState.TERMINATED, server.state)
 
-            verify { watcher.onStateChanged(server, ServerState.TERMINATED) }
+            verify { watcher.onStateChanged(server, TaskState.TERMINATED) }
         }
 
     @Test
@@ -375,12 +375,12 @@ internal class ComputeServiceTest {
             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)
+            val server = client.newTask("test", image, flavor, start = false)
 
             server.start()
             delay(5L * 60 * 1000)
 
             server.reload()
-            assertEquals(ServerState.PROVISIONING, server.state)
+            assertEquals(TaskState.PROVISIONING, server.state)
         }
 }
diff --git a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceServerTest.kt b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceTaskTest.kt
index b420ee3b..e77665fe 100644
--- a/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceServerTest.kt
+++ b/opendc-compute/opendc-compute-service/src/test/kotlin/org/opendc/compute/service/ServiceTaskTest.kt
@@ -31,16 +31,16 @@ import org.junit.jupiter.api.Assertions.assertNotEquals
 import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
-import org.opendc.compute.api.Server
-import org.opendc.compute.api.ServerState
+import org.opendc.compute.api.Task
+import org.opendc.compute.api.TaskState
 import org.opendc.compute.service.driver.Host
 import org.opendc.simulator.kotlin.runSimulation
 import java.util.UUID
 
 /**
- * Test suite for the [ServiceServer] implementation.
+ * Test suite for the [ServiceTask] implementation.
  */
-class ServiceServerTest {
+class ServiceTaskTest {
     @Test
     fun testEquality() {
         val service = mockk<ComputeService>()
@@ -48,8 +48,26 @@ class ServiceServerTest {
         val flavor = mockFlavor()
         val image = mockImage()
 
-        val a = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
-        val b = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+        val a =
+            ServiceTask(
+                service,
+                uid,
+                "test",
+                flavor,
+                image,
+                mutableMapOf(),
+                mutableMapOf<String, Any>(),
+            )
+        val b =
+            ServiceTask(
+                service,
+                uid,
+                "test",
+                flavor,
+                image,
+                mutableMapOf(),
+                mutableMapOf<String, Any>(),
+            )
 
         assertEquals(a, b)
     }
@@ -60,9 +78,18 @@ class ServiceServerTest {
         val uid = UUID.randomUUID()
         val flavor = mockFlavor()
         val image = mockImage()
-        val a = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
-
-        val b = mockk<Server>(relaxUnitFun = true)
+        val a =
+            ServiceTask(
+                service,
+                uid,
+                "test",
+                flavor,
+                image,
+                mutableMapOf(),
+                mutableMapOf<String, Any>(),
+            )
+
+        val b = mockk<Task>(relaxUnitFun = true)
         every { b.uid } returns UUID.randomUUID()
 
         assertNotEquals(a, b)
@@ -74,7 +101,16 @@ class ServiceServerTest {
         val uid = UUID.randomUUID()
         val flavor = mockFlavor()
         val image = mockImage()
-        val a = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+        val a =
+            ServiceTask(
+                service,
+                uid,
+                "test",
+                flavor,
+                image,
+                mutableMapOf(),
+                mutableMapOf<String, Any>(),
+            )
 
         assertNotEquals(a, Unit)
     }
@@ -86,14 +122,23 @@ class ServiceServerTest {
             val uid = UUID.randomUUID()
             val flavor = mockFlavor()
             val image = mockImage()
-            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
-
-            every { service.schedule(any()) } answers { ComputeService.SchedulingRequest(it.invocation.args[0] as ServiceServer, 0) }
+            val server =
+                ServiceTask(
+                    service,
+                    uid,
+                    "test",
+                    flavor,
+                    image,
+                    mutableMapOf(),
+                    mutableMapOf<String, Any>(),
+                )
+
+            every { service.schedule(any()) } answers { ComputeService.SchedulingRequest(it.invocation.args[0] as ServiceTask, 0) }
 
             server.start()
 
             verify(exactly = 1) { service.schedule(server) }
-            assertEquals(ServerState.PROVISIONING, server.state)
+            assertEquals(TaskState.PROVISIONING, server.state)
         }
 
     @Test
@@ -103,9 +148,18 @@ class ServiceServerTest {
             val uid = UUID.randomUUID()
             val flavor = mockFlavor()
             val image = mockImage()
-            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
-
-            server.setState(ServerState.DELETED)
+            val server =
+                ServiceTask(
+                    service,
+                    uid,
+                    "test",
+                    flavor,
+                    image,
+                    mutableMapOf(),
+                    mutableMapOf<String, Any>(),
+                )
+
+            server.setState(TaskState.DELETED)
 
             assertThrows<IllegalStateException> { server.start() }
         }
@@ -117,13 +171,22 @@ class ServiceServerTest {
             val uid = UUID.randomUUID()
             val flavor = mockFlavor()
             val image = mockImage()
-            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
-
-            server.setState(ServerState.PROVISIONING)
+            val server =
+                ServiceTask(
+                    service,
+                    uid,
+                    "test",
+                    flavor,
+                    image,
+                    mutableMapOf(),
+                    mutableMapOf<String, Any>(),
+                )
+
+            server.setState(TaskState.PROVISIONING)
 
             server.start()
 
-            assertEquals(ServerState.PROVISIONING, server.state)
+            assertEquals(TaskState.PROVISIONING, server.state)
         }
 
     @Test
@@ -133,13 +196,22 @@ class ServiceServerTest {
             val uid = UUID.randomUUID()
             val flavor = mockFlavor()
             val image = mockImage()
-            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
-
-            server.setState(ServerState.RUNNING)
+            val server =
+                ServiceTask(
+                    service,
+                    uid,
+                    "test",
+                    flavor,
+                    image,
+                    mutableMapOf(),
+                    mutableMapOf<String, Any>(),
+                )
+
+            server.setState(TaskState.RUNNING)
 
             server.start()
 
-            assertEquals(ServerState.RUNNING, server.state)
+            assertEquals(TaskState.RUNNING, server.state)
         }
 
     @Test
@@ -149,7 +221,16 @@ class ServiceServerTest {
             val uid = UUID.randomUUID()
             val flavor = mockFlavor()
             val image = mockImage()
-            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+            val server =
+                ServiceTask(
+                    service,
+                    uid,
+                    "test",
+                    flavor,
+                    image,
+                    mutableMapOf(),
+                    mutableMapOf<String, Any>(),
+                )
             val request = ComputeService.SchedulingRequest(server, 0)
 
             every { service.schedule(any()) } returns request
@@ -158,7 +239,7 @@ class ServiceServerTest {
             server.stop()
 
             assertTrue(request.isCancelled)
-            assertEquals(ServerState.TERMINATED, server.state)
+            assertEquals(TaskState.TERMINATED, server.state)
         }
 
     @Test
@@ -168,12 +249,21 @@ class ServiceServerTest {
             val uid = UUID.randomUUID()
             val flavor = mockFlavor()
             val image = mockImage()
-            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
-
-            server.setState(ServerState.TERMINATED)
+            val server =
+                ServiceTask(
+                    service,
+                    uid,
+                    "test",
+                    flavor,
+                    image,
+                    mutableMapOf(),
+                    mutableMapOf<String, Any>(),
+                )
+
+            server.setState(TaskState.TERMINATED)
             server.stop()
 
-            assertEquals(ServerState.TERMINATED, server.state)
+            assertEquals(TaskState.TERMINATED, server.state)
         }
 
     @Test
@@ -183,12 +273,21 @@ class ServiceServerTest {
             val uid = UUID.randomUUID()
             val flavor = mockFlavor()
             val image = mockImage()
-            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
-
-            server.setState(ServerState.DELETED)
+            val server =
+                ServiceTask(
+                    service,
+                    uid,
+                    "test",
+                    flavor,
+                    image,
+                    mutableMapOf(),
+                    mutableMapOf<String, Any>(),
+                )
+
+            server.setState(TaskState.DELETED)
             server.stop()
 
-            assertEquals(ServerState.DELETED, server.state)
+            assertEquals(TaskState.DELETED, server.state)
         }
 
     @Test
@@ -198,10 +297,19 @@ class ServiceServerTest {
             val uid = UUID.randomUUID()
             val flavor = mockFlavor()
             val image = mockImage()
-            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+            val server =
+                ServiceTask(
+                    service,
+                    uid,
+                    "test",
+                    flavor,
+                    image,
+                    mutableMapOf(),
+                    mutableMapOf<String, Any>(),
+                )
             val host = mockk<Host>(relaxUnitFun = true)
 
-            server.setState(ServerState.RUNNING)
+            server.setState(TaskState.RUNNING)
             server.host = host
             server.stop()
             yield()
@@ -216,7 +324,16 @@ class ServiceServerTest {
             val uid = UUID.randomUUID()
             val flavor = mockFlavor()
             val image = mockImage()
-            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+            val server =
+                ServiceTask(
+                    service,
+                    uid,
+                    "test",
+                    flavor,
+                    image,
+                    mutableMapOf(),
+                    mutableMapOf<String, Any>(),
+                )
             val request = ComputeService.SchedulingRequest(server, 0)
 
             every { service.schedule(any()) } returns request
@@ -225,7 +342,7 @@ class ServiceServerTest {
             server.delete()
 
             assertTrue(request.isCancelled)
-            assertEquals(ServerState.DELETED, server.state)
+            assertEquals(TaskState.DELETED, server.state)
             verify { service.delete(server) }
         }
 
@@ -236,12 +353,21 @@ class ServiceServerTest {
             val uid = UUID.randomUUID()
             val flavor = mockFlavor()
             val image = mockImage()
-            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
-
-            server.setState(ServerState.TERMINATED)
+            val server =
+                ServiceTask(
+                    service,
+                    uid,
+                    "test",
+                    flavor,
+                    image,
+                    mutableMapOf(),
+                    mutableMapOf<String, Any>(),
+                )
+
+            server.setState(TaskState.TERMINATED)
             server.delete()
 
-            assertEquals(ServerState.DELETED, server.state)
+            assertEquals(TaskState.DELETED, server.state)
 
             verify { service.delete(server) }
         }
@@ -253,12 +379,21 @@ class ServiceServerTest {
             val uid = UUID.randomUUID()
             val flavor = mockFlavor()
             val image = mockImage()
-            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
-
-            server.setState(ServerState.DELETED)
+            val server =
+                ServiceTask(
+                    service,
+                    uid,
+                    "test",
+                    flavor,
+                    image,
+                    mutableMapOf(),
+                    mutableMapOf<String, Any>(),
+                )
+
+            server.setState(TaskState.DELETED)
             server.delete()
 
-            assertEquals(ServerState.DELETED, server.state)
+            assertEquals(TaskState.DELETED, server.state)
         }
 
     @Test
@@ -268,10 +403,19 @@ class ServiceServerTest {
             val uid = UUID.randomUUID()
             val flavor = mockFlavor()
             val image = mockImage()
-            val server = ServiceServer(service, uid, "test", flavor, image, mutableMapOf(), mutableMapOf<String, Any>())
+            val server =
+                ServiceTask(
+                    service,
+                    uid,
+                    "test",
+                    flavor,
+                    image,
+                    mutableMapOf(),
+                    mutableMapOf<String, Any>(),
+                )
             val host = mockk<Host>(relaxUnitFun = true)
 
-            server.setState(ServerState.RUNNING)
+            server.setState(TaskState.RUNNING)
             server.host = host
             server.delete()
             yield()
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 3bcecf9b..2478bf82 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
@@ -29,7 +29,7 @@ import org.junit.jupiter.api.Assertions.assertNull
 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.api.Task
 import org.opendc.compute.service.HostView
 import org.opendc.compute.service.driver.HostModel
 import org.opendc.compute.service.driver.HostState
@@ -78,11 +78,11 @@ internal class FilterSchedulerTest {
                 weighers = emptyList(),
             )
 
-        val server = mockk<Server>()
-        every { server.flavor.coreCount } returns 2
-        every { server.flavor.memorySize } returns 1024
+        val task = mockk<Task>()
+        every { task.flavor.coreCount } returns 2
+        every { task.flavor.memorySize } returns 1024
 
-        assertNull(scheduler.select(server))
+        assertNull(scheduler.select(task))
     }
 
     @Test
@@ -102,14 +102,14 @@ internal class FilterSchedulerTest {
         scheduler.addHost(hostA)
         scheduler.addHost(hostB)
 
-        val server = mockk<Server>()
-        every { server.flavor.coreCount } returns 2
-        every { server.flavor.memorySize } returns 1024
+        val task = mockk<Task>()
+        every { task.flavor.coreCount } returns 2
+        every { task.flavor.memorySize } returns 1024
 
         // Make sure we get the first host both times
         assertAll(
-            { assertEquals(hostA, scheduler.select(server)) },
-            { assertEquals(hostA, scheduler.select(server)) },
+            { assertEquals(hostA, scheduler.select(task)) },
+            { assertEquals(hostA, scheduler.select(task)) },
         )
     }
 
@@ -132,14 +132,14 @@ internal class FilterSchedulerTest {
         scheduler.addHost(hostA)
         scheduler.addHost(hostB)
 
-        val server = mockk<Server>()
-        every { server.flavor.coreCount } returns 2
-        every { server.flavor.memorySize } returns 1024
+        val task = mockk<Task>()
+        every { task.flavor.coreCount } returns 2
+        every { task.flavor.memorySize } returns 1024
 
         // Make sure we get the first host both times
         assertAll(
-            { assertEquals(hostB, scheduler.select(server)) },
-            { assertEquals(hostA, scheduler.select(server)) },
+            { assertEquals(hostB, scheduler.select(task)) },
+            { assertEquals(hostA, scheduler.select(task)) },
         )
     }
 
@@ -156,11 +156,11 @@ internal class FilterSchedulerTest {
 
         scheduler.addHost(host)
 
-        val server = mockk<Server>()
-        every { server.flavor.coreCount } returns 2
-        every { server.flavor.memorySize } returns 1024
+        val task = mockk<Task>()
+        every { task.flavor.coreCount } returns 2
+        every { task.flavor.memorySize } returns 1024
 
-        assertNull(scheduler.select(server))
+        assertNull(scheduler.select(task))
     }
 
     @Test
@@ -176,11 +176,11 @@ internal class FilterSchedulerTest {
 
         scheduler.addHost(host)
 
-        val server = mockk<Server>()
-        every { server.flavor.coreCount } returns 2
-        every { server.flavor.memorySize } returns 1024
+        val task = mockk<Task>()
+        every { task.flavor.coreCount } returns 2
+        every { task.flavor.memorySize } returns 1024
 
-        assertEquals(host, scheduler.select(server))
+        assertEquals(host, scheduler.select(task))
     }
 
     @Test
@@ -204,11 +204,11 @@ internal class FilterSchedulerTest {
         scheduler.addHost(hostA)
         scheduler.addHost(hostB)
 
-        val server = mockk<Server>()
-        every { server.flavor.coreCount } returns 2
-        every { server.flavor.memorySize } returns 1024
+        val task = mockk<Task>()
+        every { task.flavor.coreCount } returns 2
+        every { task.flavor.memorySize } returns 1024
 
-        assertEquals(hostB, scheduler.select(server))
+        assertEquals(hostB, scheduler.select(task))
     }
 
     @Test
@@ -226,11 +226,11 @@ internal class FilterSchedulerTest {
 
         scheduler.addHost(host)
 
-        val server = mockk<Server>()
-        every { server.flavor.coreCount } returns 2
-        every { server.flavor.memorySize } returns 2300
+        val task = mockk<Task>()
+        every { task.flavor.coreCount } returns 2
+        every { task.flavor.memorySize } returns 2300
 
-        assertNull(scheduler.select(server))
+        assertNull(scheduler.select(task))
     }
 
     @Test
@@ -254,11 +254,11 @@ internal class FilterSchedulerTest {
         scheduler.addHost(hostA)
         scheduler.addHost(hostB)
 
-        val server = mockk<Server>()
-        every { server.flavor.coreCount } returns 2
-        every { server.flavor.memorySize } returns 1024
+        val task = mockk<Task>()
+        every { task.flavor.coreCount } returns 2
+        every { task.flavor.memorySize } returns 1024
 
-        assertEquals(hostB, scheduler.select(server))
+        assertEquals(hostB, scheduler.select(task))
     }
 
     @Test
@@ -276,11 +276,11 @@ internal class FilterSchedulerTest {
 
         scheduler.addHost(host)
 
-        val server = mockk<Server>()
-        every { server.flavor.coreCount } returns 8
-        every { server.flavor.memorySize } returns 1024
+        val task = mockk<Task>()
+        every { task.flavor.coreCount } returns 8
+        every { task.flavor.memorySize } returns 1024
 
-        assertNull(scheduler.select(server))
+        assertNull(scheduler.select(task))
     }
 
 // TODO: fix when schedulers are reworked
@@ -305,12 +305,12 @@ internal class FilterSchedulerTest {
 
         scheduler.addHost(hostB)
 
-        val server = mockk<Server>()
-        every { server.flavor.coreCount } returns 2
-        every { server.flavor.memorySize } returns 1024
-        every { server.flavor.meta } returns mapOf("cpu-capacity" to 2 * 3200.0)
+        val task = mockk<Task>()
+        every { task.flavor.coreCount } returns 2
+        every { task.flavor.memorySize } returns 1024
+        every { task.flavor.meta } returns mapOf("cpu-capacity" to 2 * 3200.0)
 
-        assertEquals(hostB, scheduler.select(server))
+        assertEquals(hostB, scheduler.select(task))
     }
 
     @Test
@@ -334,11 +334,11 @@ internal class FilterSchedulerTest {
         scheduler.addHost(hostA)
         scheduler.addHost(hostB)
 
-        val server = mockk<Server>()
-        every { server.flavor.coreCount } returns 2
-        every { server.flavor.memorySize } returns 1024
+        val task = mockk<Task>()
+        every { task.flavor.coreCount } returns 2
+        every { task.flavor.memorySize } returns 1024
 
-        assertEquals(hostB, scheduler.select(server))
+        assertEquals(hostB, scheduler.select(task))
     }
 
     @Test
@@ -349,10 +349,10 @@ internal class FilterSchedulerTest {
                 weighers = emptyList(),
             )
 
-        val serverA = mockk<Server>()
-        every { serverA.uid } returns UUID.randomUUID()
-        every { serverA.flavor.coreCount } returns 2
-        every { serverA.flavor.memorySize } returns 1024
+        val taskA = mockk<Task>()
+        every { taskA.uid } returns UUID.randomUUID()
+        every { taskA.flavor.coreCount } returns 2
+        every { taskA.flavor.memorySize } returns 1024
 
         val hostA = mockk<HostView>()
         every { hostA.host.state } returns HostState.UP
@@ -363,22 +363,22 @@ internal class FilterSchedulerTest {
         val hostB = mockk<HostView>()
         every { hostB.host.state } returns HostState.UP
         every { hostB.host.model } returns HostModel(4 * 2600.0, 1, 4, 2048)
-        every { hostB.host.instances } returns setOf(serverA)
+        every { hostB.host.instances } returns setOf(taskA)
         every { hostB.provisionedCores } returns 0
 
         scheduler.addHost(hostA)
         scheduler.addHost(hostB)
 
-        val serverB = mockk<Server>()
-        every { serverB.flavor.coreCount } returns 2
-        every { serverB.flavor.memorySize } returns 1024
-        every { serverB.meta } returns emptyMap()
+        val taskB = mockk<Task>()
+        every { taskB.flavor.coreCount } returns 2
+        every { taskB.flavor.memorySize } returns 1024
+        every { taskB.meta } returns emptyMap()
 
-        assertEquals(hostA, scheduler.select(serverB))
+        assertEquals(hostA, scheduler.select(taskB))
 
-        every { serverB.meta } returns mapOf("scheduler_hint:same_host" to setOf(serverA.uid))
+        every { taskB.meta } returns mapOf("scheduler_hint:same_host" to setOf(taskA.uid))
 
-        assertEquals(hostB, scheduler.select(serverB))
+        assertEquals(hostB, scheduler.select(taskB))
     }
 
     @Test
@@ -389,15 +389,15 @@ internal class FilterSchedulerTest {
                 weighers = emptyList(),
             )
 
-        val serverA = mockk<Server>()
-        every { serverA.uid } returns UUID.randomUUID()
-        every { serverA.flavor.coreCount } returns 2
-        every { serverA.flavor.memorySize } returns 1024
+        val taskA = mockk<Task>()
+        every { taskA.uid } returns UUID.randomUUID()
+        every { taskA.flavor.coreCount } returns 2
+        every { taskA.flavor.memorySize } returns 1024
 
         val hostA = mockk<HostView>()
         every { hostA.host.state } returns HostState.UP
         every { hostA.host.model } returns HostModel(4 * 2600.0, 1, 4, 2048)
-        every { hostA.host.instances } returns setOf(serverA)
+        every { hostA.host.instances } returns setOf(taskA)
         every { hostA.provisionedCores } returns 3
 
         val hostB = mockk<HostView>()
@@ -409,16 +409,16 @@ internal class FilterSchedulerTest {
         scheduler.addHost(hostA)
         scheduler.addHost(hostB)
 
-        val serverB = mockk<Server>()
-        every { serverB.flavor.coreCount } returns 2
-        every { serverB.flavor.memorySize } returns 1024
-        every { serverB.meta } returns emptyMap()
+        val taskB = mockk<Task>()
+        every { taskB.flavor.coreCount } returns 2
+        every { taskB.flavor.memorySize } returns 1024
+        every { taskB.meta } returns emptyMap()
 
-        assertEquals(hostA, scheduler.select(serverB))
+        assertEquals(hostA, scheduler.select(taskB))
 
-        every { serverB.meta } returns mapOf("scheduler_hint:different_host" to setOf(serverA.uid))
+        every { taskB.meta } returns mapOf("scheduler_hint:different_host" to setOf(taskA.uid))
 
-        assertEquals(hostB, scheduler.select(serverB))
+        assertEquals(hostB, scheduler.select(taskB))
     }
 
     @Test
@@ -442,11 +442,11 @@ internal class FilterSchedulerTest {
         scheduler.addHost(hostA)
         scheduler.addHost(hostB)
 
-        val server = mockk<Server>()
-        every { server.flavor.coreCount } returns 2
-        every { server.flavor.memorySize } returns 1024
+        val task = mockk<Task>()
+        every { task.flavor.coreCount } returns 2
+        every { task.flavor.memorySize } returns 1024
 
-        assertEquals(hostA, scheduler.select(server))
+        assertEquals(hostA, scheduler.select(task))
     }
 
     // TODO: fix test when updating schedulers
@@ -471,11 +471,11 @@ internal class FilterSchedulerTest {
         scheduler.addHost(hostA)
         scheduler.addHost(hostB)
 
-        val server = mockk<Server>()
-        every { server.flavor.coreCount } returns 2
-        every { server.flavor.memorySize } returns 1024
+        val task = mockk<Task>()
+        every { task.flavor.coreCount } returns 2
+        every { task.flavor.memorySize } returns 1024
 
-        assertEquals(hostB, scheduler.select(server))
+        assertEquals(hostB, scheduler.select(task))
     }
 
     @Test
@@ -499,11 +499,11 @@ internal class FilterSchedulerTest {
         scheduler.addHost(hostA)
         scheduler.addHost(hostB)
 
-        val server = mockk<Server>()
-        every { server.flavor.coreCount } returns 2
-        every { server.flavor.memorySize } returns 1024
+        val task = mockk<Task>()
+        every { task.flavor.coreCount } returns 2
+        every { task.flavor.memorySize } returns 1024
 
-        assertEquals(hostB, scheduler.select(server))
+        assertEquals(hostB, scheduler.select(task))
     }
 
     @Test
@@ -527,10 +527,10 @@ internal class FilterSchedulerTest {
         scheduler.addHost(hostA)
         scheduler.addHost(hostB)
 
-        val server = mockk<Server>()
-        every { server.flavor.coreCount } returns 2
-        every { server.flavor.memorySize } returns 1024
+        val task = mockk<Task>()
+        every { task.flavor.coreCount } returns 2
+        every { task.flavor.memorySize } returns 1024
 
-        assertEquals(hostB, scheduler.select(server))
+        assertEquals(hostB, scheduler.select(task))
     }
 }