Yoda 0.11.2

Browser for Gemini Protocol
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

pub mod auth;

use anyhow::{bail, Result};
pub use auth::Auth;
use std::{collections::HashMap, sync::RwLock};

/// Reduce disk usage by cache Auth index in memory
pub struct Memory {
    index: RwLock<HashMap<String, i64>>,
}

impl Default for Memory {
    fn default() -> Self {
        Self::new()
    }
}

impl Memory {
    // Constructors

    /// Create new `Self`
    pub fn new() -> Self {
        Self {
            index: RwLock::new(HashMap::new()),
        }
    }

    // Actions

    /// Add new record with `scope` as key and `profile_identity_id` as value
    /// * validate record with same key does not exist yet
    pub fn add(&self, scope: String, profile_identity_id: i64) -> Result<()> {
        // Borrow shared index access
        let mut index = self.index.write().unwrap();

        // Prevent existing key overwrite
        if index.contains_key(&scope) {
            bail!("Overwrite attempt for existing record `{scope}`")
        }

        // Slot should be free, let check it twice
        match index.insert(scope, profile_identity_id) {
            Some(_) => bail!("Unexpected error"),
            None => Ok(()),
        }
    }

    /// Cleanup index
    pub fn clear(&self) -> Result<()> {
        let mut index = self.index.write().unwrap();
        index.clear();
        if index.is_empty() {
            Ok(())
        } else {
            bail!("Could not cleanup memory index")
        }
    }

    /// Get identity exactly match `scope`
    /// * [Client certificates specification](https://geminiprotocol.net/docs/protocol-specification.gmi#client-certificates)
    /// * see also parent `is_match_request`
    pub fn match_scope(&self, scope: &str) -> Option<Auth> {
        let mut result = Vec::new();

        for (value, &profile_identity_id) in self.index.read().unwrap().iter() {
            if scope.starts_with(value) {
                result.push(Auth {
                    profile_identity_id,
                    scope: value.clone(),
                })
            }
        }

        // Sort by length desc @TODO
        result.sort_by(|a, b| b.scope.len().cmp(&a.scope.len()));

        // Get first copy
        result.first().cloned()
    }

    /// Get identity exactly match `scope`
    /// * [Client certificates specification](https://geminiprotocol.net/docs/protocol-specification.gmi#client-certificates)
    /// * see also parent `is_match_request`
    pub fn total(&self, profile_identity_id: i64) -> usize {
        let mut total = 0;
        for (_, _profile_identity_id) in self.index.read().unwrap().iter() {
            if *_profile_identity_id == profile_identity_id {
                total += 1
            }
        }
        total
    }
}