feat(storage): full file protocol over per-client shared region (badged clients, owned handles, clamped lengths, ReadOnly on unwritable disk); init loads via libkos::fs; drop boot shared buffer

crates/servers/storage-server/src/tests/protocol.rs

@@ -3,78 +3,58 @@ use crate::protocol::*;
 use server_framework::{Decode, Encode};
 
 #[test]
-fn open_roundtrip() {
-    let path = PackedPath::from_bytes(b"test.txt");
-    let req = StorageRequest::Open { path };
-    assert_eq!(StorageRequest::decode(req.encode()), Some(req));
+fn every_request_roundtrips() {
+    let h = FileHandle::new(3);
+    for req in [
+        StorageRequest::Attach,
+        StorageRequest::Open { path_len: 9 },
+        StorageRequest::Read { handle: h, len: 100 },
+        StorageRequest::Write { handle: h, len: 7 },
+        StorageRequest::Close { handle: h },
+        StorageRequest::FileSize { handle: h },
+        StorageRequest::ListDir { path_len: 1 },
+        StorageRequest::Create { path_len: 5 },
+        StorageRequest::Delete { path_len: 5 },
+        StorageRequest::Mkdir { path_len: 4 },
+    ] {
+        assert_eq!(StorageRequest::decode(req.encode()), Some(req));
+    }
 }
 
 #[test]
-fn read_roundtrip() {
-    let req = StorageRequest::Read { handle: FileHandle::new(3), max_bytes: 512 };
-    assert_eq!(StorageRequest::decode(req.encode()), Some(req));
-}
-
-#[test]
-fn write_roundtrip() {
-    let req = StorageRequest::Write { handle: FileHandle::new(1), data_word: 42 };
-    assert_eq!(StorageRequest::decode(req.encode()), Some(req));
-}
-
-#[test]
-fn close_roundtrip() {
-    let req = StorageRequest::Close { handle: FileHandle::new(5) };
-    assert_eq!(StorageRequest::decode(req.encode()), Some(req));
-}
-
-#[test]
-fn file_size_roundtrip() {
-    let req = StorageRequest::FileSize { handle: FileHandle::new(2) };
-    assert_eq!(StorageRequest::decode(req.encode()), Some(req));
-}
-
-#[test]
-fn handle_response_roundtrip() {
-    let resp = StorageResponse::Handle(FileHandle::new(7));
-    assert_eq!(StorageResponse::decode(resp.encode()), Some(resp));
-}
-
-#[test]
-fn data_response_roundtrip() {
-    let resp = StorageResponse::Data { bytes_read: 256 };
-    assert_eq!(StorageResponse::decode(resp.encode()), Some(resp));
-}
-
-#[test]
-fn all_response_variants() {
-    let variants = [
+fn every_response_roundtrips() {
+    for resp in [
+        StorageResponse::Attached { size: BUFFER_SIZE },
+        StorageResponse::Handle(FileHandle::new(2)),
+        StorageResponse::Data { bytes: 512 },
+        StorageResponse::Written { bytes: 8 },
         StorageResponse::Ok,
+        StorageResponse::DirEntries { count: 3 },
+        StorageResponse::Size(4096),
         StorageResponse::NotFound,
         StorageResponse::Error,
-        StorageResponse::Size(1024),
-        StorageResponse::DirEntries { count: 3 },
-    ];
-    for resp in variants {
+        StorageResponse::ReadOnly,
+        StorageResponse::NotAttached,
+    ] {
         assert_eq!(StorageResponse::decode(resp.encode()), Some(resp));
     }
 }
 
 #[test]
-fn mkdir_roundtrip() {
-    let path = PackedPath::from_bytes(b"mydir");
-    let req = StorageRequest::Mkdir { path };
-    assert_eq!(StorageRequest::decode(req.encode()), Some(req));
+fn handles_that_do_not_fit_are_rejected_not_truncated() {
+    assert_eq!(StorageRequest::decode([2, 0x1_0003, 10, 0]), None);
+    assert_eq!(StorageRequest::decode([4, usize::MAX, 0, 0]), None);
 }
 
 #[test]
-fn invalid_request_returns_none() {
-    assert!(StorageRequest::decode([99, 0, 0, 0]).is_none());
+fn unknown_opcodes_do_not_decode() {
+    assert_eq!(StorageRequest::decode([99, 0, 0, 0]), None);
+    assert_eq!(StorageRequest::decode([usize::MAX, 0, 0, 0]), None);
 }
 
 #[test]
-fn packed_path_roundtrip() {
-    let path = PackedPath::from_bytes(b"hello");
-    let buf = path.to_bytes();
-    assert_eq!(&buf[..5], b"hello");
-    assert_eq!(buf[5], 0);
+fn wire_numbers_are_the_shared_ones() {
+    use types::storage::{op, reply};
+    assert_eq!(StorageRequest::Read { handle: FileHandle::new(0), len: 0 }.encode()[0], op::READ);
+    assert_eq!(StorageResponse::ReadOnly.encode()[0], reply::READ_ONLY);
 }