feat: adding instantiate action (#130)

Author: Frnd-me

src/main/kotlin/at/ac/uibk/dps/cirrina/Cirrina.kt

@@ -9,7 +9,6 @@ private val logger = KotlinLogging.logger {}
 
 class Cirrina {
   fun run() {
-
     val component = DaggerCirrinaComponent.create()
 
     logger.info { "cirrina version ${getBuildVersion()}" }

src/main/kotlin/at/ac/uibk/dps/cirrina/Runtime.kt

@@ -2,19 +2,24 @@ package at.ac.uibk.dps.cirrina
 
 import at.ac.uibk.dps.cirrina.cirrina.di.Main
 import at.ac.uibk.dps.cirrina.cirrina.di.Run
-import at.ac.uibk.dps.cirrina.execution.graph.EventGraph
 import at.ac.uibk.dps.cirrina.execution.`object`.*
 import at.ac.uibk.dps.cirrina.execution.service.RandomServiceImplementationSelector
 import at.ac.uibk.dps.cirrina.execution.service.ServiceImplementation
-import at.ac.uibk.dps.cirrina.execution.service.ServiceImplementationSelector
 import at.ac.uibk.dps.cirrina.io.CsmParser
+import at.ac.uibk.dps.cirrina.spec.ContextVariable
 import at.ac.uibk.dps.cirrina.spec.Csml as CsmlSpec
+import at.ac.uibk.dps.cirrina.spec.Event
+import at.ac.uibk.dps.cirrina.spec.Instance
+import at.ac.uibk.dps.cirrina.spec.graph.EventGraph
 import com.codahale.metrics.MetricRegistry
 import com.codahale.metrics.Timer
 import jakarta.inject.Inject
 import java.net.URI
+import kotlin.collections.component1
+import kotlin.collections.component2
 import kotlin.time.measureTime
 import kotlin.time.toJavaDuration
+import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.joinAll
 import kotlinx.coroutines.runBlocking
 import mu.KotlinLogging
@@ -24,75 +29,100 @@ private val logger = KotlinLogging.logger {}
 class Runtime
 @Inject
 constructor(
-  @Run private val run: List<String>,
+  @Run run: List<String>,
   @Main main: URI,
+  metricRegistry: MetricRegistry,
   persistentContext: Context?,
   stateMachineFactory: StateMachine.Factory,
-  val metricRegistry: MetricRegistry,
-) {
-  val eventHandler = EventHandler()
+) : PropagationHandler {
   val extent = persistentContext?.let { Extent.of(it) } ?: Extent.of()
 
-  val selector: ServiceImplementationSelector
+  val eventHandler = EventHandler(this)
 
-  private val instances: Map<String, StateMachine>
+  private val csml =
+    CsmlSpec.create(CsmParser.parseCsml(main))
+      .onFailure { logger.error(it) { "failed to initialize collaborative state machine class" } }
+      .getOrThrow()
 
-  private val graph: EventGraph
+  val serviceImplementationSelector =
+    RandomServiceImplementationSelector(ServiceImplementation.from(csml.bindings ?: emptyList()))
+
+  private val runtimeJob = SupervisorJob()
 
   private var completion: Timer = metricRegistry.timer("runtime.completionTime")
 
-  init {
-    val spec =
-      CsmlSpec.create(CsmParser.parseCsml(main))
-        .onFailure { logger.error(it) { "failed to initialize collaborative state machine class" } }
-        .getOrThrow()
+  inner class InstanceRegistry(private val stateMachineFactory: StateMachine.Factory) {
+    @Volatile
+    var version = 0L
+      private set
 
-    selector =
-      RandomServiceImplementationSelector(ServiceImplementation.from(spec.bindings ?: emptyList()))
+    private val graph = EventGraph()
 
-    persistentContext?.let { context ->
-      spec.collaborativeStateMachine.persistentContext.forEach { variable ->
-        runCatching { context.create(variable.name, variable.value) }
-          .onFailure {
-            logger.warn { "variable '${variable.name}' already exists or failed to create" }
-          }
-      }
+    val instances: List<StateMachine>
+      get() = graph.instances
+
+    fun instantiate(
+      instance: Instance,
+      instanceData: List<ContextVariable> =
+        instance.data.map { (k, v) -> ContextVariable(k, v.evaluate()) },
+    ) {
+      val hierarchy =
+        stateMachineFactory.createHierarchy(
+          name = instance.name,
+          specification = instance.stateMachine,
+          instanceData = instanceData,
+          instanceSubscription = instance.subscription,
+          instanceRegistry = this,
+          parent = null,
+          runtimeExtent = extent,
+          eventHandler = eventHandler,
+          serviceImplementationSelector = serviceImplementationSelector,
+        )
+
+      hierarchy.forEach { machine -> graph.addInstance(machine) }
+
+      ++version
+
+      val instances = graph.instances
+
+      eventHandler.addPublishers(graph.getOutgoing(instances).map { it.event })
+      eventHandler.addSubscribers(instances.flatMap { it.subscriptions })
+
+      hierarchy.forEach { machine -> machine.start(parentContext = runtimeJob) }
     }
 
-    instances =
-      spec.instances
-        .filter { it.name in run }
-        .flatMap { instance ->
-          stateMachineFactory.createHierarchy(
-            name = instance.name,
-            specification = instance.stateMachine,
-            instance = instance,
-            subscriptions =
-              spec.instances.filter { instance.subscription.matches(it.name) }.map { it.name },
-            runtime = this,
-            parent = null,
-          )
-        }
-        .associateBy { it.name }
+    fun findStateMachineInstance(name: String): StateMachine? =
+      graph.instances.filter { it.name == name }.firstOrNull()
+  }
 
-    graph = EventGraph.create(spec.instances)
+  private val instanceRegistry = InstanceRegistry(stateMachineFactory)
 
-    eventHandler.bind(
-      graph = graph,
-      instanceNames = run,
-      subscribedTo = instances.values.flatMap { it.subscriptions }.toSet(),
-      handlers = instances.values.map { it::pushEvent },
-    )
+  init {
+    persistentContext?.let { context ->
+      csml.collaborativeStateMachine.persistentContext.forEach { (k, v) ->
+        runCatching { context.create(k, v.evaluate()) }
+          .onFailure { logger.warn { "variable '${k}' already exists or failed to create" } }
+      }
+    }
+    csml.instances.filter { it.name in run }.forEach { instanceRegistry.instantiate(it) }
   }
 
   fun run() = runBlocking {
-    measureTime { instances.values.map { it.start() }.joinAll() }
+    measureTime {
+        while (runtimeJob.children.any()) {
+          runtimeJob.children.toList().joinAll()
+        }
+
+        runtimeJob.complete()
+        runtimeJob.join()
+      }
       .also {
         completion.update(it.toJavaDuration())
         logger.info { "runtime terminated in $it" }
       }
   }
 
-  fun findStateMachineInstance(stateMachineObjectName: String): StateMachine? =
-    instances[stateMachineObjectName]
+  override fun invoke(event: Event) {
+    instanceRegistry.instances.forEach { it.pushEvent(event) }
+  }
 }

src/main/kotlin/at/ac/uibk/dps/cirrina/di/CirrinaModule.kt

@@ -31,7 +31,6 @@ import java.util.concurrent.TimeUnit
 
 @Module
 class CirrinaModule {
-
   @Provides
   @Singleton
   fun providePersistentContext(): Context? =