fn cmd_raw_rpc>()

in src/vtok_tool/src/main.rs [103:147]
39 lines of code
2 McCabe index (conditional complexity)

fn cmd_raw_rpc<I: Iterator<Item = String>>(mut arg_iter: I) -> Result<(), Error> {
    let mut cli_opts = HashMap::new();

    while let Some(word) = arg_iter.next() {
        match word.as_str() {
            "--server" => {
                let addr = arg_iter
                    .next()
                    .ok_or(Error::UsageError(format!("invalid server addr")))
                    .and_then(|addr| parse_server_addr(addr.as_str()))?;
                cli_opts.insert(word, CliOption::Server(addr));
            }
            _ => return Err(Error::UsageError(format!("unexpected argument: {}", word))),
        }
    }

    let server_addr = match cli_opts.get("--server") {
        Some(CliOption::Server(addr)) => addr,
        _ => return Err(Error::UsageError(format!("missing server address"))),
    };

    fn do_raw_rpc<T: Transport>(mut transport: T) -> Result<(), Error> {
        let request = serde_json::from_reader(std::io::stdin())
            .map_err(|_| Error::UsageError(format!("Invalid RPC request")))?;
        transport
            .send_request(&request)
            .map_err(Error::TransportError)?;
        let response = transport.recv_response().map_err(Error::TransportError)?;

        serde_json::to_writer(std::io::stdout(), &response).map_err(Error::SerdeError)?;

        Ok(())
    }

    match server_addr {
        ServerAddr::Unix(path) => UnixStream::connect(path)
            .map_err(Error::IoError)
            .map(|stream| HttpTransport::new(stream, schema::API_URL))
            .and_then(|xport| do_raw_rpc(xport)),
        ServerAddr::Vsock(addr) => VsockStream::connect(*addr)
            .map_err(Error::IoError)
            .map(|stream| HttpTransport::new(stream, schema::API_URL))
            .and_then(|xport| do_raw_rpc(xport)),
    }
}