kovi 0.13.0-rc1

A OneBot V11 bot plugin framework
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

use crate::bot::handler::{ExitEvent, InternalInternalEvent};
use crate::driver::{Driver, DriverEvent};
use crate::event::InternalEvent;
use crate::types::ApiAndOptOneshot;
use futures::StreamExt as _;
use std::sync::Arc;
use tokio::sync::mpsc::{self};

pub(crate) async fn event_connect(
    self_event_tx: mpsc::Sender<InternalInternalEvent>,
    drive: Arc<dyn Driver>,
) {
    let mut drive_stream = match drive.event_channel().await {
        Ok(drive_stream) => drive_stream,
        Err(err) => {
            eprintln!("Failed to get drive event channel: {}", err);
            self_event_tx.send(InternalInternalEvent::Exit(ExitEvent::FromDrive)).await.expect("Kovi kernel encountered an unrecoverable error during message forwarding (channel closed)");
            return;
        }
    };

    //处理事件，每个事件都会来到这里
    while let Some(event) = drive_stream.next().await {
        let event = match event {
            Ok(event) => event,
            Err(err) => {
                eprintln!("Failed to get drive event: {}", err);
                self_event_tx.send(InternalInternalEvent::Exit(ExitEvent::FromDrive)).await.expect("Kovi kernel encountered an unrecoverable error during message forwarding (channel closed)");
                return;
            }
        };

        let internal_event = match event {
            DriverEvent::Exit => InternalInternalEvent::Exit(ExitEvent::FromDrive),
            DriverEvent::Normal(value) => {
                InternalInternalEvent::OneBotEvent(Box::new(InternalEvent::DriverEvent(value)))
            }
        };

        self_event_tx.send(internal_event).await.expect("Kovi kernel encountered an unrecoverable error during message forwarding (channel closed)");
    }
}

pub(crate) async fn send_connect(
    mut self_api_rx: mpsc::Receiver<ApiAndOptOneshot>,
    self_event_tx: mpsc::Sender<InternalInternalEvent>,
    drive: Arc<dyn Driver>,
) {
    //处理事件，每个事件都会来到这里
    while let Some(api_and_oneshot) = self_api_rx.recv().await {
        tokio::spawn(send_api_inner(
            api_and_oneshot,
            self_event_tx.clone(),
            drive.clone(),
        ));
    }
}

async fn send_api_inner(
    api_and_oneshot: ApiAndOptOneshot,
    self_event_tx: mpsc::Sender<InternalInternalEvent>,
    drive: Arc<dyn Driver>,
) {
    let (send_api, oneshot) = api_and_oneshot;

    let result = drive.api_handler(send_api.clone()).await;

    let result = match result {
        Ok(result) => result,
        Err(err) => {
            eprintln!("Failed to handle API: {}", err);
            self_event_tx.send(InternalInternalEvent::Exit(ExitEvent::FromDrive)).await.expect("Kovi kernel encountered an unrecoverable error during message forwarding (channel closed)");
            return;
        }
    };

    if let Some(oneshot) = oneshot {
        oneshot.send(result.clone()).ok();
    }

    self_event_tx
        .send(InternalInternalEvent::OneBotEvent(
           Box::new(InternalEvent::DriverApiEvent((send_api, result))),
        ))
        .await.expect("Kovi kernel encountered an unrecoverable error during message forwarding (channel closed)");
}