sute/src/schema/authentication.rs

pub struct Authentication {
    inner: auth_capnp::authentication::Client,
}
impl fmt::Debug for Authentication {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Authentication")
            .field("inner", &self.inner.type_id())
            .finish()
    }
}

impl Authentication {
    pub fn new(inner: auth_capnp::authentication::Client) -> Self {
        Self { inner }
    }

    pub async fn mechanisms(&mut self) -> Vec<String> {
        let req = self.inner.mechanisms_request().send().promise;
        let res = req.await.unwrap();
        let tmp = res.get().unwrap();
        tmp.get_mechs().unwrap().iter().map(|x| x.unwrap().to_string()).collect()
    }
}

async fn handshake(log: Logger, mut stream: &mut TcpStream) -> Result<(), io::Error> {
    let host = "localhost";
    let program = format!("{}-{}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION"));
    let version = (0u32,1u32);

    let mut message = capnp::message::Builder::new_default();
    let mut builder = message.init_root::<connection_capnp::greeting::Builder>();

    builder.set_host(host);
    builder.set_major(version.0);
    builder.set_minor(version.1);
    builder.set_program(&program);

    capnp_futures::serialize::write_message(&mut stream, message).await.unwrap();
    if let Some(m) = capnp_futures::serialize::read_message(&mut stream, Default::default()).await.unwrap() {
        let greeting = m.get_root::<connection_capnp::greeting::Reader>().unwrap();
        let peer_host = greeting.get_host().unwrap();
        let peer_program = greeting.get_program().unwrap();
        let major = greeting.get_major();
        let minor = greeting.get_minor();

        info!(log, "Peer {} running {} API {}.{}", peer_host, peer_program, major, minor)
    } else {
        error!(log, "Oh noes");
    }

    Ok(())
}