im-core 0.1.0

Rust IM SDK for Awiki clients built on Agent Network Protocol (ANP)
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

use serde_json::Value;
use std::time::Duration;

pub const SESSION_PING_INTERVAL: Duration = Duration::from_secs(60);
pub const SESSION_PING_TIMEOUT: Duration = Duration::from_secs(15);

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NotificationPingOutcome {
    Ok,
    Error(String),
}

#[derive(Debug, Clone, PartialEq)]
pub enum ConsumeNotificationsEvent {
    ContextDone { error: String },
    PingTick { outcome: NotificationPingOutcome },
    Notification(Value),
    NotificationsClosed { reader_error: Option<String> },
}

#[derive(Debug, Clone, PartialEq)]
pub enum ConsumeNotificationsAction {
    StartPing { timeout: Duration },
    CancelPing,
    HandleNotification(Value),
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ConsumeNotificationsDecision {
    Continue,
    Exit { error: String },
}

#[derive(Debug, Clone, PartialEq)]
pub struct ConsumeNotificationsStep {
    pub actions: Vec<ConsumeNotificationsAction>,
    pub decision: ConsumeNotificationsDecision,
}

pub fn consume_notifications_step(event: ConsumeNotificationsEvent) -> ConsumeNotificationsStep {
    match event {
        ConsumeNotificationsEvent::ContextDone { error } => ConsumeNotificationsStep {
            actions: Vec::new(),
            decision: ConsumeNotificationsDecision::Exit { error },
        },
        ConsumeNotificationsEvent::PingTick { outcome } => consume_ping_tick(outcome),
        ConsumeNotificationsEvent::Notification(notification) => ConsumeNotificationsStep {
            actions: vec![ConsumeNotificationsAction::HandleNotification(notification)],
            decision: ConsumeNotificationsDecision::Continue,
        },
        ConsumeNotificationsEvent::NotificationsClosed { reader_error } => {
            ConsumeNotificationsStep {
                actions: Vec::new(),
                decision: ConsumeNotificationsDecision::Exit {
                    error: reader_error
                        .unwrap_or_else(|| "websocket notification loop closed".to_string()),
                },
            }
        }
    }
}

fn consume_ping_tick(outcome: NotificationPingOutcome) -> ConsumeNotificationsStep {
    let mut actions = vec![ConsumeNotificationsAction::StartPing {
        timeout: SESSION_PING_TIMEOUT,
    }];
    let decision = match outcome {
        NotificationPingOutcome::Ok => ConsumeNotificationsDecision::Continue,
        NotificationPingOutcome::Error(error) => ConsumeNotificationsDecision::Exit {
            error: format!("websocket ping failed: {error}"),
        },
    };
    actions.push(ConsumeNotificationsAction::CancelPing);
    ConsumeNotificationsStep { actions, decision }
}