bpm_core 0.1.0

Cross-platform software helping to verify, prove and secure package compilation, building, fetching, and deployment. Core package.
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

use std::{
    fs,
    os::unix::fs::MetadataExt,
    path::{Path, PathBuf},
};

use log::{debug, trace};
use walkdir::WalkDir;

/**
 * Returns whether file is an executable or not
 */
fn is_executable(metadata: &fs::Metadata) -> bool {
    metadata.is_file() && metadata.mode() & 0o111 != 0
}

/**
 * Find all executables in given directory and its subdirectories
 */
pub fn find_executables(directory: &Path) -> Result<Vec<PathBuf>, Box<dyn std::error::Error>> {
    debug!(
        "Searching executables in {}...",
        directory.to_path_buf().display()
    );
    let mut executables_paths = vec![];
    for entry in WalkDir::new(directory) {
        let entry = entry?;

        let entry_metadata = entry.metadata()?;

        let entry_path = entry.into_path().clone();

        if is_executable(&entry_metadata) {
            trace!("Found executable at {}", entry_path.display());
            executables_paths.push(entry_path);
        }
    }

    debug!("Done finding executables !");
    Ok(executables_paths)
}

#[cfg(test)]
mod tests {
    use super::*;
    use fs::File;
    use std::os::unix::fs::PermissionsExt;
    use tempfile::TempDir;

    /**
     * It should return false if not executable
     */
    #[test]
    fn test_executable_on_non_executable_file() -> Result<(), Box<dyn std::error::Error>> {
        let expected_executable_state = false;

        let test_dir = TempDir::new().unwrap();

        let file_path = test_dir.path().join("non_executable");

        // Create the file
        File::create(&file_path)?;

        let metadata = fs::metadata(file_path)?;
        let executable = is_executable(&metadata);

        assert_eq!(executable, expected_executable_state);

        Ok(())
    }

    /**
     * It should return true if executable
     */
    #[test]
    fn test_executable_on_executable_file() -> Result<(), Box<dyn std::error::Error>> {
        let expected_executable_state = true;

        let test_dir = TempDir::new().unwrap();

        let file_path = test_dir.path().join("executable");

        // Create the file
        let file = File::create(&file_path)?;

        // Set permissions to make the file executable
        let mut permissions = file.metadata()?.permissions();
        permissions.set_mode(0o755);
        fs::set_permissions(&file_path, permissions)?;

        let metadata = fs::metadata(file_path)?;
        let executable = is_executable(&metadata);

        assert_eq!(executable, expected_executable_state);

        Ok(())
    }

    /**
     * It should return only executable files
     */
    #[test]
    fn test_find_executable_files() -> Result<(), Box<dyn std::error::Error>> {
        let test_dir = TempDir::new().unwrap();

        let file_path_one = test_dir.path().join("executable_1");
        let file_path_two = test_dir.path().join("executable_2");
        let file_path_three = test_dir.path().join("non_executable");

        // Create the files
        let file_one = File::create(&file_path_one)?;
        let file_two = File::create(&file_path_two)?;
        File::create(&file_path_three)?;

        let expected_executable_files = vec![file_path_one.clone(), file_path_two.clone()];

        // Set permissions to make the files executable
        let mut permissions = file_one.metadata()?.permissions();
        permissions.set_mode(0o755);
        fs::set_permissions(&file_path_one, permissions)?;

        permissions = file_two.metadata()?.permissions();
        permissions.set_mode(0o755);
        fs::set_permissions(&file_path_two, permissions)?;

        let executable_files = find_executables(test_dir.path())?;

        assert_eq!(expected_executable_files, executable_files);

        Ok(())
    }
}