stigmerge 0.5.13

Anonymous decentralized file distribution and transfer
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
139
140
141
142
143
144
145
146
147
148

use std::{io::IsTerminal, path::PathBuf};

use anyhow::{Error, Result};
use clap::{arg, Parser, Subcommand};
use sha2::{Digest, Sha256};

use crate::share;

#[derive(Parser, Debug)]
#[command(name = "stigmerge")]
#[command(bin_name = "stigmerge")]
pub struct Cli {
    #[arg(long, env)]
    pub no_ui: bool,

    #[arg(long, env)]
    pub state_dir: Option<String>,

    #[command(subcommand)]
    pub commands: Commands,
}

impl Cli {
    pub fn no_ui(&self) -> bool {
        return self.no_ui || !std::io::stdout().is_terminal();
    }

    pub fn state_dir(&self) -> Result<String> {
        if let Some(s) = &self.state_dir {
            return Ok(s.to_owned());
        }
        match self.commands {
            Commands::Fetch {
                ref share_keys,
                ref index_digest,
                ref output_path,
                ..
            } => {
                if share_keys.len() == 0 {
                    return Err(Error::msg("at least one share key must be provided"));
                }
                let key_match = match index_digest {
                    Some(digest) => digest,
                    None => &share_keys[0],
                };
                self.state_dir_for(format!(
                    "get:{}:{}",
                    key_match,
                    output_path.to_string_lossy()
                ))
            }
            Commands::Seed { ref path } => {
                self.state_dir_for(format!("seed:{}", path.to_string_lossy()))
            }
            _ => Err(Error::msg("invalid command")),
        }
    }

    pub fn state_dir_for(&self, key: String) -> Result<String> {
        let mut key_digest = Sha256::new();
        key_digest.update(&key.as_bytes());
        let key_digest_bytes: [u8; 32] = key_digest.finalize().into();
        let dir_name = hex::encode(key_digest_bytes);
        let data_dir = dirs::state_dir()
            .or(dirs::data_local_dir())
            .ok_or(Error::msg("cannot resolve state dir"))?;
        let state_dir = data_dir
            .join("stigmerge")
            .join(dir_name)
            .into_os_string()
            .into_string()
            .map_err(|os| Error::msg(format!("{:?}", os)))?;
        Ok(state_dir)
    }

    pub fn version(&self) -> bool {
        if let Commands::Version = self.commands {
            return true;
        }
        return false;
    }
}

#[derive(Subcommand, Debug)]
pub enum Commands {
    Fetch {
        share_keys: Vec<String>,

        #[arg(long = "index-digest", short = 'i')]
        index_digest: Option<String>,

        #[arg(long = "output-path", short = 'o', default_value = ".")]
        output_path: PathBuf,

        #[arg(long = "fetchers", short = 'n', default_value = "50")]
        fetchers: usize,
    },
    Seed {
        path: PathBuf,
    },
    Version,
}

impl Commands {
    pub fn share_args(&self) -> Result<(share::Mode, share::Config)> {
        Ok(match self {
            Commands::Fetch {
                share_keys: share_key_strings,
                index_digest,
                output_path,
                fetchers,
            } => {
                let want_index_digest = match index_digest {
                    Some(digest_string) => {
                        let digest = hex::decode(digest_string)?;
                        Some(
                            digest
                                .try_into()
                                .map_err(|_| Error::msg("invalid digest length"))?,
                        )
                    }
                    None => None,
                };
                let mut share_keys = vec![];
                for share_key_string in share_key_strings {
                    share_keys.push(share_key_string.parse()?);
                }
                (
                    share::Mode::Fetch {
                        root: output_path.into(),
                        want_index_digest,
                        share_keys,
                    },
                    share::Config {
                        n_fetchers: TryInto::<u8>::try_into(*fetchers)?,
                    },
                )
            }
            Commands::Seed { path } => (
                share::Mode::Seed {
                    path: path.to_owned(),
                },
                share::Config::default(),
            ),
            Commands::Version => return Err(Error::msg("invalid command")),
        })
    }
}