actr-cli 0.3.1

Command line tool for Actor-RTC framework projects
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

//! Default FingerprintValidator implementation

use anyhow::Result;
use async_trait::async_trait;
use sha2::{Digest, Sha256};
use std::io::Read;
use std::path::Path;
use walkdir::WalkDir;

use super::{Fingerprint, FingerprintValidator, ResolvedDependency, ServiceInfo};

/// Default fingerprint validator
pub struct DefaultFingerprintValidator;

impl DefaultFingerprintValidator {
    pub fn new() -> Self {
        Self
    }

    /// Compute SHA256 of a file's content
    fn hash_file(path: &Path) -> Result<Vec<u8>> {
        let mut hasher = Sha256::new();
        let mut file = std::fs::File::open(path)?;
        let mut buffer = [0u8; 8192];

        loop {
            let count = file.read(&mut buffer)?;
            if count == 0 {
                break;
            }
            hasher.update(&buffer[..count]);
        }

        Ok(hasher.finalize().to_vec())
    }
}

impl Default for DefaultFingerprintValidator {
    fn default() -> Self {
        Self::new()
    }
}

#[async_trait]
impl FingerprintValidator for DefaultFingerprintValidator {
    async fn compute_service_fingerprint(&self, service: &ServiceInfo) -> Result<Fingerprint> {
        Ok(Fingerprint {
            algorithm: "sha256".to_string(),
            value: service.fingerprint.clone(),
        })
    }

    async fn verify_fingerprint(
        &self,
        expected: &Fingerprint,
        actual: &Fingerprint,
    ) -> Result<bool> {
        Ok(expected.algorithm == actual.algorithm && expected.value == actual.value)
    }

    async fn compute_project_fingerprint(&self, project_path: &Path) -> Result<Fingerprint> {
        let mut hasher = Sha256::new();
        let mut proto_files: Vec<_> = WalkDir::new(project_path)
            .into_iter()
            .filter_map(|e| e.ok())
            .filter(|e| e.path().extension().and_then(|s| s.to_str()) == Some("proto"))
            .collect();

        // Sort files to ensure deterministic hash
        proto_files.sort_by(|a, b| a.path().cmp(b.path()));

        for entry in proto_files {
            let file_hash = Self::hash_file(entry.path())?;
            hasher.update(&file_hash);
        }

        Ok(Fingerprint {
            algorithm: "sha256".to_string(),
            value: hex::encode(hasher.finalize()),
        })
    }

    async fn generate_lock_fingerprint(&self, deps: &[ResolvedDependency]) -> Result<Fingerprint> {
        let mut hasher = Sha256::new();
        let mut dep_names: Vec<_> = deps.iter().map(|d| &d.spec.name).collect();
        dep_names.sort();

        for name in dep_names {
            hasher.update(name.as_bytes());
            if let Some(dep) = deps.iter().find(|d| d.spec.name == *name) {
                hasher.update(dep.fingerprint.as_bytes());
            }
        }

        Ok(Fingerprint {
            algorithm: "sha256".to_string(),
            value: hex::encode(hasher.finalize()),
        })
    }
}