simulator: Remove concept of resource lifecycle

This change removes the AutoCloseable interface from the
SimResourceProvider and removes the concept of a resource lifecycle.
Instead, resource providers are now either active (running a resource
consumer) or in-active (being idle), which simplifies implementation.

4 files changed, 89 insertions, 198 deletions

diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
index 51024e80..2f01a8c4 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceAggregatorMaxMinTest.kt
@@ -26,7 +26,7 @@ import io.mockk.every
 import io.mockk.mockk
 import io.mockk.verify
 import kotlinx.coroutines.*
-import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.*
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertAll
 import org.junit.jupiter.api.assertThrows
@@ -58,17 +58,13 @@ internal class SimResourceAggregatorMaxMinTest {
         val adapter = SimSpeedConsumerAdapter(forwarder, usage::add)
         source.startConsumer(adapter)
 
-        try {
-            aggregator.consume(consumer)
-            yield()
+        aggregator.consume(consumer)
+        yield()
 
-            assertAll(
-                { assertEquals(1000, clock.millis()) },
-                { assertEquals(listOf(0.0, 0.5, 0.0), usage) }
-            )
-        } finally {
-            aggregator.close()
-        }
+        assertAll(
+            { assertEquals(1000, clock.millis()) },
+            { assertEquals(listOf(0.0, 0.5, 0.0), usage) }
+        )
     }
 
     @Test
@@ -86,16 +82,12 @@ internal class SimResourceAggregatorMaxMinTest {
         val usage = mutableListOf<Double>()
         val adapter = SimSpeedConsumerAdapter(consumer, usage::add)
 
-        try {
-            aggregator.consume(adapter)
-            yield()
-            assertAll(
-                { assertEquals(1000, clock.millis()) },
-                { assertEquals(listOf(0.0, 2.0, 0.0), usage) }
-            )
-        } finally {
-            aggregator.close()
-        }
+        aggregator.consume(adapter)
+        yield()
+        assertAll(
+            { assertEquals(1000, clock.millis()) },
+            { assertEquals(listOf(0.0, 2.0, 0.0), usage) }
+        )
     }
 
     @Test
@@ -114,15 +106,11 @@ internal class SimResourceAggregatorMaxMinTest {
             .returns(SimResourceCommand.Consume(4.0, 4.0, 1000))
             .andThen(SimResourceCommand.Exit)
 
-        try {
-            aggregator.consume(consumer)
-            yield()
-            assertEquals(1000, clock.millis())
+        aggregator.consume(consumer)
+        yield()
+        assertEquals(1000, clock.millis())
 
-            verify(exactly = 2) { consumer.onNext(any()) }
-        } finally {
-            aggregator.close()
-        }
+        verify(exactly = 2) { consumer.onNext(any()) }
     }
 
     @Test
@@ -141,13 +129,9 @@ internal class SimResourceAggregatorMaxMinTest {
             .returns(SimResourceCommand.Consume(1.0, 1.0))
             .andThenThrows(IllegalStateException("Test Exception"))
 
-        try {
-            assertThrows<IllegalStateException> { aggregator.consume(consumer) }
-            yield()
-            assertEquals(SimResourceState.Pending, sources[0].state)
-        } finally {
-            aggregator.close()
-        }
+        assertThrows<IllegalStateException> { aggregator.consume(consumer) }
+        yield()
+        assertFalse(sources[0].isActive)
     }
 
     @Test
@@ -162,17 +146,13 @@ internal class SimResourceAggregatorMaxMinTest {
         sources.forEach(aggregator::addInput)
 
         val consumer = SimWorkConsumer(4.0, 1.0)
-        try {
-            coroutineScope {
-                launch { aggregator.consume(consumer) }
-                delay(1000)
-                sources[0].capacity = 0.5
-            }
-            yield()
-            assertEquals(2334, clock.millis())
-        } finally {
-            aggregator.close()
+        coroutineScope {
+            launch { aggregator.consume(consumer) }
+            delay(1000)
+            sources[0].capacity = 0.5
         }
+        yield()
+        assertEquals(2334, clock.millis())
     }
 
     @Test
@@ -187,17 +167,13 @@ internal class SimResourceAggregatorMaxMinTest {
         sources.forEach(aggregator::addInput)
 
         val consumer = SimWorkConsumer(1.0, 0.5)
-        try {
-            coroutineScope {
-                launch { aggregator.consume(consumer) }
-                delay(500)
-                sources[0].capacity = 0.5
-            }
-            yield()
-            assertEquals(1000, clock.millis())
-        } finally {
-            aggregator.close()
+        coroutineScope {
+            launch { aggregator.consume(consumer) }
+            delay(500)
+            sources[0].capacity = 0.5
         }
+        yield()
+        assertEquals(1000, clock.millis())
     }
 
     @Test
@@ -216,13 +192,9 @@ internal class SimResourceAggregatorMaxMinTest {
             .returns(SimResourceCommand.Consume(4.0, 4.0, 1000))
             .andThen(SimResourceCommand.Exit)
 
-        try {
-            aggregator.consume(consumer)
-            yield()
-            assertEquals(1000, clock.millis())
-            assertEquals(2.0, aggregator.counters.actual) { "Actual work mismatch" }
-        } finally {
-            aggregator.close()
-        }
+        aggregator.consume(consumer)
+        yield()
+        assertEquals(1000, clock.millis())
+        assertEquals(2.0, aggregator.counters.actual) { "Actual work mismatch" }
     }
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
index 08d88093..4895544d 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceSourceTest.kt
@@ -50,16 +50,12 @@ class SimResourceSourceTest {
             .returns(SimResourceCommand.Consume(1000 * capacity, capacity))
             .andThen(SimResourceCommand.Exit)
 
-        try {
-            val res = mutableListOf<Double>()
-            val adapter = SimSpeedConsumerAdapter(consumer, res::add)
+        val res = mutableListOf<Double>()
+        val adapter = SimSpeedConsumerAdapter(consumer, res::add)
 
-            provider.consume(adapter)
+        provider.consume(adapter)
 
-            assertEquals(listOf(0.0, capacity, 0.0), res) { "Speed is reported correctly" }
-        } finally {
-            provider.close()
-        }
+        assertEquals(listOf(0.0, capacity, 0.0), res) { "Speed is reported correctly" }
     }
 
     @Test
@@ -69,17 +65,13 @@ class SimResourceSourceTest {
 
         val consumer = spyk(SimWorkConsumer(2.0, 1.0))
 
-        try {
-            coroutineScope {
-                launch { provider.consume(consumer) }
-                delay(1000)
-                provider.capacity = 0.5
-            }
-            assertEquals(3000, clock.millis())
-            verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Capacity) }
-        } finally {
-            provider.close()
+        coroutineScope {
+            launch { provider.consume(consumer) }
+            delay(1000)
+            provider.capacity = 0.5
         }
+        assertEquals(3000, clock.millis())
+        verify(exactly = 1) { consumer.onEvent(any(), SimResourceEvent.Capacity) }
     }
 
     @Test
@@ -93,16 +85,12 @@ class SimResourceSourceTest {
             .returns(SimResourceCommand.Consume(1000 * capacity, 2 * capacity))
             .andThen(SimResourceCommand.Exit)
 
-        try {
-            val res = mutableListOf<Double>()
-            val adapter = SimSpeedConsumerAdapter(consumer, res::add)
+        val res = mutableListOf<Double>()
+        val adapter = SimSpeedConsumerAdapter(consumer, res::add)
 
-            provider.consume(adapter)
+        provider.consume(adapter)
 
-            assertEquals(listOf(0.0, capacity, 0.0), res) { "Speed is reported correctly" }
-        } finally {
-            provider.close()
-        }
+        assertEquals(listOf(0.0, capacity, 0.0), res) { "Speed is reported correctly" }
     }
 
     /**
@@ -125,11 +113,7 @@ class SimResourceSourceTest {
             }
         }
 
-        try {
-            provider.consume(consumer)
-        } finally {
-            provider.close()
-        }
+        provider.consume(consumer)
     }
 
     @Test
@@ -160,17 +144,13 @@ class SimResourceSourceTest {
             }
         }
 
-        try {
-            launch {
-                yield()
-                resCtx.interrupt()
-            }
-            provider.consume(consumer)
-
-            assertEquals(0, clock.millis())
-        } finally {
-            provider.close()
+        launch {
+            yield()
+            resCtx.interrupt()
         }
+        provider.consume(consumer)
+
+        assertEquals(0, clock.millis())
     }
 
     @Test
@@ -183,12 +163,8 @@ class SimResourceSourceTest {
         every { consumer.onEvent(any(), eq(SimResourceEvent.Start)) }
             .throws(IllegalStateException())
 
-        try {
-            assertThrows<IllegalStateException> {
-                provider.consume(consumer)
-            }
-        } finally {
-            provider.close()
+        assertThrows<IllegalStateException> {
+            provider.consume(consumer)
         }
     }
 
@@ -203,12 +179,8 @@ class SimResourceSourceTest {
             .returns(SimResourceCommand.Consume(1.0, 1.0))
             .andThenThrows(IllegalStateException())
 
-        try {
-            assertThrows<IllegalStateException> {
-                provider.consume(consumer)
-            }
-        } finally {
-            provider.close()
+        assertThrows<IllegalStateException> {
+            provider.consume(consumer)
         }
     }
 
@@ -223,41 +195,16 @@ class SimResourceSourceTest {
             .returns(SimResourceCommand.Consume(1.0, 1.0))
             .andThenThrows(IllegalStateException())
 
-        try {
-            assertThrows<IllegalStateException> {
-                coroutineScope {
-                    launch { provider.consume(consumer) }
-                    provider.consume(consumer)
-                }
-            }
-        } finally {
-            provider.close()
-        }
-    }
-
-    @Test
-    fun testClosedConsumption() = runBlockingSimulation {
-        val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
-        val capacity = 4200.0
-        val provider = SimResourceSource(capacity, scheduler)
-
-        val consumer = mockk<SimResourceConsumer>(relaxUnitFun = true)
-        every { consumer.onNext(any()) }
-            .returns(SimResourceCommand.Consume(1.0, 1.0))
-            .andThenThrows(IllegalStateException())
-
-        try {
-            assertThrows<IllegalStateException> {
-                provider.close()
+        assertThrows<IllegalStateException> {
+            coroutineScope {
+                launch { provider.consume(consumer) }
                 provider.consume(consumer)
             }
-        } finally {
-            provider.close()
         }
     }
 
     @Test
-    fun testCloseDuringConsumption() = runBlockingSimulation {
+    fun testCancelDuringConsumption() = runBlockingSimulation {
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
         val capacity = 4200.0
         val provider = SimResourceSource(capacity, scheduler)
@@ -267,15 +214,11 @@ class SimResourceSourceTest {
             .returns(SimResourceCommand.Consume(1.0, 1.0))
             .andThenThrows(IllegalStateException())
 
-        try {
-            launch { provider.consume(consumer) }
-            delay(500)
-            provider.close()
+        launch { provider.consume(consumer) }
+        delay(500)
+        provider.cancel()
 
-            assertEquals(500, clock.millis())
-        } finally {
-            provider.close()
-        }
+        assertEquals(500, clock.millis())
     }
 
     @Test
@@ -289,13 +232,9 @@ class SimResourceSourceTest {
             .returns(SimResourceCommand.Idle(clock.millis() + 500))
             .andThen(SimResourceCommand.Exit)
 
-        try {
-            provider.consume(consumer)
+        provider.consume(consumer)
 
-            assertEquals(500, clock.millis())
-        } finally {
-            provider.close()
-        }
+        assertEquals(500, clock.millis())
     }
 
     @Test
@@ -311,11 +250,7 @@ class SimResourceSourceTest {
                     .returns(SimResourceCommand.Idle())
                     .andThenThrows(IllegalStateException())
 
-                try {
-                    provider.consume(consumer)
-                } finally {
-                    provider.close()
-                }
+                provider.consume(consumer)
             }
         }
     }
@@ -331,12 +266,8 @@ class SimResourceSourceTest {
             .returns(SimResourceCommand.Idle(2))
             .andThen(SimResourceCommand.Exit)
 
-        try {
-            delay(10)
+        delay(10)
 
-            assertThrows<IllegalArgumentException> { provider.consume(consumer) }
-        } finally {
-            provider.close()
-        }
+        assertThrows<IllegalArgumentException> { provider.consume(consumer) }
     }
 }
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
index 810052b8..cf69b7b5 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimResourceTransformerTest.kt
@@ -40,15 +40,12 @@ import org.opendc.simulator.resources.impl.SimResourceInterpreterImpl
 @OptIn(ExperimentalCoroutinesApi::class)
 internal class SimResourceTransformerTest {
     @Test
-    fun testExitImmediately() = runBlockingSimulation {
+    fun testCancelImmediately() = runBlockingSimulation {
         val forwarder = SimResourceForwarder()
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
         val source = SimResourceSource(2000.0, scheduler)
 
-        launch {
-            source.consume(forwarder)
-            source.close()
-        }
+        launch { source.consume(forwarder) }
 
         forwarder.consume(object : SimResourceConsumer {
             override fun onNext(ctx: SimResourceContext): SimResourceCommand {
@@ -57,18 +54,16 @@ internal class SimResourceTransformerTest {
         })
 
         forwarder.close()
+        source.cancel()
     }
 
     @Test
-    fun testExit() = runBlockingSimulation {
+    fun testCancel() = runBlockingSimulation {
         val forwarder = SimResourceForwarder()
         val scheduler = SimResourceInterpreterImpl(coroutineContext, clock)
         val source = SimResourceSource(2000.0, scheduler)
 
-        launch {
-            source.consume(forwarder)
-            source.close()
-        }
+        launch { source.consume(forwarder) }
 
         forwarder.consume(object : SimResourceConsumer {
             var isFirst = true
@@ -84,6 +79,7 @@ internal class SimResourceTransformerTest {
         })
 
         forwarder.close()
+        source.cancel()
     }
 
     @Test
@@ -93,18 +89,18 @@ internal class SimResourceTransformerTest {
             override fun onNext(ctx: SimResourceContext): SimResourceCommand = SimResourceCommand.Exit
         }
 
-        assertEquals(SimResourceState.Pending, forwarder.state)
+        assertFalse(forwarder.isActive)
 
         forwarder.startConsumer(consumer)
-        assertEquals(SimResourceState.Active, forwarder.state)
+        assertTrue(forwarder.isActive)
 
         assertThrows<IllegalStateException> { forwarder.startConsumer(consumer) }
 
         forwarder.cancel()
-        assertEquals(SimResourceState.Pending, forwarder.state)
+        assertFalse(forwarder.isActive)
 
         forwarder.close()
-        assertEquals(SimResourceState.Stopped, forwarder.state)
+        assertFalse(forwarder.isActive)
     }
 
     @Test
@@ -171,7 +167,7 @@ internal class SimResourceTransformerTest {
         forwarder.consume(consumer)
         yield()
 
-        assertEquals(SimResourceState.Pending, source.state)
+        assertFalse(forwarder.isActive)
     }
 
     @Test
diff --git a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt
index db4fe856..42648cf1 100644
--- a/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt
+++ b/opendc-simulator/opendc-simulator-resources/src/test/kotlin/org/opendc/simulator/resources/SimWorkConsumerTest.kt
@@ -41,12 +41,8 @@ internal class SimWorkConsumerTest {
 
         val consumer = SimWorkConsumer(1.0, 1.0)
 
-        try {
-            provider.consume(consumer)
-            assertEquals(1000, clock.millis())
-        } finally {
-            provider.close()
-        }
+        provider.consume(consumer)
+        assertEquals(1000, clock.millis())
     }
 
     @Test
@@ -56,11 +52,7 @@ internal class SimWorkConsumerTest {
 
         val consumer = SimWorkConsumer(1.0, 0.5)
 
-        try {
-            provider.consume(consumer)
-            assertEquals(2000, clock.millis())
-        } finally {
-            provider.close()
-        }
+        provider.consume(consumer)
+        assertEquals(2000, clock.millis())
     }
 }