lakestream 0.0.2

Portable file-utility for object-stores
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

use std::fs;
use std::path::Path;

use crate::{FileObject, FileObjectFilter};

pub fn list_files(
    path: &Path,
    max_keys: Option<u32>,
    recursive: bool,
    filter: &Option<FileObjectFilter>,
) -> Vec<FileObject> {
    let mut file_objects = Vec::new();
    list_files_next(path, max_keys, recursive, filter, &mut file_objects);
    file_objects
}

fn handle_file(
    entry: &fs::DirEntry,
    filter: &Option<FileObjectFilter>,
    file_objects: &mut Vec<FileObject>,
) -> u32 {
    let metadata = match entry.metadata() {
        Ok(md) => md,
        Err(_) => return 0,
    };

    let file_name = entry.path().to_string_lossy().to_string();
    let file_size = metadata.len();
    let modified = metadata.modified().ok().map(|mtime| {
        mtime
            .duration_since(std::time::UNIX_EPOCH)
            .map(|duration| duration.as_secs())
            .unwrap_or(0)
    });

    let file_object = FileObject::new(file_name, file_size, modified, None);

    // Check if the file_object satisfies the filter conditions
    if let Some(ref filter) = filter {
        if !filter.matches(&file_object) {
            return 0;
        }
    }

    file_objects.push(file_object);
    1
}

fn handle_directory(
    entry: &fs::DirEntry,
    max_keys: Option<u32>,
    recursive: bool,
    filter: &Option<FileObjectFilter>,
    file_objects: &mut Vec<FileObject>,
) -> u32 {
    let dir_name = entry.path().to_string_lossy().to_string();

    // Only add directory object when no filter is provided
    if filter.is_none() {
        let dir_object = FileObject::new(dir_name, 0, None, None);
        file_objects.push(dir_object);
    }

    if !recursive {
        return 1;
    }

    list_files_next(
        entry.path().as_path(),
        max_keys,
        recursive,
        filter,
        file_objects,
    ) + 1
}

fn list_files_next(
    path: &Path,
    max_keys: Option<u32>,
    recursive: bool,
    filter: &Option<FileObjectFilter>,
    file_objects: &mut Vec<FileObject>,
) -> u32 {
    let mut count = 0;

    if let Ok(entries) = fs::read_dir(path) {
        for entry in entries.flatten() {
            if let Some(max_keys) = max_keys {
                if file_objects.len() >= max_keys as usize {
                    break;
                }
            }

            let metadata = match entry.metadata() {
                Ok(md) => md,
                Err(_) => continue,
            };

            if metadata.is_file() {
                count += handle_file(&entry, filter, file_objects);
            } else if metadata.is_dir() {
                count += handle_directory(
                    &entry,
                    max_keys,
                    recursive,
                    filter,
                    file_objects,
                );
            }
        }
    }
    count
}