sdtn 0.1.4

SpaceArth DTN - A Rust-based implementation of Delay Tolerant Networking (DTN) for resilient communication
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use sdtn::consts::BUNDLES_ADVANCED_DIR;
use sdtn::{convenience, BundleStatus, DtnNode};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    println!("🚀 SpaceArth DTN Advanced Usage Example");

    // Method 1: Using the full DtnNode API with default settings
    println!("\n📋 Method 1: Using DtnNode API (default settings)");
    let node = DtnNode::new()?;

    // Insert multiple bundles
    let messages = [
        "First message",
        "Second message with special chars: 🚀🌍",
        "Third message with numbers: 12345",
        "Fourth message - very long message that demonstrates how the system handles longer content",
    ];

    for (i, msg) in messages.iter().enumerate() {
        println!("  Inserting bundle {}: {}", i + 1, msg);
        node.insert_bundle(msg.to_string()).await?;
    }

    // Method 1b: Using DtnNode API with custom store path
    println!("\n📋 Method 1b: Using DtnNode API (custom store path)");
    let custom_node = DtnNode::with_store_path(BUNDLES_ADVANCED_DIR)?;
    custom_node
        .insert_bundle("Message in custom store".to_string())
        .await?;

    // Get detailed status for a specific bundle
    let bundles = node.list_bundles()?;
    if let Some(first_id) = bundles.first() {
        println!("\n📄 Detailed status for bundle: {}", first_id);
        let status = node.get_bundle_status(Some(first_id))?;
        match status {
            BundleStatus::Single { id, bundle } => {
                println!("  ID: {}", id);
                println!("  Source: {}", bundle.primary.source);
                println!("  Destination: {}", bundle.primary.destination);
                println!("  Creation Time: {}", bundle.primary.creation_timestamp);
                println!("  Lifetime: {} seconds", bundle.primary.lifetime);
                println!("  Expired: {}", bundle.is_expired());
                println!("  Message: {}", String::from_utf8_lossy(&bundle.payload));
            }
            _ => unreachable!(),
        }
    }

    // Method 2: Using convenience functions (always use default path)
    println!("\n📋 Method 2: Using convenience functions");

    // Quick insert
    convenience::insert_bundle_quick("Quick message from convenience function").await?;

    // Quick list
    let quick_bundles = convenience::list_bundles_quick()?;
    println!(
        "  Found {} bundles using convenience function",
        quick_bundles.len()
    );

    // Quick show (if we have bundles)
    if let Some(bundle_id) = quick_bundles.first() {
        let partial_id = &bundle_id[..8]; // Use first 8 characters
        match convenience::show_bundle_quick(partial_id) {
            Ok(bundle) => {
                println!(
                    "  Quick show for {}: {}",
                    partial_id,
                    String::from_utf8_lossy(&bundle.payload)
                );
            }
            Err(e) => {
                println!("  Quick show failed: {}", e);
            }
        }
    }

    // Method 3: Error handling demonstration
    println!("\n📋 Method 3: Error handling demonstration");

    // Try to show a non-existent bundle
    match node.show_bundle("nonexistent") {
        Ok(_) => println!("  Unexpected: Found non-existent bundle"),
        Err(e) => println!("  Expected error for non-existent bundle: {}", e),
    }

    // Method 4: Status summary
    println!("\n📋 Method 4: Status summary");
    let summary = node.get_bundle_status(None)?;
    match summary {
        BundleStatus::Summary {
            active,
            expired,
            total,
        } => {
            println!("  📊 Bundle Summary:");
            println!("    ✅ Active: {}", active);
            println!("    ⏰ Expired: {}", expired);
            println!("    📦 Total: {}", total);

            if expired > 0 {
                println!("  🧹 Cleaning up expired bundles...");
                node.cleanup_expired()?;

                // Check status after cleanup
                let after_cleanup = node.get_bundle_status(None)?;
                if let BundleStatus::Summary {
                    active: new_active,
                    expired: new_expired,
                    total: new_total,
                } = after_cleanup
                {
                    println!("  📊 After cleanup:");
                    println!("    ✅ Active: {}", new_active);
                    println!("    ⏰ Expired: {}", new_expired);
                    println!("    📦 Total: {}", new_total);
                }
            }
        }
        _ => unreachable!(),
    }

    // Method 5: Using Default trait
    println!("\n📋 Method 5: Using Default trait");
    let default_node = DtnNode::default();
    default_node
        .insert_bundle("Message from default instance".to_string())
        .await?;

    println!("\n✅ Advanced usage example completed successfully!");
    Ok(())
}