polypty 0.1.0

Agent-aware terminal multiplexer with sidebar tabs and nested panes
Documentation
use std::io::Write;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{self, Receiver, SyncSender, TrySendError};
use std::sync::Arc;
use std::thread;
use std::time::Duration;

use crate::tab::pty::input::{writer_loop, PtyInput};

struct GateWriter {
    entered: SyncSender<()>,
    release: Option<Receiver<()>>,
}

impl Write for GateWriter {
    fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
        if let Some(release) = self.release.take() {
            self.entered.send(()).unwrap();
            release.recv().unwrap();
        }
        Ok(bytes.len())
    }

    fn flush(&mut self) -> std::io::Result<()> {
        Ok(())
    }
}

#[test]
fn blocked_pty_writer_does_not_block_input_producers() {
    let (input_tx, input_rx) = mpsc::sync_channel(2);
    let (entered_tx, entered_rx) = mpsc::sync_channel(0);
    let (release_tx, release_rx) = mpsc::sync_channel(0);
    let query_in_flight = Arc::new(AtomicBool::new(true));
    let writer_flag = Arc::clone(&query_in_flight);
    let writer = thread::spawn(move || {
        writer_loop(
            Box::new(GateWriter {
                entered: entered_tx,
                release: Some(release_rx),
            }),
            input_rx,
            writer_flag,
        )
    });

    input_tx.try_send(PtyInput::Query(vec![1])).unwrap();
    entered_rx.recv_timeout(Duration::from_secs(1)).unwrap();
    input_tx.try_send(PtyInput::User(vec![2])).unwrap();
    input_tx.try_send(PtyInput::User(vec![3])).unwrap();
    assert!(matches!(
        input_tx.try_send(PtyInput::User(vec![4])),
        Err(TrySendError::Full(_))
    ));
    release_tx.send(()).unwrap();
    drop(input_tx);
    writer.join().unwrap();
    assert!(!query_in_flight.load(Ordering::Acquire));
}