mainline 0.6.0

Simple, robust, BitTorrent's Mainline DHT implementation
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

use std::{
    convert::TryFrom,
    time::{Instant, SystemTime},
};

use ed25519_dalek::SigningKey;
use mainline::{common::MutableItem, Dht};

use clap::Parser;

#[derive(Parser)]
#[command(author, version, about, long_about = None)]
struct Cli {
    /// Mutable data public key.
    secret_key: String,
    /// Value to store on the DHT
    value: String,
}

fn main() {
    let cli = Cli::parse();

    let dht = Dht::default();

    let start = Instant::now();

    let signer = from_hex(cli.secret_key);

    println!(
        "\nStoring mutable data: \"{}\" for public_key: {}  ...\n",
        cli.value,
        to_hex(signer.verifying_key().to_bytes().to_vec())
    );

    let seq = SystemTime::now()
        .duration_since(SystemTime::UNIX_EPOCH)
        .expect("time drift")
        .as_micros() as i64;

    let item = MutableItem::new(signer, cli.value.as_bytes().to_owned().into(), seq, None);

    let metadata = dht.put_mutable(item).expect("put mutable failed");

    println!(
        "Stored immutable data as {:?} in {:?} seconds",
        metadata.target(),
        start.elapsed().as_secs_f32()
    );

    let stored_at = metadata.stored_at();
    println!("Stored at: {:?} nodes", stored_at.len());
    for node in stored_at {
        println!("   {:?}", node);
    }

    // You can now republish to the same closest nodes
    // skipping the the lookup step.
    //
    // This time we choose to not sepcify the port, effectively
    // making the port implicit to be detected by the storing node
    // from the source address of the put_immutable request
    //
    // Uncomment the following lines to try it out:

    // println!(
    //     "Publishing immutable data again to {:?} closest_nodes ...",
    //     metadata.closest_nodes().len()
    // );
    //
    // let again = Instant::now();
    // match dht.put_immutable_to(target, value, metadata.closest_nodes()) {
    //     Ok(metadata) => {
    //         println!(
    //             "Published again to {:?} nodes in {:?} seconds",
    //             metadata.stored_at().len(),
    //             again.elapsed().as_secs()
    //         );
    //     }
    //     Err(err) => {
    //         println!("Error: {:?}", err);
    //     }
    // }
}

fn from_hex(s: String) -> SigningKey {
    if s.len() % 2 != 0 {
        panic!("Number of Hex characters should be even");
    }

    let mut bytes = Vec::with_capacity(s.len() / 2);

    for i in 0..s.len() / 2 {
        let byte_str = &s[i * 2..(i * 2) + 2];
        let byte = u8::from_str_radix(byte_str, 16).expect("Invalid hex character");
        bytes.push(byte);
    }

    SigningKey::try_from(bytes.as_slice()).expect("Invalid signing key")
}

fn to_hex(bytes: Vec<u8>) -> String {
    let hex_chars: String = bytes.iter().map(|byte| format!("{:02x}", byte)).collect();

    hex_chars
}