reactive_graph_dynamic_graph_impl/
dynamic_graph_schema_manager_impl.rs1use std::ops::Deref;
2use std::sync::Arc;
3use std::sync::RwLock;
4use std::sync::atomic::AtomicBool;
5use std::sync::atomic::Ordering;
6use std::time::Instant;
7
8use async_graphql::dynamic::Schema;
9use async_graphql::dynamic::SchemaError;
10use async_trait::async_trait;
11use log::debug;
12use log::error;
13use log::info;
14use log::trace;
15use reactive_graph_dynamic_graph_api::DynamicGraphSchemaBuilder;
16use reactive_graph_dynamic_graph_api::DynamicGraphSchemaManager;
17use reactive_graph_lifecycle::Lifecycle;
18use reactive_graph_model_core::reactive_graph::core::event::EventProperties::EVENT;
19use reactive_graph_reactive_model_api::ReactivePropertyContainer;
20use reactive_graph_type_system_api::TypeSystemEventManager;
21use reactive_graph_type_system_api::TypeSystemEventTypes;
22use springtime_di::Component;
23use springtime_di::component_alias;
24use uuid::Uuid;
25
26static UUID_TYPE_SYSTEM_CHANGED_EVENT: Uuid = Uuid::from_u128(0x6ba7b8109e1511d150b900c04fe530c7);
27
28fn create_dynamic_schema() -> Arc<RwLock<Option<Arc<Schema>>>> {
29 Arc::new(RwLock::new(None))
30}
31
32fn create_dynamic_schema_modified() -> Arc<AtomicBool> {
33 Arc::new(AtomicBool::new(true))
34}
35
36#[derive(Component)]
37pub struct DynamicGraphSchemaManagerImpl {
38 dynamic_graph_schema_builder: Arc<dyn DynamicGraphSchemaBuilder + Send + Sync>,
39
40 type_system_event_manager: Arc<dyn TypeSystemEventManager + Send + Sync>,
41
42 #[component(default = "create_dynamic_schema")]
43 dynamic_schema: Arc<RwLock<Option<Arc<Schema>>>>,
44
45 #[component(default = "create_dynamic_schema_modified")]
46 type_system_modified_state: Arc<AtomicBool>,
47}
48
49impl DynamicGraphSchemaManagerImpl {
50 async fn generate_dynamic_schema(&self) {
51 let dynamic_schema_lock = self.dynamic_schema.clone();
52 let type_system_modified_state = self.type_system_modified_state.clone();
53 let dynamic_graph_schema_builder = self.dynamic_graph_schema_builder.clone();
54 tokio::spawn(async move {
55 debug!("Start generating dynamic schema");
56 let start = Instant::now();
57 match dynamic_graph_schema_builder.build_dynamic_schema() {
58 Ok(dynamic_schema) => {
59 let mut guard = dynamic_schema_lock.write().unwrap();
60 *guard = Some(Arc::new(dynamic_schema));
61 type_system_modified_state.store(false, Ordering::Relaxed);
62 let duration = start.elapsed();
63 debug!("Successfully generated dynamic schema in {duration:?}");
64 }
65 Err(e) => {
66 error!("Failed to generate dynamic schema: {e}");
67 }
68 }
69 });
70 }
71}
72
73#[async_trait]
74#[component_alias]
75impl DynamicGraphSchemaManager for DynamicGraphSchemaManagerImpl {
76 fn is_type_system_modified(&self) -> bool {
77 self.type_system_modified_state.load(Ordering::Relaxed)
78 }
79
80 async fn regenerate_dynamic_schema(&self) -> Result<(), SchemaError> {
81 trace!("Regenerating dynamic schema");
82 match self.dynamic_graph_schema_builder.build_dynamic_schema() {
83 Ok(dynamic_schema) => {
84 info!("Successfully regenerated dynamic schema");
85 trace!("{}", dynamic_schema.sdl());
86 let mut guard = self.dynamic_schema.write().unwrap();
87 *guard = Some(Arc::new(dynamic_schema));
88 self.type_system_modified_state.store(false, Ordering::Relaxed);
89 Ok(())
90 }
91 Err(e) => {
92 error!("Failed to regenerate dynamic schema: {e}");
93 Err(e)
94 }
95 }
96 }
97
98 async fn regenerate_dynamic_schema_if_modified(&self) -> Result<(), SchemaError> {
99 if !self.is_type_system_modified() {
100 return Ok(());
101 }
102 trace!("The type system has been modified. Regenerating the dynamic schema");
103 self.regenerate_dynamic_schema().await
104 }
105
106 async fn get_dynamic_schema(&self) -> Result<Arc<Schema>, SchemaError> {
107 self.regenerate_dynamic_schema_if_modified().await?;
108 let guard = self.dynamic_schema.read().unwrap();
109 match guard.deref() {
110 Some(schema) => Ok(schema.clone()),
111 None => {
112 error!("Can't get dynamic schema!");
113 Err(SchemaError("Dynamic schema is empty".to_string()))
114 }
115 }
116 }
117}
118
119#[async_trait]
120impl Lifecycle for DynamicGraphSchemaManagerImpl {
121 async fn init(&self) {}
122
123 async fn post_init(&self) {
124 self.generate_dynamic_schema().await;
126
127 if let Some(event_type_system_changed) = self
129 .type_system_event_manager
130 .get_type_system_event_instance(TypeSystemEventTypes::TypeSystemChanged)
131 {
132 let type_system_modified_state = self.type_system_modified_state.clone();
133 event_type_system_changed.observe_with_handle(
134 EVENT.as_ref(),
135 move |v| {
136 if v.is_boolean() && v.as_bool().unwrap() {
137 info!("The type system has changed -> regenerate the dynamic schema");
139 type_system_modified_state.store(true, Ordering::Relaxed);
140 }
141 },
142 UUID_TYPE_SYSTEM_CHANGED_EVENT.as_u128(),
143 );
144 }
145 }
146
147 async fn pre_shutdown(&self) {
148 if let Some(event_type_system_changed) = self
149 .type_system_event_manager
150 .get_type_system_event_instance(TypeSystemEventTypes::TypeSystemChanged)
151 {
152 event_type_system_changed.remove_observer(&EVENT.as_ref(), UUID_TYPE_SYSTEM_CHANGED_EVENT.as_u128());
153 }
154 }
155
156 async fn shutdown(&self) {}
157}