Function ssb_client::ssb

pub fn ssb<R: AsyncRead, W: AsyncWrite>(
    r: R, 
    w: W
) -> (Client<R, W>, Receive<R, W>, Closed<W>)

Take ownership of an AsyncRead and an AsyncWrite to create an ssb client.

Example

sodiumoxide::init();

let (pk, sk) = load_or_create_keys().unwrap();
let pk = pk.try_into().unwrap();
let sk = sk.try_into().unwrap();
let (ephemeral_pk, ephemeral_sk) = box_::gen_keypair();

let addr = SocketAddr::new(Ipv6Addr::localhost().into(), DEFAULT_TCP_PORT);

current_thread::run(|_| {
    current_thread::spawn(TcpStream::connect(&addr)
                              .and_then(move |tcp| {
        // Performs a secret-handshake and yields an encrypted duplex connection.
        OwningClient::new(tcp,
                          &MAINNET_IDENTIFIER,
                          &pk, &sk,
                          &ephemeral_pk, &ephemeral_sk,
                          &pk)
                .map_err(|(err, _)| err)
    })
      .map_err(|err| panic!("{:?}", err))
      .map(move |connection| {
        let (read, write) = connection.unwrap().split();
        let (mut client, receive, _) = ssb(read, write);
        current_thread::spawn(receive.map_err(|err| panic!("{:?}", err)));

        let (send_request, response) = client.whoami();

        current_thread::spawn(send_request.map_err(|err| panic!("{:?}", err)));
        current_thread::spawn(response
                                  .map(|res| println!("{:?}", res))
                                  .map_err(|err| panic!("{:?}", err))
                                  .and_then(|_| client.close().map_err(|err| panic!("{:?}", err))));
    }))
});