215 lines
7.6 KiB
Rust
215 lines
7.6 KiB
Rust
// SPDX-License-Identifier: MIT
|
|
use alkane_os::hal_wire::{HalClient, HalError};
|
|
use alkane_os::HardwareBackend;
|
|
use std::io::{Read, Write};
|
|
use std::os::unix::net::{UnixListener, UnixStream};
|
|
use std::thread;
|
|
use std::time::{Duration, Instant};
|
|
|
|
fn reply(socket: &mut UnixStream, request: &[u8; 16], body: &[u8]) {
|
|
let mut header = *request;
|
|
header[6..8].copy_from_slice(&1_u16.to_le_bytes());
|
|
header[12..16].copy_from_slice(&(body.len() as u32).to_le_bytes());
|
|
socket.write_all(&header).unwrap();
|
|
socket.write_all(body).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn sdk_backend_round_trip_and_safety_limits() {
|
|
let (client, mut server) = UnixStream::pair().unwrap();
|
|
let worker = thread::spawn(move || {
|
|
let expected = [
|
|
(1, vec![2, 3, 0, 0x55, 0xaa, 0x21], vec![0]),
|
|
(2, vec![2, 8, 0], vec![0, 3, 0, 0xaa, 0x55, 0x01]),
|
|
(3, vec![2, 1], vec![0]),
|
|
(4, vec![0, 90], vec![0]),
|
|
(
|
|
5,
|
|
vec![1],
|
|
[vec![0], 72_500_i32.to_le_bytes().to_vec()].concat(),
|
|
),
|
|
(6, vec![1], vec![0]),
|
|
];
|
|
for (index, (opcode, request_body, response_body)) in expected.iter().enumerate() {
|
|
let mut header = [0_u8; 16];
|
|
server.read_exact(&mut header).unwrap();
|
|
assert_eq!(&header[..4], b"ALKH");
|
|
assert_eq!(header[4], 1);
|
|
assert_eq!(header[5], *opcode);
|
|
assert_eq!(
|
|
u32::from_le_bytes(header[8..12].try_into().unwrap()),
|
|
index as u32 + 1
|
|
);
|
|
let length = u32::from_le_bytes(header[12..16].try_into().unwrap()) as usize;
|
|
let mut body = vec![0_u8; length];
|
|
server.read_exact(&mut body).unwrap();
|
|
assert_eq!(&body, request_body);
|
|
reply(&mut server, &header, response_body);
|
|
}
|
|
});
|
|
let mut backend = HalClient::from_stream(client).unwrap();
|
|
backend.send_frame(2, &[0x55, 0xaa, 0x21]).unwrap();
|
|
let mut buffer = [0_u8; 8];
|
|
assert_eq!(backend.receive_frame(2, &mut buffer).unwrap(), 3);
|
|
assert_eq!(&buffer[..3], &[0xaa, 0x55, 0x01]);
|
|
backend.set_chain_reset(2, true).unwrap();
|
|
backend.set_fan_target(0, 90).unwrap();
|
|
assert_eq!(backend.read_temperature_mc(1).unwrap(), 72_500);
|
|
backend.set_psu_enabled(true).unwrap();
|
|
assert!(matches!(
|
|
backend.set_fan_target(0, 101),
|
|
Err(HalError::InvalidFanPercent)
|
|
));
|
|
assert!(matches!(
|
|
backend.send_frame(0, &[0_u8; 4094]),
|
|
Err(HalError::FrameTooLong)
|
|
));
|
|
worker.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_wrong_response_sequence() {
|
|
let (client, mut server) = UnixStream::pair().unwrap();
|
|
let worker = thread::spawn(move || {
|
|
let mut header = [0_u8; 16];
|
|
server.read_exact(&mut header).unwrap();
|
|
let mut body = [0_u8; 1];
|
|
server.read_exact(&mut body).unwrap();
|
|
header[8..12].copy_from_slice(&2_u32.to_le_bytes());
|
|
header[6..8].copy_from_slice(&1_u16.to_le_bytes());
|
|
header[12..16].copy_from_slice(&1_u32.to_le_bytes());
|
|
server.write_all(&header).unwrap();
|
|
let mut one = [0_u8; 1];
|
|
assert_eq!(server.read(&mut one).unwrap(), 0);
|
|
});
|
|
let mut backend = HalClient::from_stream(client).unwrap();
|
|
assert!(matches!(
|
|
backend.set_psu_enabled(true),
|
|
Err(HalError::Protocol("response sequence mismatch"))
|
|
));
|
|
assert!(matches!(
|
|
backend.set_psu_enabled(true),
|
|
Err(HalError::Protocol("connection is unusable"))
|
|
));
|
|
worker.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn failed_power_off_ends_backend_power_lease() {
|
|
let (client, mut server) = UnixStream::pair().unwrap();
|
|
let worker = thread::spawn(move || {
|
|
let mut header = [0_u8; 16];
|
|
server.read_exact(&mut header).unwrap();
|
|
let mut body = [0_u8; 1];
|
|
server.read_exact(&mut body).unwrap();
|
|
assert_eq!(header[5], 6);
|
|
assert_eq!(body, [0]);
|
|
reply(&mut server, &header, &[3]);
|
|
assert_eq!(server.read(&mut body).unwrap(), 0);
|
|
});
|
|
let mut backend = HalClient::from_stream(client).unwrap();
|
|
assert!(matches!(
|
|
backend.set_psu_enabled(false),
|
|
Err(HalError::Device(3))
|
|
));
|
|
worker.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn malformed_temperature_response_disconnects_power_lease() {
|
|
let (client, mut server) = UnixStream::pair().unwrap();
|
|
let worker = thread::spawn(move || {
|
|
let mut header = [0_u8; 16];
|
|
server.read_exact(&mut header).unwrap();
|
|
let mut request = [0_u8; 1];
|
|
server.read_exact(&mut request).unwrap();
|
|
assert_eq!(header[5], 5);
|
|
reply(&mut server, &header, &[0, 1]);
|
|
assert_eq!(server.read(&mut request).unwrap(), 0);
|
|
});
|
|
let mut backend = HalClient::from_stream(client).unwrap();
|
|
assert!(matches!(
|
|
backend.read_temperature_mc(1),
|
|
Err(HalError::Protocol("invalid temperature response"))
|
|
));
|
|
worker.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_malformed_error_response_and_poisoned_connection() {
|
|
for body in [&[4_u8][..], &[3_u8, 99][..]] {
|
|
let (client, mut server) = UnixStream::pair().unwrap();
|
|
let response = body.to_vec();
|
|
let worker = thread::spawn(move || {
|
|
let mut header = [0_u8; 16];
|
|
server.read_exact(&mut header).unwrap();
|
|
let mut request = [0_u8; 1];
|
|
server.read_exact(&mut request).unwrap();
|
|
reply(&mut server, &header, &response);
|
|
});
|
|
let mut backend = HalClient::from_stream(client).unwrap();
|
|
assert!(matches!(
|
|
backend.set_psu_enabled(true),
|
|
Err(HalError::Protocol("invalid error response"))
|
|
));
|
|
assert!(matches!(
|
|
backend.set_psu_enabled(true),
|
|
Err(HalError::Protocol("connection is unusable"))
|
|
));
|
|
worker.join().unwrap();
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn slow_partial_response_hits_absolute_exchange_deadline() {
|
|
let (client, mut server) = UnixStream::pair().unwrap();
|
|
let worker = thread::spawn(move || {
|
|
let mut header = [0_u8; 16];
|
|
server.read_exact(&mut header).unwrap();
|
|
let mut request = [0_u8; 1];
|
|
server.read_exact(&mut request).unwrap();
|
|
header[6..8].copy_from_slice(&1_u16.to_le_bytes());
|
|
header[12..16].copy_from_slice(&1_u32.to_le_bytes());
|
|
for byte in header.into_iter().chain([0]) {
|
|
if server.write_all(&[byte]).is_err() {
|
|
break;
|
|
}
|
|
thread::sleep(Duration::from_millis(250));
|
|
}
|
|
});
|
|
let mut backend = HalClient::from_stream(client).unwrap();
|
|
let start = Instant::now();
|
|
assert!(matches!(
|
|
backend.set_psu_enabled(true),
|
|
Err(HalError::Io(_))
|
|
));
|
|
assert!(start.elapsed() < Duration::from_secs(4));
|
|
drop(backend);
|
|
worker.join().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn connects_to_a_local_backend_socket() {
|
|
let path = std::env::temp_dir().join(format!(
|
|
"alkane-hal-{}-{}.sock",
|
|
std::process::id(),
|
|
std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.unwrap()
|
|
.as_nanos()
|
|
));
|
|
let listener = UnixListener::bind(&path).unwrap();
|
|
let worker = thread::spawn(move || {
|
|
let (mut server, _) = listener.accept().unwrap();
|
|
let mut header = [0_u8; 16];
|
|
server.read_exact(&mut header).unwrap();
|
|
let mut request = [0_u8; 1];
|
|
server.read_exact(&mut request).unwrap();
|
|
reply(&mut server, &header, &[0]);
|
|
});
|
|
let mut backend = HalClient::connect(&path).unwrap();
|
|
backend.set_psu_enabled(true).unwrap();
|
|
worker.join().unwrap();
|
|
std::fs::remove_file(path).unwrap();
|
|
}
|