forked from M-Labs/artiq-zynq
92 lines
2.5 KiB
Rust
92 lines
2.5 KiB
Rust
use libasync::smoltcp::TcpStream;
|
|
use libboard_zynq::smoltcp::Error as IoError;
|
|
use log;
|
|
|
|
use crate::proto_async::*;
|
|
|
|
pub enum Error {
|
|
WrongMagic,
|
|
UnknownPacket(u8),
|
|
UnknownLogLevel(u8),
|
|
Io(IoError),
|
|
}
|
|
|
|
impl core::fmt::Debug for Error {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
|
use Error::*;
|
|
match self {
|
|
WrongMagic => write!(f, "Wrong magic string"),
|
|
UnknownPacket(v) => write!(f, "Unknown packet {:#02x}", v),
|
|
UnknownLogLevel(v) => write!(f, "Unknown log level {}", v),
|
|
Io(e) => write!(f, "{}", e),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<IoError> for Error {
|
|
fn from(value: IoError) -> Error {
|
|
Error::Io(value)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum Request {
|
|
GetLog,
|
|
ClearLog,
|
|
PullLog,
|
|
SetLogFilter(log::LevelFilter),
|
|
SetUartLogFilter(log::LevelFilter),
|
|
}
|
|
|
|
pub enum Reply<'a> {
|
|
Success,
|
|
LogContent(&'a str),
|
|
}
|
|
|
|
impl Request {
|
|
pub async fn read_from(stream: &mut TcpStream) -> Result<Self, Error> {
|
|
async fn read_log_level_filter(stream: &mut TcpStream) -> Result<log::LevelFilter, Error> {
|
|
Ok(match read_i8(stream).await? {
|
|
0 => log::LevelFilter::Off,
|
|
1 => log::LevelFilter::Error,
|
|
2 => log::LevelFilter::Warn,
|
|
3 => log::LevelFilter::Info,
|
|
4 => log::LevelFilter::Debug,
|
|
5 => log::LevelFilter::Trace,
|
|
lv => return Err(Error::UnknownLogLevel(lv as u8)),
|
|
})
|
|
}
|
|
|
|
Ok(match read_i8(stream).await? {
|
|
1 => Request::GetLog,
|
|
2 => Request::ClearLog,
|
|
7 => Request::PullLog,
|
|
3 => Request::SetLogFilter(read_log_level_filter(stream).await?),
|
|
6 => Request::SetUartLogFilter(read_log_level_filter(stream).await?),
|
|
ty => return Err(Error::UnknownPacket(ty as u8)),
|
|
})
|
|
}
|
|
|
|
pub async fn read_magic(stream: &mut TcpStream) -> Result<(), Error> {
|
|
if !expect(&stream, b"ARTIQ management\n").await? {
|
|
return Err(Error::WrongMagic);
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl<'a> Reply<'a> {
|
|
pub async fn write_to(&self, stream: &mut TcpStream) -> Result<(), IoError> {
|
|
match *self {
|
|
Reply::Success => {
|
|
write_i8(stream, 1).await?;
|
|
}
|
|
Reply::LogContent(ref log) => {
|
|
write_i8(stream, 2).await?;
|
|
write_chunk(stream, log.as_bytes()).await?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|