reactive_graph_reactive_service_impl/
reactive_flow_manager_impl.rs1use 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 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 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>, #[component(default = "DashMap::new")]
80 flow_instance_providers: DashMap<Uuid, Arc<dyn FlowInstanceProvider>>, #[component(default = "create_label_path_tree")]
83 label_path_tree: RwLock<PathTree<Uuid>>, }
85
86impl ReactiveFlowManagerImpl {
87 fn get_entity_instance_id_by_extension(&self, entity_instance: &EntityInstance, variables: &PropertyInstances) -> Uuid {
88 if entity_instance.has_own_extension(&EXTENSION_FLOW_RESOLVE_EXISTING_INSTANCE.clone()) {
90 return entity_instance.id;
91 }
92 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 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 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 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 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 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 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 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 entity_instance_copy
242 .properties
243 .insert(property.name.clone(), property.data_type.default_value());
244 }
245 }
246
247 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 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 for property in relation_type.properties.iter() {
291 if !relation_instance_copy.properties.contains_key(&property.name) {
292 relation_instance_copy
296 .properties
297 .insert(property.name.clone(), property.data_type.default_value());
298 }
299 }
300
301 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 relation_instance_copy
310 .properties
311 .insert(property.name.clone(), property.data_type.default_value());
312 }
313 }
314 }
315 }
316
317 relation_instances.push(relation_instance_copy);
321 }
322
323 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()) .description(flow_type.description.clone())
329 .entity_instances(entity_instances)
330 .relation_instances(relation_instances)
331 .build();
332
333 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 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 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 match self.reactive_entity_manager.register_or_merge_reactive_instance(entity_instance.clone()) {
371 Ok(entity_instance) => {
372 replaced_entity_instances.insert(*uuid, entity_instance);
374 }
375 Err(e) => {
376 debug!("Failed to register entity instance {uuid}: {e:?}");
378 }
379 }
380 }
386
387 entity_instances.clear();
389 for (uuid, entity_instance) in replaced_entity_instances.iter() {
390 entity_instances.insert(*uuid, entity_instance.clone());
391 }
392
393 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 }
410
411 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 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 replaced_relation_instances.insert(relation_instance_id.clone(), relation_instance);
424 }
425 Err(e) => {
426 debug!("Failed to register relation instance {relation_instance_id:?}: {e:?}");
428 }
429 }
430 }
431
432 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 } 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 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 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 self.reactive_instance_event_manager.emit_event(ReactiveInstanceEvent::FlowInstanceDeleted(id));
535 result
536 }
537
538 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 }
598}