homeboy 0.76.0

CLI for multi-component deployment and development workflow automation
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use crate::engine::temp;
use crate::Error;
use std::collections::{BTreeMap, BTreeSet};
use std::path::{Path, PathBuf};

pub struct SandboxDir {
    path: PathBuf,
}

impl SandboxDir {
    pub fn path(&self) -> &Path {
        &self.path
    }
}

impl Drop for SandboxDir {
    fn drop(&mut self) {
        let _ = std::fs::remove_dir_all(&self.path);
    }
}

pub fn clone_tree(src: &Path) -> crate::Result<SandboxDir> {
    let temp = temp::runtime_temp_dir("homeboy-refactor-ci")?;
    copy_dir_recursive(src, &temp)?;
    Ok(SandboxDir { path: temp })
}

pub fn copy_changed_files(
    src_root: &Path,
    dst_root: &Path,
    changed_files: &[String],
) -> crate::Result<()> {
    for file in changed_files {
        let src = src_root.join(file);
        let dst = dst_root.join(file);

        if let Some(parent) = dst.parent() {
            std::fs::create_dir_all(parent).map_err(|e| {
                Error::internal_io(e.to_string(), Some(format!("create parent for {}", file)))
            })?;
        }

        std::fs::copy(&src, &dst).map_err(|e| {
            Error::internal_io(e.to_string(), Some(format!("copy changed file {}", file)))
        })?;
    }

    Ok(())
}

pub fn snapshot_tree(root: &str) -> crate::Result<BTreeMap<String, u64>> {
    let root_path = Path::new(root);
    let mut files = BTreeMap::new();
    snapshot_tree_recursive(root_path, root_path, &mut files)?;
    Ok(files)
}

pub fn diff_tree_snapshots(
    before: &BTreeMap<String, u64>,
    after: &BTreeMap<String, u64>,
) -> Vec<String> {
    let mut changed = BTreeSet::new();

    for (file, size) in after {
        if before.get(file) != Some(size) {
            changed.insert(file.clone());
        }
    }

    for file in before.keys() {
        if !after.contains_key(file) {
            changed.insert(file.clone());
        }
    }

    changed.into_iter().collect()
}

fn snapshot_tree_recursive(
    root: &Path,
    dir: &Path,
    files: &mut BTreeMap<String, u64>,
) -> crate::Result<()> {
    for entry in std::fs::read_dir(dir)
        .map_err(|e| Error::internal_io(e.to_string(), Some("read sandbox dir".to_string())))?
    {
        let entry = entry.map_err(|e| {
            Error::internal_io(e.to_string(), Some("read sandbox entry".to_string()))
        })?;
        let path = entry.path();

        if path.is_dir() {
            snapshot_tree_recursive(root, &path, files)?;
            continue;
        }

        let relative = path
            .strip_prefix(root)
            .map_err(|e| {
                Error::internal_io(e.to_string(), Some("strip sandbox prefix".to_string()))
            })?
            .to_string_lossy()
            .replace('\\', "/");
        let metadata = std::fs::metadata(&path).map_err(|e| {
            Error::internal_io(e.to_string(), Some("stat sandbox file".to_string()))
        })?;
        files.insert(relative, metadata.len());
    }

    Ok(())
}

fn copy_dir_recursive(src: &Path, dst: &Path) -> crate::Result<()> {
    std::fs::create_dir_all(dst)
        .map_err(|e| Error::internal_io(e.to_string(), Some("create sandbox dir".to_string())))?;

    for entry in std::fs::read_dir(src)
        .map_err(|e| Error::internal_io(e.to_string(), Some("read source dir".to_string())))?
    {
        let entry = entry
            .map_err(|e| Error::internal_io(e.to_string(), Some("read dir entry".to_string())))?;
        let src_path = entry.path();
        let dst_path = dst.join(entry.file_name());

        if src_path.is_dir() {
            if entry.file_name() == ".git" {
                continue;
            }
            copy_dir_recursive(&src_path, &dst_path)?;
        } else {
            std::fs::copy(&src_path, &dst_path).map_err(|e| {
                Error::internal_io(e.to_string(), Some("copy sandbox file".to_string()))
            })?;
        }
    }

    Ok(())
}