compute: Convert Server to stateful interface

This change converts the Server data class which can be used as a
stateful object to control an instance running in the cloud.

3 files changed, 137 insertions, 16 deletions

diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/ClientServer.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/ClientServer.kt
new file mode 100644
index 00000000..6d4fb4ae
--- /dev/null
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/ClientServer.kt
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2021 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package org.opendc.compute.simulator
+
+import org.opendc.compute.core.Flavor
+import org.opendc.compute.core.Server
+import org.opendc.compute.core.ServerState
+import org.opendc.compute.core.ServerWatcher
+import org.opendc.compute.core.image.Image
+import java.util.*
+
+/**
+ * A [Server] implementation that is passed to clients but delegates its implementation to another class.
+ */
+internal class ClientServer(private val delegate: Server) : Server, ServerWatcher {
+    private val watchers = mutableListOf<ServerWatcher>()
+
+    override val uid: UUID = delegate.uid
+
+    override var name: String = delegate.name
+        private set
+
+    override var flavor: Flavor = delegate.flavor
+        private set
+
+    override var image: Image = delegate.image
+        private set
+
+    override var tags: Map<String, String> = delegate.tags.toMap()
+        private set
+
+    override var state: ServerState = delegate.state
+        private set
+
+    override fun watch(watcher: ServerWatcher) {
+        if (watchers.isEmpty()) {
+            delegate.watch(this)
+        }
+
+        watchers += watcher
+    }
+
+    override fun unwatch(watcher: ServerWatcher) {
+        watchers += watcher
+
+        if (watchers.isEmpty()) {
+            delegate.unwatch(this)
+        }
+    }
+
+    override suspend fun refresh() {
+        name = delegate.name
+        flavor = delegate.flavor
+        image = delegate.image
+        tags = delegate.tags
+        state = delegate.state
+    }
+
+    override fun onStateChanged(server: Server, newState: ServerState) {
+        val watchers = watchers
+
+        for (watcher in watchers) {
+            watcher.onStateChanged(this, newState)
+        }
+    }
+}
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtProvisioningService.kt b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtProvisioningService.kt
index ee747a9a..5676a5e9 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtProvisioningService.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/main/kotlin/org/opendc/compute/simulator/SimVirtProvisioningService.kt
@@ -27,10 +27,7 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import mu.KotlinLogging
-import org.opendc.compute.core.Flavor
-import org.opendc.compute.core.Server
-import org.opendc.compute.core.ServerEvent
-import org.opendc.compute.core.ServerState
+import org.opendc.compute.core.*
 import org.opendc.compute.core.image.Image
 import org.opendc.compute.core.metal.Node
 import org.opendc.compute.core.metal.NodeEvent
@@ -181,14 +178,11 @@ public class SimVirtProvisioningService(
         image: Image,
         flavor: Flavor
     ): Server {
-        return Server(
+        return ServerImpl(
             uid = UUID(random.nextLong(), random.nextLong()),
             name = name,
-            tags = emptyMap(),
             flavor = flavor,
-            image = image,
-            state = ServerState.BUILD,
-            events = EventFlow()
+            image = image
         )
     }
 
@@ -255,7 +249,7 @@ public class SimVirtProvisioningService(
 
                 coroutineScope.launch {
                     try {
-                        cont.resume(server)
+                        cont.resume(ClientServer(server))
                         selectedHv.driver.spawn(server)
                         activeServers += server
 
@@ -367,9 +361,9 @@ public class SimVirtProvisioningService(
     }
 
     override fun onStateChange(host: Host, server: Server, newState: ServerState) {
-        val eventFlow = server.events as EventFlow<ServerEvent>
-        val newServer = server.copy(state = newState)
-        eventFlow.emit(ServerEvent.StateChanged(newServer, server.state))
+        val serverImpl = server as ServerImpl
+        serverImpl.state = newState
+        serverImpl.watchers.forEach { it.onStateChanged(server, newState) }
 
         if (newState == ServerState.SHUTOFF) {
             logger.info { "[${clock.millis()}] Server ${server.uid} ${server.name} ${server.flavor} finished." }
@@ -405,4 +399,29 @@ public class SimVirtProvisioningService(
     }
 
     public data class LaunchRequest(val server: Server, val cont: Continuation<Server>)
+
+    private class ServerImpl(
+        override val uid: UUID,
+        override val name: String,
+        override val flavor: Flavor,
+        override val image: Image
+    ) : Server {
+        val watchers = mutableListOf<ServerWatcher>()
+
+        override fun watch(watcher: ServerWatcher) {
+            watchers += watcher
+        }
+
+        override fun unwatch(watcher: ServerWatcher) {
+            watchers -= watcher
+        }
+
+        override suspend fun refresh() {
+            // No-op: this object is the source-of-truth
+        }
+
+        override val tags: Map<String, String> = emptyMap()
+
+        override var state: ServerState = ServerState.BUILD
+    }
 }
diff --git a/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimHostTest.kt b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimHostTest.kt
index 83e891cb..22d3a7d2 100644
--- a/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimHostTest.kt
+++ b/simulator/opendc-compute/opendc-compute-simulator/src/test/kotlin/org/opendc/compute/simulator/SimHostTest.kt
@@ -24,7 +24,6 @@ package org.opendc.compute.simulator
 
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.emptyFlow
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
@@ -36,6 +35,7 @@ import org.junit.jupiter.api.assertAll
 import org.opendc.compute.core.Flavor
 import org.opendc.compute.core.Server
 import org.opendc.compute.core.ServerState
+import org.opendc.compute.core.ServerWatcher
 import org.opendc.compute.core.image.Image
 import org.opendc.compute.core.virt.HostEvent
 import org.opendc.simulator.compute.SimFairShareHypervisorProvider
@@ -134,8 +134,8 @@ internal class SimHostTest {
                 }
                 .launchIn(this)
 
-            launch { virtDriver.spawn(Server(UUID.randomUUID(), "a", emptyMap(), flavor, vmImageA, ServerState.BUILD, emptyFlow())) }
-            launch { virtDriver.spawn(Server(UUID.randomUUID(), "b", emptyMap(), flavor, vmImageB, ServerState.BUILD, emptyFlow())) }
+            launch { virtDriver.spawn(MockServer(UUID.randomUUID(), "a", flavor, vmImageA)) }
+            launch { virtDriver.spawn(MockServer(UUID.randomUUID(), "b", flavor, vmImageB)) }
         }
 
         scope.advanceUntilIdle()
@@ -148,4 +148,20 @@ internal class SimHostTest {
             { assertEquals(1200006, scope.currentTime) }
         )
     }
+
+    private class MockServer(
+        override val uid: UUID,
+        override val name: String,
+        override val flavor: Flavor,
+        override val image: Image
+    ) : Server {
+        override val tags: Map<String, String> = emptyMap()
+        override val state: ServerState = ServerState.BUILD
+
+        override fun watch(watcher: ServerWatcher) {}
+
+        override fun unwatch(watcher: ServerWatcher) {}
+
+        override suspend fun refresh() {}
+    }
 }