refactor: move examples to common location

Refactor examples into separate binary crates.

Fixes https://github.com/libp2p/rust-libp2p/issues/3111.

Pull-Request: #3509.

examples/distributed-key-value-store/src/main.rs

@@ -0,0 +1,255 @@
+// Copyright 20l9 Parity Technologies (UK) Ltd.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+//! A basic key value store demonstrating libp2p and the mDNS and Kademlia protocols.
+//!
+//! 1. Using two terminal windows, start two instances. If you local network
+//!    allows mDNS, they will automatically connect.
+//!
+//! 2. Type `PUT my-key my-value` in terminal one and hit return.
+//!
+//! 3. Type `GET my-key` in terminal two and hit return.
+//!
+//! 4. Close with Ctrl-c.
+//!
+//! You can also store provider records instead of key value records.
+//!
+//! 1. Using two terminal windows, start two instances. If you local network
+//!    allows mDNS, they will automatically connect.
+//!
+//! 2. Type `PUT_PROVIDER my-key` in terminal one and hit return.
+//!
+//! 3. Type `GET_PROVIDERS my-key` in terminal two and hit return.
+//!
+//! 4. Close with Ctrl-c.
+
+use async_std::io;
+use futures::{prelude::*, select};
+use libp2p::kad::record::store::MemoryStore;
+use libp2p::kad::{
+    record::Key, AddProviderOk, GetProvidersOk, GetRecordOk, Kademlia, KademliaEvent, PeerRecord,
+    PutRecordOk, QueryResult, Quorum, Record,
+};
+use libp2p::{
+    development_transport, identity, mdns,
+    swarm::{NetworkBehaviour, SwarmEvent},
+    PeerId, Swarm,
+};
+use std::error::Error;
+
+#[async_std::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    env_logger::init();
+
+    // Create a random key for ourselves.
+    let local_key = identity::Keypair::generate_ed25519();
+    let local_peer_id = PeerId::from(local_key.public());
+
+    // Set up a an encrypted DNS-enabled TCP Transport over the Mplex protocol.
+    let transport = development_transport(local_key).await?;
+
+    // We create a custom network behaviour that combines Kademlia and mDNS.
+    #[derive(NetworkBehaviour)]
+    #[behaviour(out_event = "MyBehaviourEvent")]
+    struct MyBehaviour {
+        kademlia: Kademlia<MemoryStore>,
+        mdns: mdns::async_io::Behaviour,
+    }
+
+    #[allow(clippy::large_enum_variant)]
+    enum MyBehaviourEvent {
+        Kademlia(KademliaEvent),
+        Mdns(mdns::Event),
+    }
+
+    impl From<KademliaEvent> for MyBehaviourEvent {
+        fn from(event: KademliaEvent) -> Self {
+            MyBehaviourEvent::Kademlia(event)
+        }
+    }
+
+    impl From<mdns::Event> for MyBehaviourEvent {
+        fn from(event: mdns::Event) -> Self {
+            MyBehaviourEvent::Mdns(event)
+        }
+    }
+
+    // Create a swarm to manage peers and events.
+    let mut swarm = {
+        // Create a Kademlia behaviour.
+        let store = MemoryStore::new(local_peer_id);
+        let kademlia = Kademlia::new(local_peer_id, store);
+        let mdns = mdns::async_io::Behaviour::new(mdns::Config::default(), local_peer_id)?;
+        let behaviour = MyBehaviour { kademlia, mdns };
+        Swarm::with_async_std_executor(transport, behaviour, local_peer_id)
+    };
+
+    // Read full lines from stdin
+    let mut stdin = io::BufReader::new(io::stdin()).lines().fuse();
+
+    // Listen on all interfaces and whatever port the OS assigns.
+    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;
+
+    // Kick it off.
+    loop {
+        select! {
+        line = stdin.select_next_some() => handle_input_line(&mut swarm.behaviour_mut().kademlia, line.expect("Stdin not to close")),
+        event = swarm.select_next_some() => match event {
+            SwarmEvent::NewListenAddr { address, .. } => {
+                println!("Listening in {address:?}");
+            },
+            SwarmEvent::Behaviour(MyBehaviourEvent::Mdns(mdns::Event::Discovered(list))) => {
+                for (peer_id, multiaddr) in list {
+                    swarm.behaviour_mut().kademlia.add_address(&peer_id, multiaddr);
+                }
+            }
+            SwarmEvent::Behaviour(MyBehaviourEvent::Kademlia(KademliaEvent::OutboundQueryProgressed { result, ..})) => {
+                match result {
+                    QueryResult::GetProviders(Ok(GetProvidersOk::FoundProviders { key, providers, .. })) => {
+                        for peer in providers {
+                            println!(
+                                "Peer {peer:?} provides key {:?}",
+                                std::str::from_utf8(key.as_ref()).unwrap()
+                            );
+                        }
+                    }
+                    QueryResult::GetProviders(Err(err)) => {
+                        eprintln!("Failed to get providers: {err:?}");
+                    }
+                    QueryResult::GetRecord(Ok(
+                        GetRecordOk::FoundRecord(PeerRecord {
+                            record: Record { key, value, .. },
+                            ..
+                        })
+                    )) => {
+                        println!(
+                            "Got record {:?} {:?}",
+                            std::str::from_utf8(key.as_ref()).unwrap(),
+                            std::str::from_utf8(&value).unwrap(),
+                        );
+                    }
+                    QueryResult::GetRecord(Ok(_)) => {}
+                    QueryResult::GetRecord(Err(err)) => {
+                        eprintln!("Failed to get record: {err:?}");
+                    }
+                    QueryResult::PutRecord(Ok(PutRecordOk { key })) => {
+                        println!(
+                            "Successfully put record {:?}",
+                            std::str::from_utf8(key.as_ref()).unwrap()
+                        );
+                    }
+                    QueryResult::PutRecord(Err(err)) => {
+                        eprintln!("Failed to put record: {err:?}");
+                    }
+                    QueryResult::StartProviding(Ok(AddProviderOk { key })) => {
+                        println!(
+                            "Successfully put provider record {:?}",
+                            std::str::from_utf8(key.as_ref()).unwrap()
+                        );
+                    }
+                    QueryResult::StartProviding(Err(err)) => {
+                        eprintln!("Failed to put provider record: {err:?}");
+                    }
+                    _ => {}
+                }
+            }
+            _ => {}
+        }
+        }
+    }
+}
+
+fn handle_input_line(kademlia: &mut Kademlia<MemoryStore>, line: String) {
+    let mut args = line.split(' ');
+
+    match args.next() {
+        Some("GET") => {
+            let key = {
+                match args.next() {
+                    Some(key) => Key::new(&key),
+                    None => {
+                        eprintln!("Expected key");
+                        return;
+                    }
+                }
+            };
+            kademlia.get_record(key);
+        }
+        Some("GET_PROVIDERS") => {
+            let key = {
+                match args.next() {
+                    Some(key) => Key::new(&key),
+                    None => {
+                        eprintln!("Expected key");
+                        return;
+                    }
+                }
+            };
+            kademlia.get_providers(key);
+        }
+        Some("PUT") => {
+            let key = {
+                match args.next() {
+                    Some(key) => Key::new(&key),
+                    None => {
+                        eprintln!("Expected key");
+                        return;
+                    }
+                }
+            };
+            let value = {
+                match args.next() {
+                    Some(value) => value.as_bytes().to_vec(),
+                    None => {
+                        eprintln!("Expected value");
+                        return;
+                    }
+                }
+            };
+            let record = Record {
+                key,
+                value,
+                publisher: None,
+                expires: None,
+            };
+            kademlia
+                .put_record(record, Quorum::One)
+                .expect("Failed to store record locally.");
+        }
+        Some("PUT_PROVIDER") => {
+            let key = {
+                match args.next() {
+                    Some(key) => Key::new(&key),
+                    None => {
+                        eprintln!("Expected key");
+                        return;
+                    }
+                }
+            };
+
+            kademlia
+                .start_providing(key)
+                .expect("Failed to start providing key");
+        }
+        _ => {
+            eprintln!("expected GET, GET_PROVIDERS, PUT or PUT_PROVIDER");
+        }
+    }
+}