88 lines
3.1 KiB
Rust
88 lines
3.1 KiB
Rust
use server_framework::Server;
|
|
|
|
use crate::filesystem::{FileSystem, DirEntry};
|
|
use crate::protocol::{StorageRequest, StorageResponse};
|
|
|
|
pub struct StorageServer<F: FileSystem> {
|
|
fs: F,
|
|
}
|
|
|
|
impl<F: FileSystem> StorageServer<F> {
|
|
pub fn new(fs: F) -> Self {
|
|
Self { fs }
|
|
}
|
|
|
|
pub fn filesystem(&self) -> &F {
|
|
&self.fs
|
|
}
|
|
}
|
|
|
|
impl<F: FileSystem> Server for StorageServer<F> {
|
|
type Request = StorageRequest;
|
|
type Response = StorageResponse;
|
|
|
|
fn handle(&mut self, request: StorageRequest) -> StorageResponse {
|
|
match request {
|
|
StorageRequest::Open { path } => {
|
|
let buf = path.to_bytes();
|
|
let len = buf.iter().position(|&b| b == 0).unwrap_or(16);
|
|
match self.fs.open(&buf[..len]) {
|
|
Some(h) => StorageResponse::Handle(h),
|
|
None => StorageResponse::NotFound,
|
|
}
|
|
}
|
|
StorageRequest::Read { handle, max_bytes } => {
|
|
let mut buf = [0u8; 512];
|
|
let read_len = max_bytes.min(buf.len());
|
|
match self.fs.read(handle, &mut buf[..read_len]) {
|
|
Some(n) => StorageResponse::Data { bytes_read: n },
|
|
None => StorageResponse::Error,
|
|
}
|
|
}
|
|
StorageRequest::Write { handle, data_word } => {
|
|
let data = data_word.to_le_bytes();
|
|
match self.fs.write(handle, &data) {
|
|
Some(n) => StorageResponse::Written { bytes_written: n },
|
|
None => StorageResponse::Error,
|
|
}
|
|
}
|
|
StorageRequest::Close { handle } => {
|
|
self.fs.close(handle);
|
|
StorageResponse::Ok
|
|
}
|
|
StorageRequest::ListDir { path } => {
|
|
let buf = path.to_bytes();
|
|
let len = buf.iter().position(|&b| b == 0).unwrap_or(16);
|
|
let mut entries = [DirEntry::empty(); 16];
|
|
match self.fs.list_dir(&buf[..len], &mut entries) {
|
|
Some(count) => StorageResponse::DirEntries { count },
|
|
None => StorageResponse::NotFound,
|
|
}
|
|
}
|
|
StorageRequest::Create { path } => {
|
|
let buf = path.to_bytes();
|
|
let len = buf.iter().position(|&b| b == 0).unwrap_or(16);
|
|
match self.fs.create(&buf[..len]) {
|
|
Some(h) => StorageResponse::Handle(h),
|
|
None => StorageResponse::Error,
|
|
}
|
|
}
|
|
StorageRequest::Delete { path } => {
|
|
let buf = path.to_bytes();
|
|
let len = buf.iter().position(|&b| b == 0).unwrap_or(16);
|
|
if self.fs.delete(&buf[..len]) {
|
|
StorageResponse::Ok
|
|
} else {
|
|
StorageResponse::NotFound
|
|
}
|
|
}
|
|
StorageRequest::FileSize { handle } => {
|
|
match self.fs.file_size(handle) {
|
|
Some(size) => StorageResponse::Size(size),
|
|
None => StorageResponse::Error,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|