refactor(actor): implement Raft consensus algorithm for cluster leader election

- Add voting mechanism with term tracking and vote persistence
- Implement election triggering logic with majority vote counting
- Add primary/replica role transition handling with state management
- Integrate health check failure detection for automatic elections
- Refactor actor messaging system for distributed coordination
- Update repository registration to query cluster for existing primary
- Add broadcast mechanism for role change notifications
- Implement proper term comparison and duplicate request filtering
- Upgrade dependency versions including tokio-util for async utilities
- Optimize code formatting and line wrapping for improved readability
- Remove redundant blank lines and improve code structure consistency
- Enhance error logging and trace information for debugging purposes

pack_cache.rs

@@ -26,11 +26,15 @@ pub const INFO_REFS_NAMESPACE: &str = "+gitks-cache/info_refs";
 #[derive(Debug, Clone)]
 pub struct PackCache {
     disk_cache: DiskCache,
+    backpressure_enabled: bool,
 }
 
 impl PackCache {
-    pub fn new(disk_cache: DiskCache, _backpressure: bool) -> Self {
-        Self { disk_cache }
+    pub fn new(disk_cache: DiskCache, backpressure: bool) -> Self {
+        Self {
+            disk_cache,
+            backpressure_enabled: backpressure,
+        }
     }
 
     pub fn is_enabled(&self) -> bool {
@@ -63,7 +67,8 @@ impl PackCache {
 
         tracing::info!(digest = %digest, "pack-objects cache hit, streaming from disk");
 
-        let (tx, rx) = tokio::sync::mpsc::channel(16);
+        let channel_size = if self.backpressure_enabled { 4 } else { 256 };
+        let (tx, rx) = tokio::sync::mpsc::channel(channel_size);
 
         let sender = tx.clone();
         tokio::spawn(async move {
@@ -104,12 +109,15 @@ impl PackCache {
 
     /// Stream pack-objects output while simultaneously writing to cache.
     /// This is the "tee" approach: data flows to both the client and the cache file.
+    /// When backpressure is enabled, uses a small channel to slow the producer
+    /// if the consumer is slow. Otherwise uses a large channel for max throughput.
     pub fn tee_pack_stream(
         &self,
         digest: &str,
         source: ReceiverStream<Result<PackfileChunk, tonic::Status>>,
     ) -> ReceiverStream<Result<PackfileChunk, tonic::Status>> {
-        let (tx, rx) = tokio::sync::mpsc::channel(16);
+        let channel_size = if self.backpressure_enabled { 4 } else { 256 };
+        let (tx, rx) = tokio::sync::mpsc::channel(channel_size);
 
         if !self.is_enabled() {
             tokio::spawn(async move {