fn run_loop_aux()

in src/reconfig.rs [246:290]

• 39 lines of code
• 4 McCabe index (conditional complexity)

fn run_loop_aux(
    reader: impl Read,
    writer: impl Write + Send + Sync + 'static,
    pool: &ThreadPool,
    fs: &(impl ReconfigurableFS + Send + Sync + Clone + 'static))
    -> Fallible<()> {

    let mut reader = io::BufReader::new(reader);
    let writer = Arc::from(Mutex::from(io::BufWriter::new(writer)));
    let mut stream = serde_json::Deserializer::from_reader(&mut reader).into_iter::<Request>();

    let mut prefixes = Prefixes::new();

    loop {
        let writer = writer.clone();
        match stream.next() {
            Some(Ok(request)) => {
                let fs = fs.clone();
                let used_prefixes = prefixes.register(&request);
                pool.execute(move || {
                    let id = match &request {
                        Request::CreateSandbox(request) => request.id.clone(),
                        Request::DestroySandbox(id) => id.clone(),
                    };
                    let result = handle_request(request, &fs, used_prefixes);
                    if let Err(e) = respond(writer, Some(id), result) {
                        warn!("Failed to write response: {}", e);
                    }
                });
            },
            Some(Err(e)) => {
                assert!(!e.is_eof());  // Handled below.
                let result = Err(format_err!("{}", e));
                respond(writer, None, Err(e.into()))?;
                // Parsing failed due to invalid JSON data.  Would be nice to recover from this by
                // advancing the stream to the next valid request, but this is currently not
                // possible; see https://github.com/serde-rs/json/issues/70.
                return result;
            },
            None => {
                return Ok(());
            }
        };
    }
}