drifter 0.1.11

A TUI-based S3 multipart uploader featuring resumable transfers and ClamAV integration.
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 crate::core::config::Config;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SettingsCategory {
    S3,
    Scanner,
    Performance,
    Theme,
}

pub struct SettingsState {
    pub endpoint: String,
    pub bucket: String,
    pub region: String,
    pub prefix: String,
    pub access_key: String,
    pub secret_key: String,
    pub clamd_host: String,
    pub clamd_port: String,
    pub scan_chunk_size: String,
    pub part_size: String,
    pub concurrency_global: String,
    pub concurrency_upload_parts: String,
    pub concurrency_scan_parts: String,
    pub active_category: SettingsCategory,
    pub selected_field: usize,
    pub editing: bool,
    pub theme: String,
    pub original_theme: Option<String>,
    pub scanner_enabled: bool,
    pub host_metrics_enabled: bool,
    pub delete_source_after_upload: bool,
}

impl SettingsState {
    pub fn from_config(cfg: &Config) -> Self {
        Self {
            endpoint: cfg.s3_endpoint.clone().unwrap_or_default(),
            bucket: cfg.s3_bucket.clone().unwrap_or_default(),
            region: cfg.s3_region.clone().unwrap_or_default(),
            prefix: cfg.s3_prefix.clone().unwrap_or_default(),
            access_key: cfg.s3_access_key.clone().unwrap_or_default(),
            secret_key: cfg.s3_secret_key.clone().unwrap_or_default(),
            clamd_host: cfg.clamd_host.clone(),
            clamd_port: cfg.clamd_port.to_string(),
            scan_chunk_size: cfg.scan_chunk_size_mb.to_string(),
            part_size: cfg.part_size_mb.to_string(),
            concurrency_global: cfg.concurrency_upload_global.to_string(),
            concurrency_upload_parts: cfg.concurrency_upload_parts.to_string(),
            concurrency_scan_parts: cfg.concurrency_scan_parts.to_string(),
            active_category: SettingsCategory::S3,
            selected_field: 0,
            editing: false,
            theme: cfg.theme.clone(),
            original_theme: None,
            scanner_enabled: cfg.scanner_enabled,
            host_metrics_enabled: cfg.host_metrics_enabled,
            delete_source_after_upload: cfg.delete_source_after_upload,
        }
    }

    pub fn apply_to_config(&self, cfg: &mut Config) {
        cfg.s3_endpoint = if self.endpoint.trim().is_empty() {
            None
        } else {
            Some(self.endpoint.trim().to_string())
        };
        cfg.s3_bucket = if self.bucket.trim().is_empty() {
            None
        } else {
            Some(self.bucket.trim().to_string())
        };
        cfg.s3_region = if self.region.trim().is_empty() {
            None
        } else {
            Some(self.region.trim().to_string())
        };
        cfg.s3_prefix = if self.prefix.trim().is_empty() {
            None
        } else {
            Some(self.prefix.trim().to_string())
        };
        cfg.s3_access_key = if self.access_key.trim().is_empty() {
            None
        } else {
            Some(self.access_key.trim().to_string())
        };
        cfg.s3_secret_key = if self.secret_key.trim().is_empty() {
            None
        } else {
            Some(self.secret_key.trim().to_string())
        };
        cfg.clamd_host = self.clamd_host.trim().to_string();
        if let Ok(p) = self.clamd_port.trim().parse() {
            cfg.clamd_port = p;
        }
        if let Ok(v) = self.scan_chunk_size.trim().parse() {
            cfg.scan_chunk_size_mb = v;
        }
        if let Ok(v) = self.part_size.trim().parse() {
            cfg.part_size_mb = v;
        }
        if let Ok(v) = self.concurrency_global.trim().parse() {
            cfg.concurrency_upload_global = v;
        }
        if let Ok(v) = self.concurrency_upload_parts.trim().parse() {
            cfg.concurrency_upload_parts = v;
        }
        if let Ok(v) = self.concurrency_scan_parts.trim().parse() {
            cfg.concurrency_scan_parts = v;
        }
        cfg.theme = self.theme.clone();
        cfg.scanner_enabled = self.scanner_enabled;
        cfg.host_metrics_enabled = self.host_metrics_enabled;
        cfg.delete_source_after_upload = self.delete_source_after_upload;
    }
}