Struct TopicId

Source

pub struct TopicId { /* private fields */ }

Implementations§

Source §

impl TopicId

Source

pub fn new(raw: String) -> Self

Examples found in repository ?

examples/simple.rs (line 28)

9async fn main() -> Result<()> {
10    // Generate a new random secret key
11    let secret_key = SecretKey::generate(rand::rngs::OsRng);
12
13    // Set up endpoint with discovery enabled
14    let endpoint = Endpoint::builder()
15        .secret_key(secret_key.clone())
16        .discovery_n0()
17        .bind()
18        .await?;
19
20    // Initialize gossip with auto-discovery
21    let gossip = Gossip::builder().spawn(endpoint.clone());
22
23    // Set up protocol router
24    let _router = iroh::protocol::Router::builder(endpoint.clone())
25        .accept(iroh_gossip::ALPN, gossip.clone())
26        .spawn();
27
28    let topic_id = TopicId::new("my-iroh-gossip-topic".to_string());
29    let initial_secret = b"my-initial-secret".to_vec();
30
31    // Split into sink (sending) and stream (receiving)
32
33    let record_publisher = RecordPublisher::new(
34        topic_id.clone(),
35        endpoint.node_id(),
36        secret_key.secret().clone(),
37        None,
38        initial_secret,
39    );
40
41    let topic = gossip
42        .subscribe_and_join_with_auto_discovery(record_publisher)
43        .await?;
44
45    println!("[joined topic]");
46
47    // Do something with the gossip topic
48    // (bonus: GossipSender and GossipReceiver are safely clonable)
49    let (_gossip_sender, _gossip_receiver) = topic.split().await?;
50
51    Ok(())
52}

More examples

Hide additional examples

examples/e2e_test.rs (line 31)

11async fn main() -> Result<()> {
12    // Generate a new random secret key
13    let secret_key = SecretKey::generate(rand::rngs::OsRng);
14
15    // Set up endpoint with discovery enabled
16    let endpoint = Endpoint::builder()
17        .secret_key(secret_key.clone())
18        .discovery_n0()
19        .bind()
20        .await?;
21
22    // Initialize gossip with auto-discovery
23    let gossip = Gossip::builder()
24        .spawn(endpoint.clone());
25
26    // Set up protocol router
27    let _router = iroh::protocol::Router::builder(endpoint.clone())
28        .accept(iroh_gossip::ALPN, gossip.clone())
29        .spawn();
30
31    let topic_id = TopicId::new("my-iroh-gossip-topic".to_string());
32    let initial_secret = b"my-initial-secret".to_vec();
33
34    let record_publisher = RecordPublisher::new(
35        topic_id.clone(),
36        endpoint.node_id(),
37        secret_key.secret().clone(),
38        None,
39        initial_secret,
40    );
41    let (gossip_sender, gossip_receiver) = gossip
42        .subscribe_and_join_with_auto_discovery(record_publisher)
43        .await?
44        .split().await?;
45
46    tokio::spawn(async move {
47        while let Some(Ok(event)) = gossip_receiver.next().await {
48            println!("event: {event:?}");
49        }
50    });
51
52
53    tokio::time::sleep(std::time::Duration::from_secs(3)).await;
54    gossip_sender.broadcast(format!("hi from {}",endpoint.node_id()).into()).await?;
55
56    println!("[joined topic]");
57
58    tokio::time::sleep(std::time::Duration::from_secs(10)).await;
59
60    println!("[finished]");
61
62    // successfully joined
63    // exit with code 0
64    Ok(())
65}

examples/chat_no_wait.rs (line 31)

11async fn main() -> Result<()> {
12    // Generate a new random secret key
13    let secret_key = SecretKey::generate(rand::rngs::OsRng);
14
15    // Set up endpoint with discovery enabled
16    let endpoint = Endpoint::builder()
17        .secret_key(secret_key.clone())
18        .discovery_n0()
19        .bind()
20        .await?;
21
22    // Initialize gossip with auto-discovery
23    let gossip = Gossip::builder()
24        .spawn(endpoint.clone());
25
26    // Set up protocol router
27    let _router = iroh::protocol::Router::builder(endpoint.clone())
28        .accept(iroh_gossip::ALPN, gossip.clone())
29        .spawn();
30
31    let topic_id = TopicId::new("my-iroh-gossip-topic".to_string());
32    let initial_secret = b"my-initial-secret".to_vec();
33
34    let record_publisher = RecordPublisher::new(
35        topic_id.clone(),
36        endpoint.node_id(),
37        secret_key.secret().clone(),
38        None,
39        initial_secret,
40    );
41    let (gossip_sender, gossip_receiver) = gossip
42        .subscribe_and_join_with_auto_discovery_no_wait(record_publisher)
43        .await?
44        .split().await?;
45
46    println!("Joined topic");
47
48    // Spawn listener for incoming messages
49    tokio::spawn(async move {
50        while let Some(Ok(event)) = gossip_receiver.next().await {
51            if let Event::Received(msg) = event {
52                println!(
53                    "\nMessage from {}: {}",
54                    &msg.delivered_from.to_string()[0..8],
55                    String::from_utf8(msg.content.to_vec()).unwrap()
56                );
57            } else if let Event::NeighborUp(peer) = event {
58                println!("\nJoined by {}", &peer.to_string()[0..8]);
59            }
60        }
61    });
62
63    // Main input loop for sending messages
64    let mut buffer = String::new();
65    let stdin = std::io::stdin();
66    loop {
67        print!("\n> ");
68        stdin.read_line(&mut buffer).unwrap();
69        gossip_sender.broadcast(buffer.clone().replace("\n", "").into())
70            .await
71            .unwrap();
72        println!(" - (sent)");
73        buffer.clear();
74    }
75}

examples/chat.rs (line 31)

11async fn main() -> Result<()> {
12    // Generate a new random secret key
13    let secret_key = SecretKey::generate(rand::rngs::OsRng);
14
15    // Set up endpoint with discovery enabled
16    let endpoint = Endpoint::builder()
17        .secret_key(secret_key.clone())
18        .discovery_n0()
19        .bind()
20        .await?;
21
22    // Initialize gossip with auto-discovery
23    let gossip = Gossip::builder()
24        .spawn(endpoint.clone());
25
26    // Set up protocol router
27    let _router = iroh::protocol::Router::builder(endpoint.clone())
28        .accept(iroh_gossip::ALPN, gossip.clone())
29        .spawn();
30
31    let topic_id = TopicId::new("my-iroh-gossip-topic".to_string());
32    let initial_secret = b"my-initial-secret".to_vec();
33
34
35    let record_publisher = RecordPublisher::new(
36        topic_id.clone(),
37        endpoint.node_id(),
38        secret_key.secret().clone(),
39        None,
40        initial_secret,
41    );
42        
43    // Split into sink (sending) and stream (receiving)
44    let (gossip_sender, gossip_receiver) = gossip
45        .subscribe_and_join_with_auto_discovery(record_publisher)
46        .await?
47        .split().await?;
48
49    println!("Joined topic");
50
51    // Spawn listener for incoming messages
52    tokio::spawn(async move {
53        while let Some(Ok(event)) = gossip_receiver.next().await {
54            if let Event::Received(msg) = event {
55                println!(
56                    "\nMessage from {}: {}",
57                    &msg.delivered_from.to_string()[0..8],
58                    String::from_utf8(msg.content.to_vec()).unwrap()
59                );
60            } else if let Event::NeighborUp(peer) = event {
61                println!("\nJoined by {}", &peer.to_string()[0..8]);
62            }
63        }
64    });
65
66    // Main input loop for sending messages
67    let mut buffer = String::new();
68    let stdin = std::io::stdin();
69    loop {
70        print!("\n> ");
71        stdin.read_line(&mut buffer).unwrap();
72        gossip_sender.broadcast(buffer.clone().replace("\n", "").into())
73            .await
74            .unwrap();
75        println!(" - (sent)");
76        buffer.clear();
77    }
78}

examples/secret_rotation.rs (line 50)

30async fn main() -> Result<()> {
31    // Generate a new random secret key
32    let secret_key = SecretKey::generate(rand::rngs::OsRng);
33
34    // Set up endpoint with discovery enabled
35    let endpoint = Endpoint::builder()
36        .secret_key(secret_key.clone())
37        .discovery_n0()
38        .bind()
39        .await?;
40
41    // Initialize gossip with auto-discovery
42    let gossip = Gossip::builder()
43        .spawn(endpoint.clone());
44
45    // Set up protocol router
46    let _router = iroh::protocol::Router::builder(endpoint.clone())
47        .accept(iroh_gossip::ALPN, gossip.clone())
48        .spawn();
49
50    let topic_id = TopicId::new("my-iroh-gossip-topic".to_string());
51    let initial_secret = b"my-initial-secret".to_vec();
52
53    // Split into sink (sending) and stream (receiving)
54
55    let record_publisher = RecordPublisher::new(
56        topic_id.clone(),
57        endpoint.node_id(),
58        secret_key.secret().clone(),
59        Some(RotationHandle::new(MySecretRotation)),
60        initial_secret,
61    );
62    let (gossip_sender, gossip_receiver) = gossip
63        .subscribe_and_join_with_auto_discovery(record_publisher)
64        .await?
65        .split().await?;
66
67    println!("Joined topic");
68
69    // Spawn listener for incoming messages
70    tokio::spawn(async move {
71        while let Some(Ok(event)) = gossip_receiver.next().await {
72            if let Event::Received(msg) = event {
73                println!(
74                    "\nMessage from {}: {}",
75                    &msg.delivered_from.to_string()[0..8],
76                    String::from_utf8(msg.content.to_vec()).unwrap()
77                );
78            } else if let Event::NeighborUp(peer) = event {
79                println!("\nJoined by {}", &peer.to_string()[0..8]);
80            }
81        }
82    });
83
84    // Main input loop for sending messages
85    let mut buffer = String::new();
86    let stdin = std::io::stdin();
87    loop {
88        print!("\n> ");
89        stdin.read_line(&mut buffer).unwrap();
90        gossip_sender.broadcast(buffer.clone().replace("\n", "").into())
91            .await
92            .unwrap();
93        println!(" - (sent)");
94        buffer.clear();
95    }
96}