mars-xlog-core 0.1.0

Core runtime building blocks for the Rust-native xlog engine.
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

use std::ffi::OsStr;
use std::fs;
use std::path::Path;

use chrono::Local;

use crate::file_naming::{
    build_path_for_index, day_key, make_date_prefix_from_day_key, LOG_EXT_WITH_DOT,
};
use crate::file_ops::local_file_state;
use crate::file_runtime::AppendTargetCache;

pub(crate) fn resolve_append_target(
    log_dir: &Path,
    cache_dir: Option<&Path>,
    now: chrono::DateTime<Local>,
    dir: &Path,
    prefix: &str,
    max_file_size: u64,
) -> AppendTargetCache {
    let day_key = day_key(now);
    let date_prefix = make_date_prefix_from_day_key(prefix, day_key);
    let (idx, merged_len) = if max_file_size == 0 {
        let path = build_path_for_index(dir, prefix, day_key, 0);
        let (local_exists, local_len) = local_file_state(&path);
        return AppendTargetCache {
            path,
            day_key,
            file_index: 0,
            merged_len: local_len,
            local_len,
            local_exists,
        };
    } else {
        next_file_index_state(log_dir, cache_dir, &date_prefix, max_file_size)
    };

    let path = build_path_for_index(dir, prefix, day_key, idx);
    let (local_exists, local_len) = local_file_state(&path);
    AppendTargetCache {
        path,
        day_key,
        file_index: idx,
        merged_len,
        local_len,
        local_exists,
    }
}

fn next_file_index_state(
    log_dir: &Path,
    cache_dir: Option<&Path>,
    date_prefix: &str,
    max_file_size: u64,
) -> (i64, u64) {
    let mut names = get_file_names_by_prefix(log_dir, date_prefix);
    if let Some(cache_dir) = cache_dir {
        names.extend(get_file_names_by_prefix(cache_dir, date_prefix));
    }
    if names.is_empty() {
        return (0, 0);
    }

    names.sort_by(|a, b| {
        if a.len() == b.len() {
            b.cmp(a)
        } else {
            b.len().cmp(&a.len())
        }
    });
    let last = &names[0];

    let mut idx = 0i64;
    if let Some(base) = last.strip_suffix(LOG_EXT_WITH_DOT) {
        if let Some(rest) = base.strip_prefix(date_prefix) {
            let rest = rest.strip_prefix('_').unwrap_or(rest);
            idx = rest.parse::<i64>().unwrap_or(0);
        }
    }

    let mut merged_size = 0u64;
    let log_path = log_dir.join(last);
    if let Ok(meta) = fs::metadata(&log_path) {
        merged_size = merged_size.saturating_add(meta.len());
    }
    if let Some(cache_dir) = cache_dir {
        let cache_path = cache_dir.join(last);
        if let Ok(meta) = fs::metadata(&cache_path) {
            merged_size = merged_size.saturating_add(meta.len());
        }
    }
    if merged_size > max_file_size {
        (idx + 1, 0)
    } else {
        (idx, merged_size)
    }
}

fn get_file_names_by_prefix(dir: &Path, file_prefix: &str) -> Vec<String> {
    let mut out = Vec::new();
    let Ok(entries) = fs::read_dir(dir) else {
        return out;
    };
    for entry in entries.flatten() {
        let path = entry.path();
        if !path.is_file() {
            continue;
        }
        let Some(name) = path.file_name().and_then(OsStr::to_str) else {
            continue;
        };
        if name.starts_with(file_prefix) && name.ends_with(LOG_EXT_WITH_DOT) {
            out.push(name.to_string());
        }
    }
    out
}