Rust 中的 P2P 通信

Question

I am trying to write a P2P node. A node contains a list of peers, opens a listening port to let other nodes establish a communication channel and, at the same time, actively tries to establish the connection with some other chosen nodes. This choice is as such that there is a single connection between each pair of nodes (not implemented in the following snippet).

I am trying to achieve this with Tokio using futures combinators.

main.rs

use failure::Error;

pub mod networking {
    use failure::Error;

    use std::net::SocketAddr;
    use tokio::net::{TcpListener, TcpStream};
    use tokio::prelude::*;

    use crate::Config;
    use futures::Future;

    pub fn start(cfg: &Config) -> Result<(), Error> {
        let myself = cfg.myself.parse::<SocketAddr>()?;
        let others = cfg
            .others
            .iter()
            .filter_map(|s| s.parse().ok())
            .collect::<Vec<SocketAddr>>();

        let server = TcpListener::bind(&myself)?
            .incoming()
            .for_each(|socket| {
                println!("Got a socket: {:?}", socket);
                future::ok(())
            })
            .map_err(|e| eprintln!("Error connecting: {:?}", e));

        let client = TcpStream::connect(&others[0])
            .map(|socket| {
                println!("Got a socket: {:?}", socket);
            })
            .map_err(|e| eprintln!("Error connecting: {:?}", e));

        let future = server.join(client);

        tokio::run(future);

        Ok(())
    }
}

struct Config {
    myself: String,
    others: Vec<String>,
}

fn main() -> Result<(), Error> {
    let config = Config {
        myself: "127.0.0.1:2501".to_string(),
        others: vec!["127.0.0.1:2502".to_string(), "127.0.0.1:2503".to_string()],
    };
    networking::start(&config)
}

( playground )

This does not work:

error[E0271]: type mismatch resolving `<futures::future::join::Join<futures::future::map_err::MapErr<futures::stream::for_each::ForEach<tokio_tcp::incoming::Incoming, [closure@src/main.rs:23:23: 26:14], futures::future::result_::FutureResult<(), std::io::Error>>, [closure@src/main.rs:27:22: 27:64]>, futures::future::map_err::MapErr<futures::future::map::Map<tokio_tcp::stream::ConnectFuture, [closure@src/main.rs:30:18: 32:14]>, [closure@src/main.rs:33:22: 33:64]>> as futures::future::Future>::Item == ()`
  --> src/main.rs:37:9
   |
37 |         tokio::run(future);
   |         ^^^^^^^^^^ expected tuple, found ()
   |
   = note: expected type `((), ())`
              found type `()`
   = note: required by `tokio::runtime::threadpool::run`

I understand what the compiler says, but I have no clue what exactly I have to correct. What should I correct to get the types right?

Answer 1

thanks for the hints,

let future = server.join(client);

has to be corrected to

let future = server.join(client).map(|_| ())