iris-chat 0.1.67

Iris Chat command line client and shared encrypted chat core
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

use super::*;

pub(super) fn new_ffi_app_inner(data_dir: String) -> Arc<FfiApp> {
    let (update_tx, update_rx) = flume::unbounded();
    let (foreground_tx, foreground_rx) = flume::unbounded();
    let (background_tx, background_rx) = flume::unbounded();
    let (completion, core_stopped) = flume::bounded(1);
    let shared_state = Arc::new(RwLock::new(AppState::empty()));
    let queue_metrics = Arc::new(CoreQueueMetrics::default());
    let recovery = Arc::new(CoreRecoveryState::default());
    let shared_db = Arc::new(RwLock::new(None));
    let shared_user_profiles: user_profile::SharedUserProfiles = Default::default();
    let mut core_worker = None;

    let update_tx_for_error = update_tx.clone();
    match AppCore::try_new_with_priority_sender(
        update_tx.clone(),
        background_tx.clone(),
        foreground_tx.clone(),
        data_dir.clone(),
        shared_state.clone(),
    ) {
        Ok(mut core) => {
            core.startup_restore = Arc::clone(&recovery.startup_restore);
            core.set_shared_user_profiles(Arc::clone(&shared_user_profiles));
            set_shared_db(&shared_db, Some(core.shared_db()));
            let spawn_result = spawn_core_supervisor(
                core,
                CoreSupervisor {
                    data_dir,
                    update_tx: update_tx.clone(),
                    core_sender: background_tx.clone(),
                    priority_sender: foreground_tx.clone(),
                    foreground_rx: foreground_rx.clone(),
                    background_rx: background_rx.clone(),
                    shared_state: shared_state.clone(),
                    shared_db: shared_db.clone(),
                    shared_user_profiles: Arc::clone(&shared_user_profiles),
                    queue_metrics: queue_metrics.clone(),
                    recovery: recovery.clone(),
                },
                completion,
            );
            match spawn_result {
                Ok(worker) => core_worker = Some(worker),
                Err(error) => {
                    set_shared_db(&shared_db, None);
                    publish_core_failure_state(
                        &shared_state,
                        &update_tx_for_error,
                        format!("Iris could not start: {error}"),
                    );
                }
            }
        }
        Err(error) => {
            publish_core_failure_state(&shared_state, &update_tx_for_error, error.to_string());
        }
    }

    Arc::new(FfiApp {
        foreground_tx,
        foreground_rx,
        background_tx,
        background_rx,
        update_rx,
        listening: AtomicBool::new(false),
        shared_state,
        shared_db,
        shared_user_profiles,
        core_worker: Mutex::new(core_worker),
        core_stopped,
        perf: FfiPerfCounters::default(),
        queue_metrics,
        recovery,
    })
}

pub(super) fn ffi_app_failure(message: String) -> Arc<FfiApp> {
    let (_completion, core_stopped) = flume::bounded(1);
    let (_update_tx, update_rx) = flume::unbounded();
    let (foreground_tx, foreground_rx) = flume::unbounded();
    let (background_tx, background_rx) = flume::unbounded();
    let mut state = AppState::empty();
    state.toast = Some(message);
    state.rev = 1;
    let shared_state = Arc::new(RwLock::new(state));
    Arc::new(FfiApp {
        foreground_tx,
        foreground_rx,
        background_tx,
        background_rx,
        update_rx,
        listening: AtomicBool::new(false),
        shared_state,
        shared_db: Arc::new(RwLock::new(None)),
        shared_user_profiles: Default::default(),
        core_worker: Mutex::new(None),
        core_stopped,
        perf: FfiPerfCounters::default(),
        queue_metrics: Arc::new(CoreQueueMetrics::default()),
        recovery: Arc::new(CoreRecoveryState::default()),
    })
}