use std::io::{Read, Write};
use std::time::{Duration, Instant};
use interprocess::local_socket::prelude::*;
use interprocess::local_socket::{GenericNamespaced, ListenerOptions, Stream};
use plughost_core::ipc::{
Hello, MessageReader, PROTOCOL_VERSION, Request, Response, write_message,
};
use super::*;
fn connection() -> (Transport, Stream) {
let name = format!("plughost-transport-test-{:016x}", super::super::random());
let listener = ListenerOptions::new()
.name(name.as_str().to_ns_name::<GenericNamespaced>().unwrap())
.create_sync()
.unwrap();
let peer = Stream::connect(name.as_str().to_ns_name::<GenericNamespaced>().unwrap()).unwrap();
let transport = Transport::new(listener.accept().unwrap()).unwrap();
(transport, peer)
}
fn identify(transport: &mut Transport, peer: &mut Stream) {
write_message(
peer,
&Hello {
protocol: PROTOCOL_VERSION,
token: 42,
},
)
.unwrap();
assert!(matches!(
transport.receive(Duration::from_secs(2)),
Ok(Ok(Incoming::Hello(Hello { token: 42, .. })))
));
}
#[test]
fn an_incomplete_frame_does_not_block_the_supervisors_deadline() {
let (mut transport, mut peer) = connection();
identify(&mut transport, &mut peer);
let mut frame = Vec::new();
write_message(&mut frame, &Response::EditorOpen(true)).unwrap();
peer.write_all(&frame[..2]).unwrap();
let started = Instant::now();
assert!(matches!(
transport.receive(Duration::from_millis(50)),
Err(Stopped::TimedOut)
));
assert!(started.elapsed() < Duration::from_secs(2));
peer.write_all(&frame[2..]).unwrap();
assert!(matches!(
transport.receive(Duration::from_secs(2)),
Ok(Ok(Incoming::Response(Response::EditorOpen(true))))
));
drop(peer);
transport.close();
}
#[test]
fn an_unread_request_does_not_block_the_supervisor_or_cleanup() {
let (mut transport, mut peer) = connection();
identify(&mut transport, &mut peer);
let request = Request::Load {
host: plughost_core::HostIdentity::default(),
plugins: vec![plughost_core::PluginRef {
format: plughost_core::PluginFormat::Clap,
bundle: None,
class_id: "x".repeat(8 * 1024 * 1024),
}],
states: Vec::new(),
activity: 0,
};
let started = Instant::now();
transport.queue(&request).unwrap();
assert!(matches!(
transport.flush(Duration::from_millis(50)),
Err(Stopped::TimedOut)
));
assert!(matches!(
transport.receive(Duration::from_millis(50)),
Err(Stopped::TimedOut)
));
drop(peer);
transport.close();
assert!(started.elapsed() < Duration::from_secs(2));
}
struct Slow(Stream);
impl Read for Slow {
fn read(&mut self, buffer: &mut [u8]) -> std::io::Result<usize> {
std::thread::sleep(Duration::from_micros(200));
let length = buffer.len().min(16 * 1024);
self.0.read(&mut buffer[..length])
}
}
#[test]
fn a_large_request_flushed_in_short_slices_arrives_intact() {
let (mut transport, mut peer) = connection();
identify(&mut transport, &mut peer);
let request = Request::Load {
host: plughost_core::HostIdentity::default(),
plugins: vec![plughost_core::PluginRef {
format: plughost_core::PluginFormat::Clap,
bundle: None,
class_id: (0..8 * 1024 * 1024)
.map(|index| char::from(b'a' + (index % 26) as u8))
.collect(),
}],
states: Vec::new(),
activity: 0,
};
let reader = std::thread::spawn(move || MessageReader::new(Slow(peer)).read::<Request>());
transport.queue(&request).unwrap();
loop {
match transport.flush(Duration::from_millis(1)) {
Ok(()) => break,
Err(Stopped::TimedOut) => continue,
Err(Stopped::Closed) => panic!("the connection closed"),
}
}
assert_eq!(reader.join().unwrap().unwrap(), request);
transport.close();
}