event-notification 0.4.1

A modular event notification system with multi-channel support
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
105
106
107

use event_notification::NotificationSystem;
use event_notification::create_adapters;
use event_notification::{AdapterConfig, NotificationConfig, WebhookConfig};
use event_notification::{Bucket, Event, Identity, Metadata, Name, Object, Source};
use std::collections::HashMap;
use std::error;
use std::sync::Arc;
use tokio::signal;

#[tokio::main]
async fn main() -> Result<(), Box<dyn error::Error>> {
    tracing_subscriber::fmt::init();

    let mut config = NotificationConfig {
        store_path: "./events".to_string(),
        channel_capacity: 100,
        adapters: vec![AdapterConfig::Webhook(WebhookConfig {
            endpoint: "http://localhost:8080/webhook".to_string(),
            auth_token: Some("secret-token".to_string()),
            custom_headers: Some(HashMap::from([(
                "X-Custom".to_string(),
                "value".to_string(),
            )])),
            max_retries: 3,
            timeout: 10,
        })],
        http: Default::default(),
    };
    config.http.port = 8080;

    // loading configuration from specific env files
    let _config = NotificationConfig::from_env_file(".env.example")?;

    // loading from a specific file
    let _config = NotificationConfig::from_file("event.toml")?;

    // Automatically load from multiple sources (Priority: Environment Variables > YAML > TOML)
    let _config = NotificationConfig::load()?;

    let system = Arc::new(tokio::sync::Mutex::new(
        NotificationSystem::new(config.clone()).await?,
    ));
    let adapters = create_adapters(&config.adapters)?;

    // create an s3 metadata object
    let metadata = Metadata {
        schema_version: "1.0".to_string(),
        configuration_id: "test-config".to_string(),
        bucket: Bucket {
            name: "my-bucket".to_string(),
            owner_identity: Identity {
                principal_id: "owner123".to_string(),
            },
            arn: "arn:aws:s3:::my-bucket".to_string(),
        },
        object: Object {
            key: "test.txt".to_string(),
            size: Some(1024),
            etag: Some("abc123".to_string()),
            content_type: Some("text/plain".to_string()),
            user_metadata: None,
            version_id: None,
            sequencer: "1234567890".to_string(),
        },
    };

    // create source object
    let source = Source {
        host: "localhost".to_string(),
        port: "80".to_string(),
        user_agent: "curl/7.68.0".to_string(),
    };

    // create events using builder mode
    let event = Event::builder()
        .event_time("2023-10-01T12:00:00.000Z")
        .event_name(Name::ObjectCreatedPut)
        .user_identity(Identity {
            principal_id: "user123".to_string(),
        })
        .s3(metadata)
        .source(source)
        .channels(vec!["webhook".to_string()])
        .build()
        .expect("failed to create event");

    {
        let system = system.lock().await;
        system.send_event(event).await?;
    }

    let system_clone = Arc::clone(&system);
    let system_handle = tokio::spawn(async move {
        let mut system = system_clone.lock().await;
        system.start(adapters).await
    });

    signal::ctrl_c().await?;
    tracing::info!("Received shutdown signal");
    {
        let system = system.lock().await;
        system.shutdown();
    }

    system_handle.await??;
    Ok(())
}