zero4rs 2.0.0

zero4rs is a powerful, pragmatic, and extremely fast web framework for Rust
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

use crate::core::natss::{NatsClient, Settings};
use async_nats::{jetstream, ConnectOptions, Event};

pub async fn client(cfg: &Option<Settings>) -> Option<NatsClient> {
    if let Some(cfg) = cfg {
        if !cfg.enabled() {
            return None;
        }

        let server = if let Some(s) = cfg.server.as_ref() {
            s.to_string()
        } else {
            "nats://127.0.0.1:4222".to_string()
        };

        let opts = ConnectOptions::new().event_callback({
            move |event: Event| {
                async move {
                    match event {
                        Event::Connected => {
                            // println!("✅ Connected to NATS");
                        }
                        Event::Disconnected => {
                            // println!("❌ Disconnected from NATS");
                        }
                        Event::Closed => {
                            // println!("❌ Closed from NATS");
                        }
                        Event::SlowConsumer(_) => {
                            // println!("✅ Connected to NATS");
                        }
                        Event::ServerError(_e) => {
                            // println!("✅ Connected to NATS");
                        }
                        Event::ClientError(_e) => {
                            // println!("✅ Connected to NATS");
                        }
                        _ => {}
                    }
                }
            }
        });

        match opts.connect(&server).await {
            Ok(client) => {
                let js: jetstream::context::Context = jetstream::new(client.clone());

                log::info!("nats-jetstream_connect_successful: server={}", server);

                let clt = NatsClient {
                    server: server.clone(),
                    js,
                    client,
                };

                // 创建 Stream
                if let Err(e) = clt
                    .create_stream("EVENTS", vec!["events.*".to_string()])
                    .await
                {
                    log::error!(
                        "nats-jetstream-connect-failed: server={}, error={:?}",
                        server,
                        e
                    );
                }

                Some(clt)
            }
            Err(_e) => {
                log::error!(
                    "nats-jetstream-connect-failed: server={}, error={:?}",
                    server,
                    _e
                );

                None
            }
        }
    } else {
        None
    }
}