Yoda 0.10.11

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
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
149
150
151
152
153
154
155
156
157
158

mod auth;
mod certificate;
mod database;
mod error;
mod item;
mod memory;

use auth::Auth;
use database::Database;
pub use error::Error;
use item::Item;

use memory::Memory;

use gtk::glib::DateTime;
use sqlite::{Connection, Transaction};
use std::{rc::Rc, sync::RwLock};

/// Authorization wrapper for Gemini protocol
///
/// https://geminiprotocol.net/docs/protocol-specification.gmi#client-certificates
pub struct Identity {
    pub auth: Rc<Auth>,
    pub database: Rc<Database>,
    pub memory: Rc<Memory>,
}

impl Identity {
    // Constructors

    /// Create new `Self`
    pub fn build(
        connection: &Rc<RwLock<Connection>>,
        profile_identity_id: &Rc<i64>,
    ) -> Result<Self, Error> {
        // Init components
        let auth = match Auth::build(connection) {
            Ok(auth) => Rc::new(auth),
            Err(e) => return Err(Error::Auth(e)),
        };
        let database = Rc::new(Database::build(connection, profile_identity_id));
        let memory = Rc::new(Memory::new());

        // Init `Self`
        let this = Self {
            auth,
            database,
            memory,
        };

        // Build initial index
        Self::index(&this)?;

        Ok(this)
    }

    // Actions

    /// Add new record to database, update memory index
    /// * return new `profile_identity_id` on success
    pub fn add(&self, pem: &str) -> Result<i64, Error> {
        match self.database.add(pem) {
            Ok(profile_identity_id) => {
                self.index()?;
                Ok(profile_identity_id)
            }
            Err(e) => Err(Error::Database(e)),
        }
    }

    /// Delete record from database including children dependencies, update memory index
    pub fn delete(&self, profile_identity_id: i64) -> Result<(), Error> {
        match self.auth.remove_ref(profile_identity_id) {
            Ok(_) => match self.database.delete(profile_identity_id) {
                Ok(_) => {
                    self.index()?;
                    Ok(())
                }
                Err(e) => Err(Error::Database(e)),
            },
            Err(e) => Err(Error::Auth(e)),
        }
    }

    /// Generate new certificate and insert record to DB, update memory index
    /// * return new `profile_identity_id` on success
    pub fn make(&self, time: Option<(DateTime, DateTime)>, name: &str) -> Result<i64, Error> {
        // Generate new certificate
        match certificate::generate(
            match time {
                Some(value) => value,
                None => (
                    DateTime::now_local().unwrap(),
                    DateTime::from_local(9999, 12, 31, 23, 59, 59.9).unwrap(), // max @TODO
                ),
            },
            name,
        ) {
            Ok(pem) => self.add(&pem),
            Err(e) => Err(Error::Certificate(e)),
        }
    }

    /// Create new `Memory` index from `Database` for `Self`
    pub fn index(&self) -> Result<(), Error> {
        // Clear previous records
        if let Err(e) = self.memory.clear() {
            return Err(Error::Memory(e));
        }

        // Build new index
        match self.database.records() {
            Ok(records) => {
                for record in records {
                    if let Err(e) = self.memory.add(record.id, record.pem) {
                        return Err(Error::Memory(e));
                    }
                }
            }
            Err(e) => return Err(Error::Database(e)),
        };

        Ok(())
    }

    /// Get `Identity` match `request`
    /// * [Client certificates specification](https://geminiprotocol.net/docs/protocol-specification.gmi#client-certificates)
    /// * this function work with memory cache (not database)
    pub fn get(&self, request: &str) -> Option<Item> {
        if let Some(auth) = self.auth.get(request) {
            match self.memory.get(auth.profile_identity_id) {
                Ok(pem) => {
                    return Some(Item {
                        // scope: auth.scope,
                        pem,
                    });
                }
                Err(e) => todo!("{e}"),
            }
        }
        None
    }
}

// Tools

pub fn migrate(tx: &Transaction) -> Result<(), String> {
    // Migrate self components
    if let Err(e) = database::init(tx) {
        return Err(e.to_string());
    }

    // Delegate migration to childs
    auth::migrate(tx)?;

    // Success
    Ok(())
}