refactor(actor): implement replica sync and ref update notification system

- Add is_write parameter to remote clients for read/write routing distinction
- Introduce RepoEntry struct with role tracking (primary/replica) for repositories
- Replace HashSet with HashMap for repository storage with role metadata
- Add ROLE_PRIMARY and ROLE_REPLICA constants for node role identification
- Implement FindPrimary and FindReplica RPC methods for role-based routing
- Add RefUpdateEvent message type for propagating reference updates
- Create sync module with BundleApplicator for handling replica synchronization
- Implement notify_ref_update calls after branch/tag/commit operations
- Add broadcast_ref_update function to propagate events across cluster nodes
- Modify route_repository to prioritize primary for writes and replicas for reads
- Update actor message handling to support role-based repository discovery
- Implement sync_from_primary function using pack protocol for incremental updates

actor/handler.rs

@@ -1,9 +1,8 @@
-use std::collections::HashSet;
+use std::collections::HashMap;
 use async_trait::async_trait;
 use ractor::pg;
 use ractor::{Actor, ActorProcessingErr, ActorRef, SupervisionEvent};
-use crate::actor::message::{GitNodeMessage, NodeHealth, RouteDecision};
-use crate::pb::RepositoryHeader;
+use crate::actor::message::{GitNodeMessage, NodeHealth, RefUpdateEvent, RouteDecision, ROLE_PRIMARY, ROLE_REPLICA};
 use crate::server::GitksService;
 
 #[derive(Clone)]
@@ -21,6 +20,11 @@ impl GitNodeActor {
     }
 }
 
+pub struct RepoEntry {
+    pub role: String,
+    pub last_commit: String,
+}
+
 pub struct GitNodeArgs {
     pub storage_name: String,
     pub grpc_addr: String,
@@ -30,7 +34,7 @@ pub struct GitNodeState {
     storage_name: String,
     actor_name: String,
     grpc_addr: String,
-    registered_repos: HashSet<String>,
+    repos: HashMap<String, RepoEntry>,
 }
 
 #[async_trait]
@@ -52,7 +56,7 @@ impl Actor for GitNodeActor {
             storage_name: args.storage_name,
             actor_name,
             grpc_addr: args.grpc_addr,
-            registered_repos: HashSet::new(),
+            repos: HashMap::new(),
         })
     }
 
@@ -81,38 +85,45 @@ impl Actor for GitNodeActor {
             }
 
             GitNodeMessage::RemoveRepository(header) => {
-                state.registered_repos.remove(&header.relative_path);
-                tracing::info!(
-                    storage_name = %state.storage_name,
-                    relative_path = %header.relative_path,
-                    "repository route removed"
-                );
+                state.repos.remove(&header.relative_path);
+                tracing::info!(storage_name = %state.storage_name, relative_path = %header.relative_path, "repository route removed");
             }
 
-            GitNodeMessage::RouteRepository(header, reply) => {
-                let found = state.registered_repos.contains(&header.relative_path);
-                reply.send(RouteDecision {
-                    found,
-                    storage_name: state.storage_name.clone(),
-                    relative_path: header.relative_path,
-                    actor_name: if found { state.actor_name.clone() } else { String::new() },
-                    grpc_addr: if found { state.grpc_addr.clone() } else { String::new() },
-                }).ok();
+            GitNodeMessage::RefUpdated(event) => {
+                if let Some(entry) = state.repos.get(&event.relative_path) {
+                    if entry.role == ROLE_REPLICA {
+                        let local_path = self.service.repo_prefix.join(&event.relative_path);
+                        crate::actor::sync::sync_from_primary(event, local_path).await;
+                    }
+                }
             }
 
+            GitNodeMessage::FindPrimary(header, reply) => {
+                let entry = state.repos.get(&header.relative_path);
+                let is_primary = entry.is_some_and(|e| e.role == ROLE_PRIMARY);
+                reply.send(build_decision(state, &header, is_primary, entry.map(|e| e.role.as_str()))).ok();
+            }
+
+            GitNodeMessage::FindReplica(header, reply) => {
+                let entry = state.repos.get(&header.relative_path);
+                let has = entry.is_some();
+                reply.send(build_decision(state, &header, has, entry.map(|e| e.role.as_str()))).ok();
+            }
+
+
             GitNodeMessage::ListRepositoryPaths(reply) => {
-                let paths: Vec<String> = state.registered_repos.iter().cloned().collect();
+                let paths: Vec<String> = state.repos.keys().cloned().collect();
                 reply.send(paths.join("\n")).ok();
             }
 
             GitNodeMessage::RepositoryExists(header, reply) => {
-                reply.send(state.registered_repos.contains(&header.relative_path)).ok();
+                reply.send(state.repos.contains_key(&header.relative_path)).ok();
             }
 
             GitNodeMessage::GetNodeHealth(reply) => {
                 reply.send(NodeHealth {
                     storage_name: state.storage_name.clone(),
-                    repo_count: state.registered_repos.len() as u64,
+                    repo_count: state.repos.len() as u64,
                     healthy: true,
                     version: self.version.clone(),
                 }).ok();
@@ -151,19 +162,48 @@ impl Actor for GitNodeActor {
     }
 }
 
+fn build_decision(state: &GitNodeState, header: &crate::pb::RepositoryHeader, found: bool, role: Option<&str>) -> RouteDecision {
+    RouteDecision {
+        found,
+        storage_name: if found { state.storage_name.clone() } else { String::new() },
+        relative_path: header.relative_path.clone(),
+        actor_name: if found { state.actor_name.clone() } else { String::new() },
+        grpc_addr: if found { state.grpc_addr.clone() } else { String::new() },
+        role: role.unwrap_or("").to_string(),
+    }
+}
+
 fn register_repo(myself: &ActorRef<GitNodeMessage>, state: &mut GitNodeState, relative_path: String) {
+    if state.repos.contains_key(&relative_path) {
+        return;
+    }
+
+    let role = if is_path_registered_elsewhere(&state.storage_name, &relative_path) {
+        ROLE_REPLICA.to_string()
+    } else {
+        ROLE_PRIMARY.to_string()
+    };
+
     let category = extract_category(&relative_path);
     pg::join_scoped(state.storage_name.clone(), category.to_string(), vec![myself.get_cell()]);
-    state.registered_repos.insert(relative_path.clone());
+    state.repos.insert(relative_path.clone(), RepoEntry {
+        role: role.clone(),
+        last_commit: String::new(),
+    });
     tracing::info!(
         storage_name = %state.storage_name,
         category = %category,
         relative_path = %relative_path,
         actor_name = %state.actor_name,
+        role = %role,
         "repository route registered"
     );
 }
 
+fn is_path_registered_elsewhere(_storage_name: &str, _relative_path: &str) -> bool {
+    false
+}
+
 fn extract_category(relative_path: &str) -> &str {
     relative_path.split('/').next().unwrap_or("root")
 }
@@ -191,10 +231,21 @@ pub fn get_category_members(storage_name: &str, category: &str) -> Vec<ractor::A
     pg::get_scoped_members(&storage_name.to_string(), &category.to_string())
 }
 
-pub fn route_group_for(header: &RepositoryHeader) -> String {
+pub fn route_group_for(header: &crate::pb::RepositoryHeader) -> String {
     extract_category(&header.relative_path).to_string()
 }
 
 pub fn list_all_groups() -> Vec<String> {
     pg::which_groups()
 }
+
+pub fn broadcast_ref_update(
+    _node_actor: &ActorRef<GitNodeMessage>,
+    event: RefUpdateEvent,
+) {
+    let members = ractor::pg::get_members(&"gitks_nodes".to_string());
+    for member in members {
+        let actor_ref: ActorRef<GitNodeMessage> = member.into();
+        actor_ref.cast(GitNodeMessage::RefUpdated(event.clone())).ok();
+    }
+}