299 lines
11 KiB
Rust
299 lines
11 KiB
Rust
use std::{collections::HashMap, sync::Arc};
|
|
|
|
use blake2::{Blake2b512, Digest};
|
|
use rand::Rng;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
/// A `Reference` represents a node in a content-addressable graph structure.
|
|
///
|
|
/// Each reference contains:
|
|
/// - An id that uniquely identifies the referenced object
|
|
/// - A content address hash that represents the content
|
|
/// - A path that provides a human-readable location for the reference
|
|
/// - A list of dependent references that this reference depends on
|
|
///
|
|
/// References form a directed acyclic graph where each node can have multiple dependents.
|
|
/// When the content of a reference changes, the object id of all parent references
|
|
/// are automatically recalculated to maintain content addressability throughout the graph.
|
|
#[derive(Serialize, Deserialize, Debug, Clone)]
|
|
pub struct Reference {
|
|
pub id: String,
|
|
pub content_address: String,
|
|
pub name: String,
|
|
#[serde(skip_serializing_if = "Vec::is_empty")]
|
|
pub dependents: Vec<Arc<Reference>>,
|
|
}
|
|
|
|
impl Reference {
|
|
/// Creates a new Reference with the specified object ID, content address, and path.
|
|
///
|
|
/// # Parameters
|
|
/// * `content_address` - The content-based hash address of the referenced object
|
|
/// * `name` - The name of the reference
|
|
///
|
|
/// # Returns
|
|
/// A new Reference instance with no dependents
|
|
pub fn new(content_address: String, name: String) -> Self {
|
|
// Calculate the reference_id from the content_address and path
|
|
let hasher = Self::initial_hash(&content_address, &name);
|
|
let calculated_id = format!("{:x}", hasher.finalize());
|
|
|
|
Self {
|
|
id: calculated_id,
|
|
content_address,
|
|
name,
|
|
dependents: Vec::new(),
|
|
}
|
|
}
|
|
|
|
/// Adds a dependent reference to this reference.
|
|
///
|
|
/// This establishes a parent-child relationship where this reference depends on
|
|
/// the provided reference. When a dependent reference changes, the parent's
|
|
/// id will be recalculated.
|
|
///
|
|
/// # Parameters
|
|
/// * `dep` - An Arc-wrapped Reference to add as a dependent
|
|
///
|
|
/// # Returns
|
|
/// The modified Reference with the new dependent added
|
|
pub fn add_dep(mut self, dep: Arc<Reference>) -> Self {
|
|
self.dependents.push(dep);
|
|
// Recalculate the ID based on dependents, content_address, and path
|
|
let mut hasher = Self::initial_hash(&self.content_address, &self.name);
|
|
for dependent in &self.dependents {
|
|
hasher.update(&dependent.id);
|
|
}
|
|
self.id = format!("{:x}", hasher.finalize());
|
|
self
|
|
}
|
|
|
|
|
|
/// Converts this Reference into an Arc-wrapped Reference for shared ownership.
|
|
///
|
|
/// This is useful when a Reference needs to be shared across multiple owners
|
|
/// in the graph structure.
|
|
///
|
|
/// # Returns
|
|
/// An Arc-wrapped version of this Reference
|
|
pub fn to_arc(self) -> Arc<Self> {
|
|
Arc::new(self)
|
|
}
|
|
|
|
/// Determines if this Reference is a leaf node (has no dependents).
|
|
///
|
|
/// Leaf nodes directly represent content, while non-leaf nodes derive their
|
|
/// content address from their dependents.
|
|
///
|
|
/// # Returns
|
|
/// `true` if this Reference has no dependents, `false` otherwise
|
|
pub fn is_leaf(&self) -> bool {
|
|
return self.dependents.is_empty();
|
|
}
|
|
|
|
fn initial_hash(content_address: &String, path: &String) -> Blake2b512 {
|
|
let mut hasher = Blake2b512::new();
|
|
hasher.update(content_address);
|
|
hasher.update(path);
|
|
hasher
|
|
}
|
|
}
|
|
|
|
pub struct Graph {
|
|
pub root: Arc<Reference>,
|
|
pub refs: Arc<HashMap<String, Arc<Reference>>>,
|
|
pub objects: Arc<HashMap<String, String>>,
|
|
}
|
|
|
|
impl Graph {
|
|
/// Gets a reference by its path
|
|
pub fn get_reference(&self, path: &str) -> Option<Arc<Reference>> {
|
|
self.refs.get(path).cloned()
|
|
}
|
|
|
|
/// Gets an object by its content address
|
|
pub fn get_object(&self, content_address: &str) -> Option<&String> {
|
|
self.objects.get(content_address)
|
|
}
|
|
}
|
|
|
|
pub fn random_object() -> (String, String) {
|
|
let mut rng = rand::rng();
|
|
let random_size = rng.random_range(50..=4096);
|
|
let random_string: String = (0..random_size)
|
|
.map(|_| rng.sample(rand::distr::Alphanumeric) as char)
|
|
.collect();
|
|
|
|
let mut hasher = Blake2b512::new();
|
|
hasher.update(&random_string);
|
|
let hash = format!("{:x}", hasher.finalize());
|
|
|
|
(hash, random_string)
|
|
}
|
|
|
|
impl Graph {
|
|
/// Updates a reference to point to a new object, recalculating content addresses and IDs
|
|
/// for all affected references in the graph.
|
|
///
|
|
/// The reference ID is calculated from the content address, name, and any dependents,
|
|
/// ensuring that it's truly content-addressable.
|
|
pub fn update_reference(&mut self, name: &String, new_content: String) -> Result<(), String> {
|
|
// Create a mutable copy of our maps
|
|
let mut refs = HashMap::new();
|
|
for (k, v) in self.refs.as_ref() {
|
|
refs.insert(k.clone(), v.clone());
|
|
}
|
|
|
|
let mut objects = HashMap::new();
|
|
for (k, v) in self.objects.as_ref() {
|
|
objects.insert(k.clone(), v.clone());
|
|
}
|
|
|
|
// Find the reference to update
|
|
let ref_to_update = refs.get(name).ok_or_else(|| format!("Reference with name {} not found", name))?;
|
|
|
|
// Calculate hash for the new content
|
|
let mut hasher = Blake2b512::new();
|
|
hasher.update(&new_content);
|
|
let new_address = format!("{:x}", hasher.finalize());
|
|
|
|
// Create a new reference with the updated content address
|
|
// The ID will be calculated based on the content address, name, and dependents
|
|
let mut updated_ref = Reference::new(
|
|
new_address.clone(),
|
|
name.to_string()
|
|
);
|
|
|
|
// Add all dependents to the updated reference
|
|
for dep in &ref_to_update.dependents {
|
|
updated_ref = updated_ref.add_dep(dep.clone());
|
|
}
|
|
|
|
|
|
let updated_ref = updated_ref.to_arc();
|
|
|
|
// Update objects map with new content
|
|
objects.insert(new_address.clone(), new_content);
|
|
|
|
// Update references map with new reference
|
|
refs.insert(name.to_string(), updated_ref.clone());
|
|
|
|
// Find and update all parent references that contain this reference
|
|
self.update_parent_references(&mut refs, name)?;
|
|
|
|
// Update the root reference if needed
|
|
if name == &self.root.name {
|
|
self.root = refs.get(name).unwrap().clone();
|
|
}
|
|
|
|
// Update the Arc maps
|
|
self.refs = Arc::new(refs);
|
|
self.objects = Arc::new(objects);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Recursively updates parent references when a child reference changes
|
|
fn update_parent_references(&self, refs: &mut HashMap<String, Arc<Reference>>, updated_name: &str) -> Result<(), String> {
|
|
// Find all references that have the updated reference as a dependent
|
|
let parent_names: Vec<String> = refs
|
|
.iter()
|
|
.filter(|(_, r)| r.dependents.iter().any(|dep| dep.name == updated_name))
|
|
.map(|(name, _)| name.clone())
|
|
.collect();
|
|
|
|
for parent_name in parent_names {
|
|
if let Some(parent_ref) = refs.get(&parent_name) {
|
|
// Create a new reference with the same content address and name
|
|
let mut updated_parent = Reference::new(
|
|
parent_ref.content_address.clone(),
|
|
parent_ref.name.clone()
|
|
);
|
|
|
|
// Add all dependents, replacing the updated one
|
|
for dep in &parent_ref.dependents {
|
|
if dep.name == updated_name {
|
|
// Use the updated reference
|
|
updated_parent = updated_parent.add_dep(refs.get(updated_name).unwrap().clone());
|
|
} else {
|
|
// Keep the existing dependent
|
|
updated_parent = updated_parent.add_dep(dep.clone());
|
|
}
|
|
}
|
|
|
|
// The ID is automatically calculated in the add_dep method
|
|
let updated_parent = Arc::new(updated_parent);
|
|
|
|
// Update the references map
|
|
refs.insert(parent_name.clone(), updated_parent);
|
|
|
|
// Recursively update parents of this parent
|
|
self.update_parent_references(refs, &parent_name)?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn random_graph() -> Graph {
|
|
let root_name = String::from("ref/0");
|
|
let mut objects = HashMap::new();
|
|
let mut refs = HashMap::new();
|
|
|
|
// Create the root reference
|
|
let mut root_ref = Reference::new(
|
|
String::from("root_content"),
|
|
root_name.clone(),
|
|
);
|
|
|
|
// Create 10 item references
|
|
for i in 1..=10 {
|
|
let item_name = format!("/item/{}", i);
|
|
let mut item_ref = Reference::new(
|
|
format!("item_content_{}", i),
|
|
item_name.clone(),
|
|
);
|
|
|
|
// Create 10 subitems for each item
|
|
for j in 1..=10 {
|
|
let (address, content) = random_object();
|
|
let subitem_name = format!("/item/{}/subitem/{}", i, j);
|
|
|
|
// Create a leaf reference
|
|
let leaf_ref = Reference::new(
|
|
address.clone(),
|
|
subitem_name,
|
|
).to_arc();
|
|
|
|
// Add the leaf reference as a dependent to the item reference
|
|
item_ref = item_ref.add_dep(leaf_ref.clone());
|
|
|
|
// Store the content in the objects map
|
|
objects.insert(address.clone(), content);
|
|
|
|
// Store the leaf reference in the refs map
|
|
refs.insert(leaf_ref.name.clone(), leaf_ref);
|
|
}
|
|
|
|
// Convert the item reference to Arc and add it to the root reference
|
|
let arc_item_ref = item_ref.to_arc();
|
|
root_ref = root_ref.add_dep(arc_item_ref.clone());
|
|
|
|
// Store the item reference in the refs map
|
|
refs.insert(arc_item_ref.name.clone(), arc_item_ref);
|
|
}
|
|
|
|
// Convert the root reference to Arc
|
|
let arc_root_ref = root_ref.to_arc();
|
|
|
|
// Store the root reference in the refs map
|
|
refs.insert(arc_root_ref.name.clone(), arc_root_ref.clone());
|
|
|
|
Graph {
|
|
root: arc_root_ref,
|
|
refs: Arc::new(refs),
|
|
objects: Arc::new(objects),
|
|
}
|
|
}
|
|
}
|