refactor(simulator): Migrate to flow-based simulation

This change renames the `opendc-simulator-resources` module into the
`opendc-simulator-flow` module to indicate that the core simulation
model of OpenDC is based around modelling and simulating flows.

Previously, the distinction between resource consumer and provider, and
input and output caused some confusion. By switching to a flow-based
model, this distinction is now clear (as in, the water flows from source
to consumer/sink).

3 files changed, 71 insertions, 71 deletions

diff --git a/opendc-simulator/opendc-simulator-power/src/test/kotlin/org/opendc/simulator/power/SimPduTest.kt b/opendc-simulator/opendc-simulator-power/src/test/kotlin/org/opendc/simulator/power/SimPduTest.kt
index 17a174b7..568a1e8c 100644
--- a/opendc-simulator/opendc-simulator-power/src/test/kotlin/org/opendc/simulator/power/SimPduTest.kt
+++ b/opendc-simulator/opendc-simulator-power/src/test/kotlin/org/opendc/simulator/power/SimPduTest.kt
@@ -28,10 +28,10 @@ import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
 import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.SimResourceConsumer
-import org.opendc.simulator.resources.SimResourceEvent
-import org.opendc.simulator.resources.SimResourceInterpreter
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
+import org.opendc.simulator.flow.FlowEngine
+import org.opendc.simulator.flow.FlowEvent
+import org.opendc.simulator.flow.FlowSource
+import org.opendc.simulator.flow.source.FixedFlowSource
 
 /**
  * Test suite for the [SimPdu] class.
@@ -39,9 +39,9 @@ import org.opendc.simulator.resources.consumer.SimWorkConsumer
 internal class SimPduTest {
     @Test
     fun testZeroOutlets() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = 100.0)
-        val pdu = SimPdu(interpreter)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = 100.0)
+        val pdu = SimPdu(engine)
         source.connect(pdu)
 
         assertEquals(0.0, source.powerDraw)
@@ -49,9 +49,9 @@ internal class SimPduTest {
 
     @Test
     fun testSingleOutlet() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = 100.0)
-        val pdu = SimPdu(interpreter)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = 100.0)
+        val pdu = SimPdu(engine)
         source.connect(pdu)
         pdu.newOutlet().connect(SimpleInlet())
 
@@ -60,9 +60,9 @@ internal class SimPduTest {
 
     @Test
     fun testDoubleOutlet() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = 100.0)
-        val pdu = SimPdu(interpreter)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = 100.0)
+        val pdu = SimPdu(engine)
         source.connect(pdu)
 
         pdu.newOutlet().connect(SimpleInlet())
@@ -73,28 +73,28 @@ internal class SimPduTest {
 
     @Test
     fun testDisconnect() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = 100.0)
-        val pdu = SimPdu(interpreter)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = 100.0)
+        val pdu = SimPdu(engine)
         source.connect(pdu)
-        val consumer = spyk(SimWorkConsumer(100.0, utilization = 1.0))
+        val consumer = spyk(FixedFlowSource(100.0, utilization = 1.0))
         val inlet = object : SimPowerInlet() {
-            override fun createConsumer(): SimResourceConsumer = consumer
+            override fun createConsumer(): FlowSource = consumer
         }
 
         val outlet = pdu.newOutlet()
         outlet.connect(inlet)
         outlet.disconnect()
 
-        verify { consumer.onEvent(any(), SimResourceEvent.Exit) }
+        verify { consumer.onEvent(any(), any(), FlowEvent.Exit) }
     }
 
     @Test
     fun testLoss() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = 100.0)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = 100.0)
         // https://download.schneider-electric.com/files?p_Doc_Ref=SPD_NRAN-66CK3D_EN
-        val pdu = SimPdu(interpreter, idlePower = 1.5, lossCoefficient = 0.015)
+        val pdu = SimPdu(engine, idlePower = 1.5, lossCoefficient = 0.015)
         source.connect(pdu)
         pdu.newOutlet().connect(SimpleInlet())
         assertEquals(89.0, source.powerDraw, 0.01)
@@ -102,9 +102,9 @@ internal class SimPduTest {
 
     @Test
     fun testOutletClose() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = 100.0)
-        val pdu = SimPdu(interpreter)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = 100.0)
+        val pdu = SimPdu(engine)
         source.connect(pdu)
         val outlet = pdu.newOutlet()
         outlet.close()
@@ -115,6 +115,6 @@ internal class SimPduTest {
     }
 
     class SimpleInlet : SimPowerInlet() {
-        override fun createConsumer(): SimResourceConsumer = SimWorkConsumer(100.0, utilization = 0.5)
+        override fun createConsumer(): FlowSource = FixedFlowSource(100.0, utilization = 0.5)
     }
 }
diff --git a/opendc-simulator/opendc-simulator-power/src/test/kotlin/org/opendc/simulator/power/SimPowerSourceTest.kt b/opendc-simulator/opendc-simulator-power/src/test/kotlin/org/opendc/simulator/power/SimPowerSourceTest.kt
index f3829ba1..b411e292 100644
--- a/opendc-simulator/opendc-simulator-power/src/test/kotlin/org/opendc/simulator/power/SimPowerSourceTest.kt
+++ b/opendc-simulator/opendc-simulator-power/src/test/kotlin/org/opendc/simulator/power/SimPowerSourceTest.kt
@@ -31,10 +31,10 @@ import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertDoesNotThrow
 import org.junit.jupiter.api.assertThrows
 import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.SimResourceConsumer
-import org.opendc.simulator.resources.SimResourceEvent
-import org.opendc.simulator.resources.SimResourceInterpreter
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
+import org.opendc.simulator.flow.FlowEngine
+import org.opendc.simulator.flow.FlowEvent
+import org.opendc.simulator.flow.FlowSource
+import org.opendc.simulator.flow.source.FixedFlowSource
 
 /**
  * Test suite for the [SimPowerSource]
@@ -42,8 +42,8 @@ import org.opendc.simulator.resources.consumer.SimWorkConsumer
 internal class SimPowerSourceTest {
     @Test
     fun testInitialState() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = 100.0)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = 100.0)
 
         assertFalse(source.isConnected)
         assertNull(source.inlet)
@@ -52,8 +52,8 @@ internal class SimPowerSourceTest {
 
     @Test
     fun testDisconnectIdempotent() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = 100.0)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = 100.0)
 
         assertDoesNotThrow { source.disconnect() }
         assertFalse(source.isConnected)
@@ -61,8 +61,8 @@ internal class SimPowerSourceTest {
 
     @Test
     fun testConnect() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = 100.0)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = 100.0)
         val inlet = SimpleInlet()
 
         source.connect(inlet)
@@ -76,27 +76,27 @@ internal class SimPowerSourceTest {
 
     @Test
     fun testDisconnect() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = 100.0)
-        val consumer = spyk(SimWorkConsumer(100.0, utilization = 1.0))
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = 100.0)
+        val consumer = spyk(FixedFlowSource(100.0, utilization = 1.0))
         val inlet = object : SimPowerInlet() {
-            override fun createConsumer(): SimResourceConsumer = consumer
+            override fun createConsumer(): FlowSource = consumer
         }
 
         source.connect(inlet)
         source.disconnect()
 
-        verify { consumer.onEvent(any(), SimResourceEvent.Exit) }
+        verify { consumer.onEvent(any(), any(), FlowEvent.Exit) }
     }
 
     @Test
     fun testDisconnectAssertion() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = 100.0)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = 100.0)
         val inlet = mockk<SimPowerInlet>(relaxUnitFun = true)
         every { inlet.isConnected } returns false
         every { inlet._outlet } returns null
-        every { inlet.createConsumer() } returns SimWorkConsumer(100.0, utilization = 1.0)
+        every { inlet.createConsumer() } returns FixedFlowSource(100.0, utilization = 1.0)
 
         source.connect(inlet)
 
@@ -107,8 +107,8 @@ internal class SimPowerSourceTest {
 
     @Test
     fun testOutletAlreadyConnected() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = 100.0)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = 100.0)
         val inlet = SimpleInlet()
 
         source.connect(inlet)
@@ -121,8 +121,8 @@ internal class SimPowerSourceTest {
 
     @Test
     fun testInletAlreadyConnected() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = 100.0)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = 100.0)
         val inlet = mockk<SimPowerInlet>(relaxUnitFun = true)
         every { inlet.isConnected } returns true
 
@@ -132,6 +132,6 @@ internal class SimPowerSourceTest {
     }
 
     class SimpleInlet : SimPowerInlet() {
-        override fun createConsumer(): SimResourceConsumer = SimWorkConsumer(100.0, utilization = 1.0)
+        override fun createConsumer(): FlowSource = FixedFlowSource(100.0, utilization = 1.0)
     }
 }
diff --git a/opendc-simulator/opendc-simulator-power/src/test/kotlin/org/opendc/simulator/power/SimUpsTest.kt b/opendc-simulator/opendc-simulator-power/src/test/kotlin/org/opendc/simulator/power/SimUpsTest.kt
index 8d5fa857..31ac0b39 100644
--- a/opendc-simulator/opendc-simulator-power/src/test/kotlin/org/opendc/simulator/power/SimUpsTest.kt
+++ b/opendc-simulator/opendc-simulator-power/src/test/kotlin/org/opendc/simulator/power/SimUpsTest.kt
@@ -28,10 +28,10 @@ import org.junit.jupiter.api.Assertions.assertAll
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 import org.opendc.simulator.core.runBlockingSimulation
-import org.opendc.simulator.resources.SimResourceConsumer
-import org.opendc.simulator.resources.SimResourceEvent
-import org.opendc.simulator.resources.SimResourceInterpreter
-import org.opendc.simulator.resources.consumer.SimWorkConsumer
+import org.opendc.simulator.flow.FlowEngine
+import org.opendc.simulator.flow.FlowEvent
+import org.opendc.simulator.flow.FlowSource
+import org.opendc.simulator.flow.source.FixedFlowSource
 
 /**
  * Test suite for the [SimUps] class.
@@ -39,9 +39,9 @@ import org.opendc.simulator.resources.consumer.SimWorkConsumer
 internal class SimUpsTest {
     @Test
     fun testSingleInlet() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = 100.0)
-        val ups = SimUps(interpreter)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = 100.0)
+        val ups = SimUps(engine)
         source.connect(ups.newInlet())
         ups.connect(SimpleInlet())
 
@@ -50,10 +50,10 @@ internal class SimUpsTest {
 
     @Test
     fun testDoubleInlet() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source1 = SimPowerSource(interpreter, capacity = 100.0)
-        val source2 = SimPowerSource(interpreter, capacity = 100.0)
-        val ups = SimUps(interpreter)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source1 = SimPowerSource(engine, capacity = 100.0)
+        val source2 = SimPowerSource(engine, capacity = 100.0)
+        val ups = SimUps(engine)
         source1.connect(ups.newInlet())
         source2.connect(ups.newInlet())
 
@@ -67,10 +67,10 @@ internal class SimUpsTest {
 
     @Test
     fun testLoss() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source = SimPowerSource(interpreter, capacity = 100.0)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source = SimPowerSource(engine, capacity = 100.0)
         // https://download.schneider-electric.com/files?p_Doc_Ref=SPD_NRAN-66CK3D_EN
-        val ups = SimUps(interpreter, idlePower = 4.0, lossCoefficient = 0.05)
+        val ups = SimUps(engine, idlePower = 4.0, lossCoefficient = 0.05)
         source.connect(ups.newInlet())
         ups.connect(SimpleInlet())
 
@@ -79,24 +79,24 @@ internal class SimUpsTest {
 
     @Test
     fun testDisconnect() = runBlockingSimulation {
-        val interpreter = SimResourceInterpreter(coroutineContext, clock)
-        val source1 = SimPowerSource(interpreter, capacity = 100.0)
-        val source2 = SimPowerSource(interpreter, capacity = 100.0)
-        val ups = SimUps(interpreter)
+        val engine = FlowEngine(coroutineContext, clock)
+        val source1 = SimPowerSource(engine, capacity = 100.0)
+        val source2 = SimPowerSource(engine, capacity = 100.0)
+        val ups = SimUps(engine)
         source1.connect(ups.newInlet())
         source2.connect(ups.newInlet())
-        val consumer = spyk(SimWorkConsumer(100.0, utilization = 1.0))
+        val consumer = spyk(FixedFlowSource(100.0, utilization = 1.0))
         val inlet = object : SimPowerInlet() {
-            override fun createConsumer(): SimResourceConsumer = consumer
+            override fun createConsumer(): FlowSource = consumer
         }
 
         ups.connect(inlet)
         ups.disconnect()
 
-        verify { consumer.onEvent(any(), SimResourceEvent.Exit) }
+        verify { consumer.onEvent(any(), any(), FlowEvent.Exit) }
     }
 
     class SimpleInlet : SimPowerInlet() {
-        override fun createConsumer(): SimResourceConsumer = SimWorkConsumer(100.0, utilization = 0.5)
+        override fun createConsumer(): FlowSource = FixedFlowSource(100.0, utilization = 0.5)
     }
 }