kernel/graph/
import_records.rs1use std::collections::{BTreeMap, HashMap};
20
21use uuid::Uuid;
22
23use super::identity::NodeKey;
24use super::{Graph, current_unix_timestamp_secs, normalize_import_records};
25use crate::types::{
26 ImportRecord, ImportRecordMembership, NodeImportProvenance, NodeImportRecordSummary,
27};
28
29impl Graph {
30 pub fn import_records(&self) -> &[ImportRecord] {
31 &self.import_records
32 }
33
34 pub fn import_record_summaries_for_node(&self, key: NodeKey) -> Vec<NodeImportRecordSummary> {
35 let Some(node) = self.get_node(key) else {
36 return Vec::new();
37 };
38 let node_id = node.id.to_string();
39 let mut summaries = self
40 .import_records
41 .iter()
42 .filter(|record| {
43 record
44 .memberships
45 .iter()
46 .any(|membership| membership.node_id == node_id && !membership.suppressed)
47 })
48 .map(|record| NodeImportRecordSummary {
49 record_id: record.record_id.clone(),
50 source_id: record.source_id.clone(),
51 source_label: record.source_label.clone(),
52 imported_at_secs: record.imported_at_secs,
53 })
54 .collect::<Vec<_>>();
55 summaries.sort_by(|left, right| {
56 right
57 .imported_at_secs
58 .cmp(&left.imported_at_secs)
59 .then_with(|| left.source_label.cmp(&right.source_label))
60 .then_with(|| left.record_id.cmp(&right.record_id))
61 });
62 summaries
63 }
64
65 pub fn import_record_member_keys(&self, record_id: &str) -> Vec<NodeKey> {
66 let mut member_keys = self
67 .import_records
68 .iter()
69 .find(|record| record.record_id == record_id)
70 .into_iter()
71 .flat_map(|record| record.memberships.iter())
72 .filter(|membership| !membership.suppressed)
73 .filter_map(|membership| Uuid::parse_str(&membership.node_id).ok())
74 .filter_map(|node_id| self.inner.key_of(&node_id))
75 .collect::<Vec<_>>();
76 member_keys.sort_by_key(|key| key.index());
77 member_keys.dedup();
78 member_keys
79 }
80
81 pub(crate) fn delete_import_record(&mut self, record_id: &str) -> bool {
82 let original_len = self.import_records.len();
83 self.import_records
84 .retain(|record| record.record_id != record_id);
85 if self.import_records.len() == original_len {
86 return false;
87 }
88 self.sync_node_import_provenance_from_records();
89 true
90 }
91
92 pub(crate) fn set_import_record_membership_suppressed(
93 &mut self,
94 record_id: &str,
95 key: NodeKey,
96 suppressed: bool,
97 ) -> bool {
98 let Some(node_id) = self.get_node(key).map(|node| node.id.to_string()) else {
99 return false;
100 };
101 let mut changed = false;
102 for record in &mut self.import_records {
103 if record.record_id != record_id {
104 continue;
105 }
106 for membership in &mut record.memberships {
107 if membership.node_id == node_id {
108 if membership.suppressed != suppressed {
109 membership.suppressed = suppressed;
110 changed = true;
111 }
112 break;
113 }
114 }
115 }
116 if changed {
117 self.sync_node_import_provenance_from_records();
118 }
119 changed
120 }
121
122 pub(crate) fn set_import_records(&mut self, mut import_records: Vec<ImportRecord>) -> bool {
123 normalize_import_records(&mut import_records);
124 if self.import_records == import_records {
125 return false;
126 }
127 self.import_records = import_records;
128 self.sync_node_import_provenance_from_records();
129 true
130 }
131
132 pub(crate) fn sync_node_import_provenance_from_records(&mut self) {
133 let mut provenance_by_node = HashMap::<NodeKey, Vec<NodeImportProvenance>>::new();
134 for record in &self.import_records {
135 for membership in record
136 .memberships
137 .iter()
138 .filter(|membership| !membership.suppressed)
139 {
140 let Ok(node_id) = Uuid::parse_str(&membership.node_id) else {
141 continue;
142 };
143 let Some(node_key) = self.inner.key_of(&node_id) else {
144 continue;
145 };
146 provenance_by_node
147 .entry(node_key)
148 .or_default()
149 .push(NodeImportProvenance {
150 source_id: record.source_id.clone(),
151 source_label: record.source_label.clone(),
152 });
153 }
154 }
155
156 let node_keys = self.inner.inner().node_indices().collect::<Vec<_>>();
157 for node_key in node_keys {
158 let mut provenance = provenance_by_node.remove(&node_key).unwrap_or_default();
159 provenance.sort();
160 provenance.dedup();
161 self.set_node_facet(node_key, super::node_facets::PROVENANCE_IMPORT, &provenance);
162 }
163 }
164
165 pub(crate) fn rebuild_import_records_from_node_provenance(&mut self, imported_at_secs: u64) {
166 let existing_record_meta = self
167 .import_records
168 .iter()
169 .map(|record| {
170 (
171 (record.source_id.clone(), record.source_label.clone()),
172 (record.record_id.clone(), record.imported_at_secs),
173 )
174 })
175 .collect::<HashMap<_, _>>();
176
177 let mut grouped = BTreeMap::<(String, String), Vec<ImportRecordMembership>>::new();
178 let nodes = self
179 .nodes()
180 .map(|(node_key, node)| (node_key, node.id))
181 .collect::<Vec<_>>();
182 for (node_key, node_id) in nodes {
183 let node_id = node_id.to_string();
184 for provenance in self.node_import_provenance(node_key).unwrap_or_default() {
185 grouped
186 .entry((provenance.source_id, provenance.source_label))
187 .or_default()
188 .push(ImportRecordMembership {
189 node_id: node_id.clone(),
190 suppressed: false,
191 });
192 }
193 }
194
195 let mut import_records = grouped
196 .into_iter()
197 .map(|((source_id, source_label), memberships)| {
198 let (record_id, imported_at_secs) = existing_record_meta
199 .get(&(source_id.clone(), source_label.clone()))
200 .cloned()
201 .unwrap_or_else(|| (format!("import-record:{}", source_id), imported_at_secs));
202 ImportRecord {
203 record_id,
204 source_id,
205 source_label,
206 imported_at_secs,
207 memberships,
208 }
209 })
210 .collect::<Vec<_>>();
211 normalize_import_records(&mut import_records);
212 self.import_records = import_records;
213 self.sync_node_import_provenance_from_records();
214 }
215
216 pub(crate) fn set_node_import_provenance(
217 &mut self,
218 key: NodeKey,
219 import_provenance: Vec<NodeImportProvenance>,
220 ) -> bool {
221 if self.inner.node(key).is_none() {
222 return false;
223 }
224 let mut normalized = import_provenance;
225 normalized.sort();
226 normalized.dedup();
227 if self.node_import_provenance(key).unwrap_or_default() == normalized {
228 return false;
229 }
230 self.set_node_facet(key, super::node_facets::PROVENANCE_IMPORT, &normalized);
231 self.rebuild_import_records_from_node_provenance(current_unix_timestamp_secs());
232 true
233 }
234}