reactive_graph_reactive_service_impl/
reactive_flow_manager_impl.rs

1use std::collections::HashMap;
2use std::sync::Arc;
3use std::sync::RwLock;
4
5use async_trait::async_trait;
6use dashmap::DashMap;
7use log::debug;
8use log::error;
9use log::info;
10use log::trace;
11use path_tree::PathTree;
12use springtime_di::Component;
13use springtime_di::component_alias;
14use uuid::Uuid;
15
16use reactive_graph_flow_model::EXTENSION_FLOW_RESOLVE_EXISTING_INSTANCE;
17use reactive_graph_flow_model::EXTENSION_FLOW_UUID_TYPE_EXTENSION;
18use reactive_graph_flow_model::EXTENSION_FLOW_UUID_TYPE_VARIABLE;
19use reactive_graph_graph::EntityInstance;
20use reactive_graph_graph::EntityInstances;
21use reactive_graph_graph::ExtensionContainer;
22use reactive_graph_graph::FlowInstance;
23use reactive_graph_graph::FlowTypeId;
24use reactive_graph_graph::Mutability::Mutable;
25use reactive_graph_graph::MutablePropertyInstanceSetter;
26use reactive_graph_graph::NamespacedTypeGetter;
27use reactive_graph_graph::PropertyInstanceGetter;
28use reactive_graph_graph::PropertyInstanceSetter;
29use reactive_graph_graph::PropertyInstances;
30use reactive_graph_graph::RelationInstance;
31use reactive_graph_graph::RelationInstanceId;
32use reactive_graph_graph::RelationInstances;
33use reactive_graph_graph::TypeDefinitionGetter;
34use reactive_graph_lifecycle::Lifecycle;
35use reactive_graph_model_core::reactive_graph::core::labeled::LabeledProperties::LABEL;
36use reactive_graph_reactive_model_api::ReactiveInstance;
37use reactive_graph_reactive_model_api::ReactivePropertyContainer;
38use reactive_graph_reactive_model_impl::ReactiveEntity;
39use reactive_graph_reactive_model_impl::ReactiveFlow;
40use reactive_graph_reactive_model_impl::ReactiveRelation;
41use reactive_graph_reactive_service_api::FlowInstanceProvider;
42use reactive_graph_reactive_service_api::ReactiveEntityManager;
43use reactive_graph_reactive_service_api::ReactiveFlowCreationError;
44use reactive_graph_reactive_service_api::ReactiveFlowManager;
45use reactive_graph_reactive_service_api::ReactiveInstanceEvent;
46use reactive_graph_reactive_service_api::ReactiveInstanceEventManager;
47use reactive_graph_reactive_service_api::ReactiveRelationManager;
48use reactive_graph_type_system_api::ComponentManager;
49use reactive_graph_type_system_api::EntityTypeManager;
50use reactive_graph_type_system_api::FlowTypeManager;
51use reactive_graph_type_system_api::RelationTypeManager;
52
53fn create_label_path_tree() -> RwLock<PathTree<Uuid>> {
54    RwLock::new(PathTree::<Uuid>::new())
55}
56
57#[derive(Component)]
58pub struct ReactiveFlowManagerImpl {
59    reactive_instance_event_manager: Arc<dyn ReactiveInstanceEventManager + Send + Sync>,
60
61    // type_system_event_manager: Arc<dyn TypeSystemEventManager + Send + Sync>,
62    component_manager: Arc<dyn ComponentManager + Send + Sync>,
63
64    entity_type_manager: Arc<dyn EntityTypeManager + Send + Sync>,
65
66    relation_type_manager: Arc<dyn RelationTypeManager + Send + Sync>,
67
68    flow_type_manager: Arc<dyn FlowTypeManager + Send + Sync>,
69
70    // flow_instance_manager: Arc<dyn FlowInstanceManager>,
71    reactive_entity_manager: Arc<dyn ReactiveEntityManager + Send + Sync>,
72
73    reactive_relation_manager: Arc<dyn ReactiveRelationManager + Send + Sync>,
74
75    #[component(default = "DashMap::new")]
76    reactive_flow_instances: DashMap<Uuid, ReactiveFlow>, // ReactiveFlowsStorage,
77
78    // TODO: move into own service
79    #[component(default = "DashMap::new")]
80    flow_instance_providers: DashMap<Uuid, Arc<dyn FlowInstanceProvider>>, // FlowInstanceProviders,
81
82    #[component(default = "create_label_path_tree")]
83    label_path_tree: RwLock<PathTree<Uuid>>, // LabelPathTree,
84}
85
86impl ReactiveFlowManagerImpl {
87    fn get_entity_instance_id_by_extension(&self, entity_instance: &EntityInstance, variables: &PropertyInstances) -> Uuid {
88        // Resolve an existing entity instance: Do not replace the uuid
89        if entity_instance.has_own_extension(&EXTENSION_FLOW_RESOLVE_EXISTING_INSTANCE.clone()) {
90            return entity_instance.id;
91        }
92        // Parse the UUID from the variable with the name specified by the extension value.
93        if let Some(id) = entity_instance
94            .get_own_extension(&EXTENSION_FLOW_UUID_TYPE_VARIABLE.clone())
95            .and_then(|extension| extension.extension.as_str().map(|s| s.to_string()))
96            .and_then(|variable_name| variables.get(&variable_name))
97            .and_then(|variable_value| variable_value.as_str().map(|s| s.to_string()))
98            .and_then(|variable_value| Uuid::parse_str(&variable_value).ok())
99        {
100            return id;
101        }
102        // Parse the UUID from the extension value.
103        if let Some(id) = entity_instance
104            .get_own_extension(&EXTENSION_FLOW_UUID_TYPE_EXTENSION.clone())
105            .and_then(|extension| extension.extension.as_str().map(|s| s.to_string()))
106            .and_then(|extension_value| Uuid::parse_str(extension_value.as_str()).ok())
107        {
108            return id;
109        }
110        // Default: Generate a random UUID
111        Uuid::new_v4()
112    }
113}
114
115#[async_trait]
116#[component_alias]
117impl ReactiveFlowManager for ReactiveFlowManagerImpl {
118    fn has(&self, id: Uuid) -> bool {
119        self.reactive_flow_instances.contains_key(&id)
120    }
121
122    fn get(&self, id: Uuid) -> Option<ReactiveFlow> {
123        self.reactive_flow_instances.get(&id).map(|reactive_flow| reactive_flow.value().clone())
124    }
125
126    fn get_by_label(&self, label: &str) -> Option<ReactiveFlow> {
127        let reader = self.label_path_tree.read().unwrap();
128        reader.find(label).and_then(|(id, _path)| self.get(*id))
129    }
130
131    fn get_all(&self) -> Vec<ReactiveFlow> {
132        self.reactive_flow_instances.iter().map(|reactive_flow| reactive_flow.value().clone()).collect()
133    }
134
135    // TODO: Assuming, that an EntityType is used in only one FlowType!
136    fn get_by_type(&self, ty: &FlowTypeId) -> Vec<ReactiveFlow> {
137        let Some(flow_type) = self.flow_type_manager.get(ty) else {
138            return Vec::new();
139        };
140        let entity_ty = flow_type.wrapper_type();
141        self.reactive_flow_instances
142            .iter()
143            .filter(|reactive_flow| reactive_flow.ty == entity_ty)
144            .map(|reactive_flow| reactive_flow.value().clone())
145            .collect()
146    }
147
148    fn count_flow_instances(&self) -> usize {
149        self.reactive_flow_instances.len()
150    }
151
152    fn create_reactive_flow(&self, flow_instance: FlowInstance) -> Result<ReactiveFlow, ReactiveFlowCreationError> {
153        let reactive_flow_instance = ReactiveFlow::try_from(flow_instance);
154        if reactive_flow_instance.is_err() {
155            return Err(ReactiveFlowCreationError::ReactiveFlowConstructionError(reactive_flow_instance.err().unwrap()));
156        }
157        let reactive_flow_instance = reactive_flow_instance.unwrap();
158        self.register_flow_instance_and_reactive_instances(reactive_flow_instance.clone());
159        Ok(reactive_flow_instance)
160    }
161
162    fn create_from_type(
163        &self,
164        ty: &FlowTypeId,
165        id: Option<Uuid>,
166        variables: PropertyInstances,
167        properties: PropertyInstances,
168    ) -> Result<ReactiveFlow, ReactiveFlowCreationError> {
169        info!("create_from_type");
170        let flow_type = self
171            .flow_type_manager
172            .get(ty)
173            .ok_or_else(|| ReactiveFlowCreationError::FlowTypeDoesntExist(ty.clone()))?;
174        for variable in flow_type.variables.iter() {
175            if !variables.contains_key(variable.name.as_str()) {
176                return Err(ReactiveFlowCreationError::MissingVariable(variable.name.clone()));
177            }
178        }
179        let wrapper_entity_type = self
180            .entity_type_manager
181            .get(&flow_type.wrapper_entity_instance.ty)
182            .ok_or_else(|| ReactiveFlowCreationError::EntityTypeDoesntExist(flow_type.wrapper_entity_instance.ty.clone()))?;
183        let mut wrapper_entity_instance = flow_type.wrapper_entity_instance.clone();
184        let wrapper_entity_instance_id = id.unwrap_or_else(|| self.get_entity_instance_id_by_extension(&wrapper_entity_instance, &variables));
185        let mut entity_instance_id_mapping: HashMap<Uuid, Uuid> = HashMap::new();
186        entity_instance_id_mapping.insert(wrapper_entity_instance.id, wrapper_entity_instance_id);
187        wrapper_entity_instance.id = wrapper_entity_instance_id;
188
189        // Add properties from entity_type if not existing
190        for property in wrapper_entity_type.properties.iter() {
191            trace!("Adding property {} from entity type {}", &property.name, &wrapper_entity_type.type_definition().to_string());
192            if !wrapper_entity_instance.properties.contains_key(&property.name) {
193                wrapper_entity_instance
194                    .properties
195                    .insert(property.name.clone(), property.data_type.default_value());
196            }
197        }
198
199        // Add properties from components if not existing
200        for component_ty in wrapper_entity_type.components.iter() {
201            if let Some(component) = self.component_manager.get(&component_ty) {
202                for property in component.properties.iter() {
203                    trace!("Adding property {} from component {}", &property.name, &component_ty.type_definition().to_string());
204                    if !wrapper_entity_instance.properties.contains_key(&property.name) {
205                        //
206                        // TODO: templating using the variables
207                        //
208                        wrapper_entity_instance
209                            .properties
210                            .insert(property.name.clone(), property.data_type.default_value());
211                    }
212                }
213            }
214        }
215
216        for property in properties.iter() {
217            let property_name = property.key();
218            let value = property.value();
219            trace!("Setting property {property_name} with value {value} from parameter");
220            wrapper_entity_instance.set(property_name, value.clone());
221        }
222
223        let entity_instances = EntityInstances::new_with_instance(wrapper_entity_instance);
224        for entity_instance in flow_type.entity_instances.iter() {
225            let entity_type = self
226                .entity_type_manager
227                .get(&entity_instance.ty)
228                .ok_or_else(|| ReactiveFlowCreationError::EntityTypeDoesntExist(entity_instance.ty.clone()))?;
229            let entity_instance_id = self.get_entity_instance_id_by_extension(&entity_instance, &variables);
230            entity_instance_id_mapping.insert(entity_instance.id, entity_instance_id);
231            let mut entity_instance_copy = entity_instance.clone();
232            entity_instance_copy.id = entity_instance_id;
233
234            // Add properties from entity_type if not existing
235            for property in entity_type.properties.iter() {
236                trace!("Adding property {} from entity type {}", &property.name, &entity_type.type_definition().to_string());
237                if !entity_instance_copy.properties.contains_key(&property.name) {
238                    //
239                    // TODO: templating using the variables
240                    //
241                    entity_instance_copy
242                        .properties
243                        .insert(property.name.clone(), property.data_type.default_value());
244                }
245            }
246
247            // Add properties from components if not existing
248            for component_ty in entity_type.components.iter() {
249                if let Some(component) = self.component_manager.get(&component_ty) {
250                    for property in component.properties.iter() {
251                        trace!("Adding property {} from component {}", &property.name, component_ty.type_definition());
252                        if !entity_instance_copy.properties.contains_key(&property.name) {
253                            entity_instance_copy
254                                .properties
255                                .insert(property.name.clone(), property.data_type.default_value());
256                        }
257                    }
258                }
259            }
260
261            // TODO: templating using the variables
262
263            // flow_instance_builder.entity(entity_instance_copy);
264            entity_instances.push(entity_instance_copy);
265        }
266        for (uf, ut) in entity_instance_id_mapping.iter() {
267            trace!("Mapping flow type entity instance id {uf} to actual entity instance id {ut}");
268        }
269
270        let relation_instances = RelationInstances::new();
271
272        for relation_instance in flow_type.relation_instances.iter() {
273            let relation_ty = relation_instance.relation_type_id();
274            trace!("Relation instance type: {}", &relation_instance.ty);
275            let relation_type = self
276                .relation_type_manager
277                .get(&relation_ty)
278                .ok_or(ReactiveFlowCreationError::RelationTypeDoesntExist(relation_ty))?;
279            let mut relation_instance_copy = relation_instance.clone();
280            match entity_instance_id_mapping.get(&relation_instance.outbound_id) {
281                Some(replaced_id) => relation_instance_copy.outbound_id = *replaced_id,
282                None => return Err(ReactiveFlowCreationError::InvalidOutboundId(relation_instance.outbound_id)),
283            }
284            match entity_instance_id_mapping.get(&relation_instance.inbound_id) {
285                Some(replaced_id) => relation_instance_copy.inbound_id = *replaced_id,
286                None => return Err(ReactiveFlowCreationError::InvalidInboundId(relation_instance.inbound_id)),
287            }
288
289            // Add properties from relation type if not existing
290            for property in relation_type.properties.iter() {
291                if !relation_instance_copy.properties.contains_key(&property.name) {
292                    //
293                    // TODO: templating using the variables
294                    //
295                    relation_instance_copy
296                        .properties
297                        .insert(property.name.clone(), property.data_type.default_value());
298                }
299            }
300
301            // Add properties from components if not existing
302            for component_ty in relation_type.components.iter() {
303                if let Some(component) = self.component_manager.get(&component_ty) {
304                    for property in component.properties.iter() {
305                        if !relation_instance_copy.properties.contains_key(&property.name) {
306                            //
307                            // TODO: templating using the variables
308                            //
309                            relation_instance_copy
310                                .properties
311                                .insert(property.name.clone(), property.data_type.default_value());
312                        }
313                    }
314                }
315            }
316
317            // TODO: templating using the variables
318
319            // flow_instance_builder.relation(relation_instance_copy);
320            relation_instances.push(relation_instance_copy);
321        }
322
323        // TODO
324        let flow_instance = FlowInstance::builder()
325            .ty(flow_type.wrapper_type())
326            .id(wrapper_entity_instance_id)
327            .name(flow_type.type_name().to_string()) // Default name for the flow instance is the flow type name.
328            .description(flow_type.description.clone())
329            .entity_instances(entity_instances)
330            .relation_instances(relation_instances)
331            .build();
332
333        // let flow_instance = flow_instance_builder.build();
334        trace!("{flow_instance:?}");
335        match ReactiveFlow::try_from(flow_instance) {
336            Ok(reactive_flow_instance) => {
337                self.register_flow_instance_and_reactive_instances(reactive_flow_instance.clone());
338
339                // Set or create properties given with the flow type instantiation
340                if let Some(wrapper_entity_instance) = reactive_flow_instance.get_wrapper_entity_instance() {
341                    for property in properties.iter() {
342                        let property_name = property.key();
343                        let property_value = property.value();
344                        if !wrapper_entity_instance.has_property(property_name) {
345                            trace!("Adding parameter property {property_name} with value {property_value} from parameter");
346                            wrapper_entity_instance.add_property(property_name, Mutable, property_value.clone());
347                        } else {
348                            trace!("Set parameter property {property_name} with value {property_value} from parameter");
349                            wrapper_entity_instance.set(property_name, property_value.clone());
350                        }
351                    }
352                }
353
354                Ok(reactive_flow_instance)
355            }
356            Err(e) => Err(ReactiveFlowCreationError::ReactiveFlowConstructionError(e)),
357        }
358    }
359
360    fn register_flow_instance_and_reactive_instances(&self, reactive_flow_instance: ReactiveFlow) {
361        if !self.has(reactive_flow_instance.id) {
362            {
363                // Step 1: Register all entity instances (if not already registered by uuid)
364                let mut entity_instances = reactive_flow_instance.entity_instances.write().unwrap();
365                let mut replaced_entity_instances = HashMap::<Uuid, ReactiveEntity>::new();
366                for (uuid, entity_instance) in entity_instances.iter() {
367                    // if let Some(entity_type) = self.entity_type_manager.get(&entity_instance.type_name) {
368                    //     for property in entity_type.properties.iter() {}
369                    // }
370                    match self.reactive_entity_manager.register_or_merge_reactive_instance(entity_instance.clone()) {
371                        Ok(entity_instance) => {
372                            // Replace the entity instance with the actual registered instance instead
373                            replaced_entity_instances.insert(*uuid, entity_instance);
374                        }
375                        Err(e) => {
376                            // This happens when a entity instance doesn't exist and cannot be created
377                            debug!("Failed to register entity instance {uuid}: {e:?}");
378                        }
379                    }
380                    // let entity_instance = self
381                    //     .reactive_entity_manager
382                    //     .register_or_merge_reactive_instance(entity_instance.clone());
383                    // // Replace the entity instance with the actual registered instance instead
384                    // replaced_entity_instances.insert(*uuid, entity_instance);
385                }
386
387                // Step 2: Replace the entity instances of the flow instance with the actual registered entity instances
388                entity_instances.clear();
389                for (uuid, entity_instance) in replaced_entity_instances.iter() {
390                    entity_instances.insert(*uuid, entity_instance.clone());
391                }
392
393                // Step 3: Recreate the reactive relation instances
394                // Because the entity instances might have been replaced by the actual registered entity instances
395                let mut relation_instances = reactive_flow_instance.relation_instances.write().unwrap();
396                let mut replaced_relation_instances = HashMap::<RelationInstanceId, ReactiveRelation>::new();
397                for (relation_instance_id, relation_instance) in relation_instances.iter() {
398                    let inbound_id = relation_instance.inbound.id;
399                    let outbound_id = relation_instance.outbound.id;
400
401                    let recreated_relation_instance = ReactiveRelation::new_from_instance(
402                        entity_instances.get(&outbound_id).unwrap().clone(),
403                        entity_instances.get(&inbound_id).unwrap().clone(),
404                        RelationInstance::from(relation_instance.clone()),
405                    );
406                    replaced_relation_instances.insert(relation_instance_id.clone(), recreated_relation_instance);
407                    // relation_instance.inbound = entity_instances.get(&inbound_id).unwrap().clone();
408                    // relation_instance.outbound = entity_instances.get(&outbound_id).unwrap().clone();
409                }
410
411                // Step 4: Replace the relation instances of the flow instance with the recreated relation instances
412                relation_instances.clear();
413                for (relation_instance_id, relation_instance) in replaced_relation_instances.iter() {
414                    relation_instances.insert(relation_instance_id.clone(), relation_instance.clone());
415                }
416
417                // Step 5: Register all (recreated) relation instances (if not already registered by relation_instance_id)
418                let mut replaced_relation_instances = HashMap::<RelationInstanceId, ReactiveRelation>::new();
419                for (relation_instance_id, relation_instance) in relation_instances.iter() {
420                    match self.reactive_relation_manager.register_or_merge_reactive_instance(relation_instance.clone()) {
421                        Ok(relation_instance) => {
422                            // Replace the relation instance with the actual registered instance
423                            replaced_relation_instances.insert(relation_instance_id.clone(), relation_instance);
424                        }
425                        Err(e) => {
426                            // This happens when a relation instance doesn't exist and cannot be created
427                            debug!("Failed to register relation instance {relation_instance_id:?}: {e:?}");
428                        }
429                    }
430                }
431
432                // Step 6: Replace the relation instances of the flow instance with the actual registered relation instances
433                relation_instances.clear();
434                for (relation_instance_id, relation_instance) in replaced_relation_instances.iter() {
435                    relation_instances.insert(relation_instance_id.clone(), relation_instance.clone());
436                }
437            } // Drop rwlock
438            self.register_flow_instance(reactive_flow_instance);
439        }
440    }
441
442    fn register_flow_instance(&self, reactive_flow_instance: ReactiveFlow) {
443        if !self.reactive_entity_manager.has(reactive_flow_instance.id) {
444            if let Some(wrapper_entity_instance) = reactive_flow_instance.get_entity(reactive_flow_instance.id) {
445                if let Err(e) = self.reactive_entity_manager.register_reactive_instance(wrapper_entity_instance) {
446                    error!("Failed to register wrapper entity instance of flow {}: {:?}", reactive_flow_instance.id, e);
447                }
448            }
449        }
450        self.reactive_flow_instances.insert(reactive_flow_instance.id, reactive_flow_instance.clone());
451        // self.reactive_flow_instances
452        //     .write()
453        //     .unwrap()
454        //     .insert(reactive_flow_instance.id, reactive_flow_instance.clone());
455        // Register label
456        if let Some(value) = reactive_flow_instance.get(LABEL.as_ref()) {
457            if let Some(label) = value.as_str() {
458                let mut writer = self.label_path_tree.write().unwrap();
459                let _ = writer.insert(label, reactive_flow_instance.id);
460            }
461        }
462        self.reactive_instance_event_manager
463            .emit_event(ReactiveInstanceEvent::FlowInstanceCreated(reactive_flow_instance.id))
464    }
465
466    // // TODO: how to detect if the flow instance has removed an entity? => remove behaviour
467    // // TODO: how to detect if the flow instance has removed an relation? => remove behaviour
468    // fn commit(&self, id: Uuid) {
469    //     if let Some(reactive_flow_instance) = self.get(id) {
470    //         // Unregister removed relations
471    //         for relation_instance_id in reactive_flow_instance.relations_removed.read().unwrap().iter() {
472    //             self.reactive_relation_manager.unregister_reactive_instance(relation_instance_id);
473    //         }
474    //         reactive_flow_instance.relations_removed.write().unwrap().clear();
475    //
476    //         // Unregister removed entities
477    //         for id in reactive_flow_instance.entities_removed.read().unwrap().iter() {
478    //             self.reactive_entity_manager.unregister_reactive_instance(*id);
479    //         }
480    //         reactive_flow_instance.entities_removed.write().unwrap().clear();
481    //
482    //         // Register added entities
483    //         for id in reactive_flow_instance.entities_added.read().unwrap().iter() {
484    //             if let Some(entity_instance) = reactive_flow_instance.get_entity(*id) {
485    //                 // TODO: How to handle reactive if registering an entity instance wasn't successful?
486    //                 let _ = self.reactive_entity_manager.register_reactive_instance(entity_instance.clone());
487    //             }
488    //         }
489    //         reactive_flow_instance.entities_added.write().unwrap().clear();
490    //
491    //         // Register added relations
492    //         for relation_instance_id in reactive_flow_instance.relations_added.read().unwrap().iter() {
493    //             if let Some(relation_instance) = reactive_flow_instance.get_relation(relation_instance_id) {
494    //                 // TODO: How to handle reactive if registering a relation instance wasn't successful?
495    //                 let _ = self.reactive_relation_manager.register_reactive_instance(relation_instance.clone());
496    //             }
497    //         }
498    //         reactive_flow_instance.relations_added.write().unwrap().clear();
499    //
500    //         // for (_, entity_instance) in reactive_flow.entity_instances.read().unwrap().iter() {
501    //         //     if !self.reactive_entity_manager.has(entity_instance.id) {
502    //         //         self.reactive_entity_manager.register_reactive_instance(entity_instance.clone());
503    //         //     }
504    //         // }
505    //         // for (_, relation_instance) in reactive_flow.relation_instances.read().unwrap().iter() {
506    //         //     let relation_instance_id = relation_instance.get_key();
507    //         //     if relation_instance_id.is_some() {
508    //         //         let relation_instance_id = relation_instance_id.unwrap();
509    //         //         if !self.reactive_relation_manager.has(relation_instance_id.clone()) {
510    //         //             self.reactive_relation_manager.register_reactive_instance(relation_instance.clone());
511    //         //         }
512    //         //     }
513    //         // }
514    //
515    //         if let Ok(flow_instance) = FlowInstance::try_from(reactive_flow_instance) {
516    //             self.flow_instance_manager.commit(flow_instance);
517    //         }
518    //     }
519    // }
520
521    fn delete(&self, id: Uuid) -> bool {
522        let Some(reactive_flow_instance) = self.get(id) else {
523            return false;
524        };
525        for (_, entity_instance) in reactive_flow_instance.entity_instances.read().unwrap().iter() {
526            self.reactive_entity_manager.unregister_reactive_instance(entity_instance.id);
527        }
528        for (_, relation_instance) in reactive_flow_instance.relation_instances.read().unwrap().iter() {
529            self.reactive_relation_manager.unregister_reactive_instance(&relation_instance.id());
530        }
531        let result = self.reactive_flow_instances.remove(&id).is_some();
532        // let result = self.reactive_flow_instances.write().unwrap().remove(&id).is_some();
533        // TODO: remove label
534        self.reactive_instance_event_manager.emit_event(ReactiveInstanceEvent::FlowInstanceDeleted(id));
535        result
536    }
537
538    // fn import(&self, path: &str) -> Result<ReactiveFlow, ReactiveFlowImportError> {
539    //     if let Ok(flow_instance) = self.flow_instance_manager.import(path) {
540    //         if let Ok(reactive_flow_instance) = self.create(flow_instance) {
541    //             return Ok(reactive_flow_instance);
542    //         }
543    //     }
544    //     Err(ReactiveFlowImportError)
545    // }
546    //
547    // fn export(&self, id: Uuid, path: &str) {
548    //     if self.has(id) {
549    //         self.commit(id);
550    //         if let Ok(flow_instance) = FlowInstance::try_from(self.get(id).unwrap()) {
551    //             self.flow_instance_manager.export(flow_instance, path);
552    //         }
553    //     }
554    // }
555
556    fn register_provider(&self, id: Uuid, provider: Arc<dyn FlowInstanceProvider>) {
557        self.flow_instance_providers.insert(id, provider);
558    }
559
560    fn unregister_provider(&self, id: &Uuid) {
561        self.flow_instance_providers.remove(id);
562    }
563}
564
565#[async_trait]
566impl Lifecycle for ReactiveFlowManagerImpl {
567    async fn init(&self) {
568        debug!("Importing provided flow instances");
569        for flow_instance_provider in self.flow_instance_providers.iter() {
570            for flow_instance in flow_instance_provider.get_flow_instances() {
571                debug!("Creating provided flow instance {}", flow_instance.id);
572                let reactive_flow_instance = self.create_reactive_flow(flow_instance.clone());
573                match reactive_flow_instance {
574                    Ok(reactive_flow_instance) => {
575                        let created_flow_instance: Result<FlowInstance, _> = reactive_flow_instance.try_into();
576                        match created_flow_instance {
577                            Ok(created_flow_instance) => {
578                                let json = serde_json::to_string_pretty(&created_flow_instance).unwrap();
579                                debug!("Successfully created reactive flow instance:\r\n{json}");
580                            }
581                            Err(err) => {
582                                debug!("Successfully created reactive flow instance {}, but failed to serialize: {:?}", flow_instance.id, err);
583                            }
584                        }
585                    }
586                    Err(err) => {
587                        error!("Failed to create provided flow instance {}: {}", flow_instance.id, err);
588                    }
589                }
590            }
591        }
592    }
593
594    async fn shutdown(&self) {
595        // self.reactive_flow_instances.write().unwrap().clear();
596        // self.flow_instance_providers.write().unwrap().clear();
597    }
598}