Fix docker for relay_v1 and prepare for relay_v2

protocols/dcutr/Cargo.toml

@@ -32,4 +32,5 @@ libp2p-ping = { path = "../ping" }
 libp2p-plaintext = { path = "../../transports/plaintext" }
 libp2p-relay = { version = "0.4", path = "../relay" }
 libp2p-yamux = { path = "../../muxers/yamux" }
-rand = "0.7"
+rand = "0.7"
+structopt = "0.3.21"

protocols/dcutr/examples/client.rs

@@ -27,77 +27,47 @@ use libp2p::identify::{Identify, IdentifyConfig, IdentifyEvent};
 use libp2p::noise;
 use libp2p::ping::{Ping, PingConfig, PingEvent};
 
-use libp2p::relay::v2::client::{self, Client};
+use core::fmt;
 use libp2p::dns::DnsConfig;
+use libp2p::relay::v2::client::{self, Client};
 use libp2p::swarm::{AddressScore, Swarm, SwarmEvent};
 use libp2p::tcp::TcpConfig;
 use libp2p::Transport;
 use libp2p::{identity, NetworkBehaviour, PeerId};
 use std::error::Error;
 use std::net::Ipv4Addr;
+use std::str::FromStr;
 use std::task::{Context, Poll};
+use structopt::StructOpt;
 
 fn main() -> Result<(), Box<dyn Error>> {
  env_logger::init();
+ let opt = Opt::from_args();
+ println!("opt: {:?}", opt);
 
- let local_key = generate_ed25519(std::env::args().nth(1).unwrap().parse().unwrap());
+ // Create a static known PeerId based on given secret
+ let local_key: identity::Keypair = generate_ed25519(opt.secret_key_seed);
  let local_peer_id = PeerId::from(local_key.public());
  println!("Local peer id: {:?}", local_peer_id);
 
-
- let (transport, client) = Client::new_transport_and_behaviour(local_peer_id, block_on(DnsConfig::system( TcpConfig::new().port_reuse(true))).unwrap());
+ let (transport, client) = Client::new_transport_and_behaviour(
+ local_peer_id,
+ block_on(DnsConfig::system(TcpConfig::new().port_reuse(true))).unwrap(),
+ );
 
  let noise_keys = noise::Keypair::<noise::X25519Spec>::new()
  .into_authentic(&local_key)
  .expect("Signing libp2p-noise static DH keypair failed.");
 
  let transport = transport
  .upgrade()
- .authenticate_with_version(noise::NoiseConfig::xx(noise_keys).into_authenticated(), upgrade::AuthenticationVersion::V1SimultaneousOpen)
+ .authenticate_with_version(
+ noise::NoiseConfig::xx(noise_keys).into_authenticated(),
+ upgrade::AuthenticationVersion::V1SimultaneousOpen,
+ )
  .multiplex(libp2p_yamux::YamuxConfig::default())
  .boxed();
 
- #[derive(NetworkBehaviour)]
- #[behaviour(out_event = "Event", event_process = false)]
- struct Behaviour {
- relay_client: Client,
- ping: Ping,
- identify: Identify,
- dcutr: dcutr::behaviour::Behaviour,
- }
-
- #[derive(Debug)]
- enum Event {
- Ping(PingEvent),
- Identify(IdentifyEvent),
- Relay(client::Event),
- Dcutr(dcutr::behaviour::Event),
- }
-
- impl From<PingEvent> for Event {
- fn from(e: PingEvent) -> Self {
- Event::Ping(e)
- }
- }
-
- impl From<IdentifyEvent> for Event {
- fn from(e: IdentifyEvent) -> Self {
- Event::Identify(e)
- }
- }
-
- impl From<client::Event> for Event {
- fn from(e: client::Event) -> Self {
- Event::Relay(e)
- }
- }
-
- impl From<dcutr::behaviour::Event> for Event {
- fn from(e: dcutr::behaviour::Event) -> Self {
- Event::Dcutr(e)
- }
- }
-
  let behaviour = Behaviour {
  relay_client: client,
  ping: Ping::new(PingConfig::new()),
@@ -110,39 +80,35 @@ fn main() -> Result<(), Box<dyn Error>> {
 
  let mut swarm = Swarm::new(transport, behaviour, local_peer_id);
 
- if let (Some(external_ip), Some(port)) = (std::env::args().nth(2), std::env::args().nth(3)) {
- let listen_addr = Multiaddr::empty()
- .with("0.0.0.0".parse::<Ipv4Addr>().unwrap().into())
- .with(Protocol::Tcp(port.parse().unwrap()));
- swarm.listen_on(listen_addr)?;
-
- let external_addr = Multiaddr::empty()
- .with(external_ip.parse::<Ipv4Addr>().unwrap().into())
- .with(Protocol::Tcp(port.parse().unwrap()));
- swarm.add_external_address(external_addr, AddressScore::Infinite);
- } else {
- panic!();
- }
-
- if let (Some(mode), Some(addr)) = (std::env::args().nth(4), std::env::args().nth(5)) {
- match mode.as_str() {
- "dial" => {
- swarm.dial_addr(addr.parse().unwrap()).unwrap();
- }
- "listen" => {
- swarm.listen_on(addr.parse().unwrap()).unwrap();
- }
- s => panic!("Unexpected string {:?}", s),
+ let listen_addr = Multiaddr::empty()
+ .with("0.0.0.0".parse::<Ipv4Addr>().unwrap().into())
+ .with(Protocol::Tcp(opt.port));
+ swarm.listen_on(listen_addr)?;
+
+ let external_addr = Multiaddr::empty()
+ .with(
+ opt.external_ipv4_address
+ .parse::<Ipv4Addr>()
+ .unwrap()
+ .into(),
+ )
+ .with(Protocol::Tcp(opt.port));
+ swarm.add_external_address(external_addr, AddressScore::Infinite);
+
+ match opt.mode {
+ Mode::Dial => {
+ swarm.dial_addr(opt.address).unwrap();
+ }
+ Mode::Listen => {
+ swarm.listen_on(opt.address).unwrap();
  }
- } else {
- panic!();
  }
 
  let mut listening = false;
  block_on(futures::future::poll_fn(move |cx: &mut Context<'_>| {
  loop {
  match swarm.poll_next_unpin(cx) {
- Poll::Ready(Some(SwarmEvent::NewListenAddr{address, ..})) => {
+ Poll::Ready(Some(SwarmEvent::NewListenAddr { address, .. })) => {
  println!("Listening on {:?}", address);
  }
  Poll::Ready(Some(SwarmEvent::Behaviour(Event::Relay(event)))) => {
@@ -176,3 +142,94 @@ fn generate_ed25519(secret_key_seed: u8) -> identity::Keypair {
  .expect("this returns `Err` only if the length is wrong; the length is correct; qed");
  identity::Keypair::Ed25519(secret_key.into())
 }
+
+#[derive(NetworkBehaviour)]
+#[behaviour(out_event = "Event", event_process = false)]
+struct Behaviour {
+ relay_client: Client,
+ ping: Ping,
+ identify: Identify,
+ dcutr: dcutr::behaviour::Behaviour,
+}
+
+#[derive(Debug)]
+enum Event {
+ Ping(PingEvent),
+ Identify(IdentifyEvent),
+ Relay(client::Event),
+ Dcutr(dcutr::behaviour::Event),
+}
+
+impl From<PingEvent> for Event {
+ fn from(e: PingEvent) -> Self {
+ Event::Ping(e)
+ }
+}
+
+impl From<IdentifyEvent> for Event {
+ fn from(e: IdentifyEvent) -> Self {
+ Event::Identify(e)
+ }
+}
+
+impl From<client::Event> for Event {
+ fn from(e: client::Event) -> Self {
+ Event::Relay(e)
+ }
+}
+
+impl From<dcutr::behaviour::Event> for Event {
+ fn from(e: dcutr::behaviour::Event) -> Self {
+ Event::Dcutr(e)
+ }
+}
+
+#[derive(Debug, StructOpt)]
+#[structopt(name = "libp2p relay")]
+struct Opt {
+ /// The mode (relay, client-listen, client-dial)
+ #[structopt(long)]
+ mode: Mode,
+
+ /// Fixed value to generate deterministic peer id
+ #[structopt(long)]
+ secret_key_seed: u8,
+
+ /// The external ip address that the client listening on
+ #[structopt(short = "x", long)]
+ external_ipv4_address: String,
+
+ /// The port used to listen both on local and external addresses
+ #[structopt(long)]
+ port: u16,
+
+ /// The multi-address that use to dial to or listen on
+ #[structopt(long)]
+ address: Multiaddr,
+}
+
+#[derive(Debug, StructOpt)]
+enum Mode {
+ Listen,
+ Dial,
+}
+
+impl FromStr for Mode {
+ type Err = ModeError;
+ fn from_str(mode: &str) -> Result<Self, Self::Err> {
+ match mode {
+ "listen" => Ok(Mode::Listen),
+ "dial" => Ok(Mode::Dial),
+ _ => Err(ModeError {}),
+ }
+ }
+}
+
+#[derive(Debug)]
+struct ModeError {}
+impl Error for ModeError {}
+impl fmt::Display for ModeError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "Could not parse a mode")
+ }
+}

protocols/relay/examples/Dockerfile

@@ -1,19 +1,14 @@
 # 1: Build the exe
 FROM rust:1 as builder
 LABEL Name=libp2p-relay Version=0.0.1
-# 1a: Prepare for static linking
-RUN apt-get update && \
- apt-get dist-upgrade -y && \
- apt-get install -y musl-tools && \
- rustup target add x86_64-unknown-linux-musl
+
 # 1b: Download and compile Rust dependencies (and store as a separate Docker layer)
 WORKDIR /usr/src/libp2p
 
 COPY . .
-RUN cargo build --target x86_64-unknown-linux-musl --example=relay --package=libp2p-relay
-
+RUN cargo build --example=relay_v? --package=libp2p-relay
 # 2: Copy the exe and extra files ("static") to an empty Docker image
 FROM debian:buster-slim
 
-COPY --from=builder /usr/src/libp2p/target/x86_64-unknown-linux-musl/debug/examples/relay .
+COPY --from=builder /usr/src/libp2p/target/debug/examples/relay_v? .
 USER 1000

protocols/relay/examples/docker-compose.yml → protocols/relay/examples/docker-compose-relay_v1.yml

@@ -5,10 +5,10 @@ services:
  relay: 
  image: libp2p-relay
  command:
- - "./relay"
+ - "./relay_v1"
  - "--mode=relay"
  - "--secret-key-seed=1"
- - "--address=/ip6/::/tcp/4444"
+ - "--address=/ip4/0.0.0.0/tcp/4444"
  build:
  context: ../../../.
  dockerfile: ./protocols/relay/examples/Dockerfile
@@ -19,10 +19,10 @@ services:
  client-listen: 
  image: libp2p-relay
  command:
- - "./relay"
+ - "./relay_v1"
  - "--mode=client-listen"
  - "--secret-key-seed=2"
- - "--address=/dns6/relay/tcp/4444/p2p/12D3KooWPjceQrSwdWXPyLLeABRXmuqt69Rg3sBYbU1Nft9HyQ6X/p2p-circuit"
+ - "--address=/dns4/relay/tcp/4444/p2p/12D3KooWPjceQrSwdWXPyLLeABRXmuqt69Rg3sBYbU1Nft9HyQ6X/p2p-circuit"
  build:
  context: ../../../.
  dockerfile: ./protocols/relay/examples/Dockerfile
@@ -34,10 +34,10 @@ services:
  client-dial: 
  image: libp2p-relay
  command:
- - "./relay"
+ - "./relay_v1"
  - "--mode=client-dial"
  - "--secret-key-seed=3"
- - "--address=/dns6/relay/tcp/4444/p2p/12D3KooWPjceQrSwdWXPyLLeABRXmuqt69Rg3sBYbU1Nft9HyQ6X/p2p-circuit/p2p/12D3KooWH3uVF6wv47WnArKHk5p6cvgCJEb74UTmxztmQDc298L3"
+ - "--address=/dns4/relay/tcp/4444/p2p/12D3KooWPjceQrSwdWXPyLLeABRXmuqt69Rg3sBYbU1Nft9HyQ6X/p2p-circuit/p2p/12D3KooWH3uVF6wv47WnArKHk5p6cvgCJEb74UTmxztmQDc298L3"
  build:
  context: ../../../.
  dockerfile: ./protocols/relay/examples/Dockerfile
@@ -48,16 +48,4 @@ services:
 
 networks:
  network-a:
- driver: bridge
- enable_ipv6: true
- ipam:
- driver: default
- config:
- - subnet: 2001:3984:3989::/64
  network-b:
- driver: bridge
- enable_ipv6: true
- ipam:
- driver: default
- config:
- - subnet: 2001:3984:3988::/64