diff --git a/README.md b/README.md index 0d47d63..815f4f5 100644 --- a/README.md +++ b/README.md @@ -19,13 +19,13 @@ wip-tui (interactive Worldspace explorer and operation editor) └── wip-protocol descriptors and logical values wip-fs-server (request-time filesystem projection and loopback listener) -├── wip-http standard routes/codecs/envelopes/batching +├── wip-http standard routes/codecs/envelopes ├── wip-host request-scoped publication and dispatch └── wip-interface macro-generated filesystem capabilities wip-public-api-example (workspace-only executable, integration tests, doctest) ├── wip-protocol logical declarations, values, calls, and validation -├── wip-http standard HTTP v1 routes, JSON codecs, envelopes, and batching +├── wip-http standard HTTP v1 routes, JSON codecs, and envelopes │ └── wip-protocol ├── wip-client stateful Known Space, lazy tree, observation, and call runtime │ ├── wip-http @@ -41,13 +41,13 @@ wip-public-api-example (workspace-only executable, integration tests, doctest) | Crate | Responsibility | Does not own | | --- | --- | --- | | `wip-protocol` | Transport-independent descriptors, object/call/result types, logical `Value`s, validation, and stable protocol error categories. | Application DTOs, implementations, persistence, or wire encoding. | -| `wip-http` | Standard WIP over HTTP v1 endpoint/route derivation, UTF-8 JSON codecs, direct success bodies, error/status classification, and retrieval batches. | HTTP I/O, URL scheme or TLS policy, authentication schemes, server frameworks, filesystem projection, or client presentation/cache policy. | +| `wip-http` | Standard WIP over HTTP v1 endpoint/route derivation, UTF-8 JSON codecs, direct success bodies, and error/status classification. | HTTP I/O, URL scheme or TLS policy, authentication schemes, server frameworks, filesystem projection, or client presentation/cache policy. | | `wip-client` | Endpoint/security-context-isolated Known Space, normalized object and interface observations, intent-driven object and descriptor coverage with bounded request deduplication, immutable operation call contexts, stale transitions, and bounded histories. | HTTP I/O, credentials, persistent cache, automatic operation retries, or presentation widgets/events. | | `wip-tui` | Keyboard-only interactive Worldspace tree, selected Entry and qualified operation panes, descriptor-driven argument editing, bounded result/diagnostic rendering, terminal lifecycle, and HTTP I/O workers over `wip-client`. | Independent cache/validator semantics, automatic operation retries, Host internals, backend paths, or persistent state. | | `wip-interface` | The public `WipType`/`interface` authoring API, Rust-to-protocol codecs, generated descriptors, and typed implementation dispatch. | Object publication, backend lifetime, or transport policy. | | `wip-interface-macros` | Procedural-macro expansion used by `wip-interface`. It is not an application dependency. | A supported direct user API. | | `wip-host` | Opaque interface registration, explicit object membership, validator checks, interface-qualified dispatch against one host-owned instance, and descriptor-guided argument decoding inside that same resolution boundary. | Backend atomicity, global object lookup, or network serving. | -| `wip-fs-server` | Linux directory-handle-confined request-time projection, complete depth-bounded observations and bounded file operations, standard `wip-http` dispatch/batch handling, and a loopback HTTP binary. | A new wire profile, implicit symlink following, non-loopback cleartext, authentication policy, TLS termination, or filesystem-wide preregistration. | +| `wip-fs-server` | Linux directory-handle-confined request-time projection, complete depth-bounded observations and bounded file operations, standard `wip-http` dispatch, and a loopback HTTP binary. | A new wire profile, implicit symlink following, non-loopback cleartext, authentication policy, TLS termination, or filesystem-wide preregistration. | | `wip-public-api-example` | An independently compiled consumer of the protocol, authoring, and host public crates. Its DTOs and traits are application-owned; its implementation and backend handle remain host-private. | Reusable library API or a production server. | The boundary is intentional: protocol types describe what can cross a diff --git a/crates/wip-client/tests/adapter.rs b/crates/wip-client/tests/adapter.rs index aec63c5..72bc4bf 100644 --- a/crates/wip-client/tests/adapter.rs +++ b/crates/wip-client/tests/adapter.rs @@ -16,7 +16,7 @@ use wip_protocol::{ }; fn limits() -> Limits { - Limits::new(64 * 1024, 64 * 1024, 64, 64).unwrap() + Limits::new(64 * 1024, 64 * 1024, 64).unwrap() } fn setup() -> (Client, wip_client::SessionId) { diff --git a/crates/wip-client/tests/runtime.rs b/crates/wip-client/tests/runtime.rs index 7dfacc6..789b863 100644 --- a/crates/wip-client/tests/runtime.rs +++ b/crates/wip-client/tests/runtime.rs @@ -17,7 +17,7 @@ use wip_protocol::{ }; fn wire_limits() -> Limits { - Limits::new(64 * 1024, 64 * 1024, 64, 64).unwrap() + Limits::new(64 * 1024, 64 * 1024, 64).unwrap() } #[derive(Clone)] @@ -399,6 +399,67 @@ fn ensure_interface_waits_for_request_and_cache_capacity_without_evicting() { )); } +#[test] +fn independent_retrievals_run_concurrently_and_complete_out_of_order() { + let mut client = client(8, 8, 8, 8); + let session = client + .open_session("https://example.test/wip", SecurityContext::new("subject")) + .unwrap(); + + let first = client.refresh_observed(&session, "/one", 0).unwrap(); + let second = client.refresh_observed(&session, "/two", 0).unwrap(); + let interface = client.prepare_interface(&session, "math").unwrap(); + + assert_eq!(first.request.uri().path(), "/wip/v1/observe"); + assert_eq!(second.request.uri().path(), "/wip/v1/observe"); + assert_eq!(interface.request.uri().path(), "/wip/v1/fetch_interface"); + assert_eq!(client.in_flight_len(), 3); + + client + .complete( + second.id, + observation_response("/two", &object("two", None, b"two")), + ) + .unwrap(); + client + .complete( + interface.id, + encode_fetch_interface_response( + &FetchInterfaceRequest { + interface: "math".into(), + }, + &FetchInterfaceResponse { + interface: "math".into(), + descriptor: descriptor(TypeExpr::Integer), + validator: Some(b"math-v1".to_vec()), + }, + wire_limits(), + ) + .unwrap(), + ) + .unwrap(); + client + .complete( + first.id, + observation_response("/one", &object("one", None, b"one")), + ) + .unwrap(); + + assert_eq!( + client.object(&session, "/one").unwrap().state, + ObservationState::Fresh + ); + assert_eq!( + client.object(&session, "/two").unwrap().state, + ObservationState::Fresh + ); + assert_eq!( + client.interface(&session, "math").unwrap().state, + ObservationState::Fresh + ); + assert_eq!(client.in_flight_len(), 0); +} + #[test] fn newer_refresh_rejects_out_of_order_response_for_the_same_subject() { let mut client = client(8, 8, 8, 8); diff --git a/crates/wip-fs-server/README.md b/crates/wip-fs-server/README.md index 403061f..15c3e8c 100644 --- a/crates/wip-fs-server/README.md +++ b/crates/wip-fs-server/README.md @@ -4,7 +4,7 @@ Worldspace `/` at request time. It does not register the filesystem contents or keep one object instance per entry. It uses `wip-host` for publication and typed operation dispatch and uses the standard `wip-http` routes, JSON codecs, -envelopes, batching, and HTTP status mapping. +envelopes, and HTTP status mapping. ## Security model @@ -118,14 +118,11 @@ curl -sS -X POST http://127.0.0.1:8080/wip/v1/call_operation \ }' ``` -`observe` and `fetch_interface` can also be combined through the standard -`POST /wip/v1/batch` route. `call_operation` is never batchable. - ## Resource and failure behavior `ResourceLimits` bounds request/response bytes, HTTP request-head bytes, JSON -nesting, batch items, file read/write bytes, tree depth/node count, pinned handles, -and active connections/requests. One absolute request deadline covers header and +nesting, file read/write bytes, tree depth/node count, pinned handles, and active +connections/requests. One absolute request deadline covers header and body intake, dispatch, cooperative filesystem work, and response transmission; stalled clients are closed and cannot occupy a worker beyond that bound. Workers accept connections directly, so the listener never moves more than the configured diff --git a/crates/wip-fs-server/src/lib.rs b/crates/wip-fs-server/src/lib.rs index 2dba665..dbf690e 100644 --- a/crates/wip-fs-server/src/lib.rs +++ b/crates/wip-fs-server/src/lib.rs @@ -4,7 +4,7 @@ //! //! - [`wip_protocol`] owns logical requests and responses; //! - [`wip_host`] owns object publication, validators, and typed dispatch; -//! - [`wip_http`] owns routes, JSON, envelopes, batching, and status mapping; +//! - [`wip_http`] owns routes, JSON, envelopes, and status mapping; //! - this crate owns the filesystem capability boundary and the real HTTP listener. //! //! The built-in HTTP listener is intentionally loopback-only. TLS termination, @@ -36,7 +36,7 @@ pub enum AccessMode { /// Bounded resource policy applied by the HTTP adapter and filesystem provider. #[derive(Debug, Clone, Copy)] pub struct ResourceLimits { - /// Standard JSON, body-size, nesting, and batch limits. + /// Standard JSON, body-size, and nesting limits. pub wire: wip_http::Limits, /// Maximum bytes returned by one file read. pub max_file_read_bytes: usize, @@ -59,7 +59,7 @@ pub struct ResourceLimits { impl Default for ResourceLimits { fn default() -> Self { Self { - wire: wip_http::Limits::new(256 * 1024, 2 * 1024 * 1024, 64, 64) + wire: wip_http::Limits::new(256 * 1024, 2 * 1024 * 1024, 64) .expect("default wire limits are nonzero"), max_file_read_bytes: 1024 * 1024, max_file_write_bytes: 1024 * 1024, diff --git a/crates/wip-fs-server/src/server.rs b/crates/wip-fs-server/src/server.rs index d1a99a2..1294e3f 100644 --- a/crates/wip-fs-server/src/server.rs +++ b/crates/wip-fs-server/src/server.rs @@ -9,11 +9,10 @@ use http::header::ALLOW; use http::{Request, Response, StatusCode}; use wip_host::{ExecutionContext, ObjectProvider}; use wip_http::{ - BatchRequestKind, BatchResponse, BatchResponseItem, BatchSuccess, CodecError, EncodeHttpError, - Endpoint, RequestMetadataError, Route, decode_batch_request, decode_call_operation_metadata, - decode_fetch_interface_request, decode_observe_request, encode_batch_error_response, - encode_batch_response, encode_call_operation_response, encode_fetch_interface_response, - encode_observe_response, encode_protocol_error_response, validate_http_request, + CodecError, EncodeHttpError, Endpoint, RequestMetadataError, Route, + decode_call_operation_metadata, decode_fetch_interface_request, decode_observe_request, + encode_call_operation_response, encode_fetch_interface_response, encode_observe_response, + encode_protocol_error_response, validate_http_request, }; use wip_protocol::{ProtocolError, ProtocolErrorCode, ProtocolInteraction}; @@ -81,7 +80,6 @@ impl WipFsServer { Route::Observe => self.observe(request.body(), &context), Route::FetchInterface => self.fetch_interface(request.body()), Route::CallOperation => self.call_operation(request.body(), &context), - Route::Batch => self.batch(request.body(), &context), }; if Instant::now() >= deadline { empty_response(StatusCode::GATEWAY_TIMEOUT) @@ -115,14 +113,9 @@ impl WipFsServer { if uri.query().is_some() { return None; } - [ - Route::Observe, - Route::FetchInterface, - Route::CallOperation, - Route::Batch, - ] - .into_iter() - .find(|route| self.endpoint.route(*route).path() == uri.path()) + [Route::Observe, Route::FetchInterface, Route::CallOperation] + .into_iter() + .find(|route| self.endpoint.route(*route).path() == uri.path()) } fn observe(&self, body: &[u8], context: &ExecutionContext) -> Response> { @@ -221,41 +214,6 @@ impl WipFsServer { } } - fn batch(&self, body: &[u8], context: &ExecutionContext) -> Response> { - let request = match decode_batch_request(body, self.config.limits.wire) { - Ok(request) => request, - Err(error) => return self.batch_codec_error(error), - }; - let responses = request - .requests - .iter() - .map(|item| { - let outcome = match &item.request { - BatchRequestKind::Observe(request) => self - .projection - .observe(context, request) - .map(BatchSuccess::Observe), - BatchRequestKind::FetchInterface(request) => self - .projection - .fetch_interface(request) - .map(BatchSuccess::FetchInterface), - BatchRequestKind::Invalid { error, .. } => Err(error.clone()), - }; - BatchResponseItem { - id: item.id.clone(), - outcome, - } - }) - .collect(); - let response = BatchResponse { responses }; - encode_batch_response(&request, &response, self.config.limits.wire).unwrap_or_else( - |error| match error { - EncodeHttpError::Codec(codec) => self.batch_encode_error(&codec), - EncodeHttpError::Http(_) => self.batch_top_error(&internal_error()), - }, - ) - } - fn metadata_error(&self, error: RequestMetadataError) -> Response> { match error { RequestMetadataError::NotFound => empty_response(StatusCode::NOT_FOUND), @@ -294,17 +252,6 @@ impl WipFsServer { } } - fn batch_codec_error(&self, error: CodecError) -> Response> { - if is_transport_limit(&error) { - empty_response(StatusCode::PAYLOAD_TOO_LARGE) - } else { - self.batch_top_error(&ProtocolError { - code: ProtocolErrorCode::InvalidRequest, - message: "malformed WIP batch request".into(), - }) - } - } - fn read_encode_error( &self, interaction: ProtocolInteraction, @@ -318,14 +265,6 @@ impl WipFsServer { } } - fn batch_encode_error(&self, error: &CodecError) -> Response> { - if is_transport_limit(error) { - empty_response(StatusCode::INTERNAL_SERVER_ERROR) - } else { - self.batch_top_error(&internal_error()) - } - } - fn protocol_error( &self, interaction: ProtocolInteraction, @@ -334,11 +273,6 @@ impl WipFsServer { encode_protocol_error_response(interaction, error, self.config.limits.wire) .unwrap_or_else(|_| empty_response(StatusCode::INTERNAL_SERVER_ERROR)) } - - fn batch_top_error(&self, error: &ProtocolError) -> Response> { - encode_batch_error_response(error, self.config.limits.wire) - .unwrap_or_else(|_| empty_response(StatusCode::INTERNAL_SERVER_ERROR)) - } } /// Bound real HTTP listener for a [`WipFsServer`]. @@ -629,9 +563,7 @@ fn write_all_with_deadline( fn is_transport_limit(error: &CodecError) -> bool { matches!( error, - CodecError::BodyTooLarge { .. } - | CodecError::NestingTooDeep { .. } - | CodecError::TooManyBatchItems { .. } + CodecError::BodyTooLarge { .. } | CodecError::NestingTooDeep { .. } ) } diff --git a/crates/wip-fs-server/tests/end_to_end.rs b/crates/wip-fs-server/tests/end_to_end.rs index d95f557..f67486e 100644 --- a/crates/wip-fs-server/tests/end_to_end.rs +++ b/crates/wip-fs-server/tests/end_to_end.rs @@ -9,11 +9,9 @@ use std::time::{Duration, Instant}; use tempfile::tempdir; use wip_fs_server::{AccessMode, ServerConfig, WipFsServer}; use wip_http::{ - BatchRequest, BatchRequestItem, BatchRequestKind, BatchResponse, BatchSuccess, ClientResponseError, DecodedResponse, Endpoint, JSON_CONTENT_TYPE, Limits, Route, - TransportFailureKind, decode_batch_request, decode_batch_response, - decode_call_operation_response, decode_fetch_interface_response, decode_observe_response, - encode_batch_request, encode_call_operation_request, encode_fetch_interface_request, + TransportFailureKind, decode_call_operation_response, decode_fetch_interface_response, + decode_observe_response, encode_call_operation_request, encode_fetch_interface_request, encode_observe_request, }; use wip_protocol::{ @@ -22,7 +20,7 @@ use wip_protocol::{ }; #[test] -fn real_listener_serves_three_core_interactions_batch_and_write() { +fn real_listener_serves_three_core_interactions_and_write() { let temporary = tempdir().expect("temporary root"); std::fs::write(temporary.path().join("hello.txt"), b"hello world").expect("write file"); std::fs::create_dir(temporary.path().join("nested")).expect("create directory"); @@ -125,36 +123,6 @@ fn real_listener_serves_three_core_interactions_batch_and_write() { ); assert_eq!(read.result, Value::Bytes(b"world".to_vec())); - let batch_request = BatchRequest { - requests: vec![ - BatchRequestItem { - id: "root".into(), - request: BatchRequestKind::Observe(ObserveRequest { - path: "/".into(), - depth: 0, - }), - }, - BatchRequestItem { - id: "tree".into(), - request: BatchRequestKind::Observe(ObserveRequest { - path: "/nested".into(), - depth: 1, - }), - }, - BatchRequestItem { - id: "interface".into(), - request: BatchRequestKind::FetchInterface(read_interface_request.clone()), - }, - ], - }; - let response = exchange( - address, - encode_batch_request(&endpoint, &batch_request, limits).expect("encode batch"), - ); - let batch = - success(decode_batch_response(&batch_request, &response, limits).expect("decode batch")); - assert_batch_successes(&batch); - let write_interface_request = FetchInterfaceRequest { interface: file.interfaces[1].clone(), }; @@ -215,7 +183,7 @@ fn real_listener_serves_three_core_interactions_batch_and_write() { fn real_listener_keeps_route_method_and_malformed_body_boundaries_distinct() { let temporary = tempdir().expect("temporary root"); let mut config = ServerConfig::for_root(temporary.path()); - config.limits.wire = Limits::new(64, 4_096, 64, 4).expect("wire limits"); + config.limits.wire = Limits::new(64, 4_096, 64).expect("wire limits"); let bound = Arc::new( WipFsServer::new(config) .expect("build server") @@ -232,6 +200,7 @@ fn real_listener_keeps_route_method_and_malformed_body_boundaries_distinct() { for uri in [ "/wip/v1/unknown", + "/wip/v1/batch", "/wip/v1/observe?unexpected=true", "/wip/v1/observe/extra", ] { @@ -239,6 +208,7 @@ fn real_listener_keeps_route_method_and_malformed_body_boundaries_distinct() { assert_eq!(response.status(), http::StatusCode::NOT_FOUND); assert!(response.body().is_empty()); assert!(!response.headers().contains_key(http::header::CONTENT_TYPE)); + assert!(!response.headers().contains_key(http::header::ALLOW)); } let wrong_method = exchange( @@ -326,10 +296,10 @@ fn real_listener_keeps_route_method_and_malformed_body_boundaries_distinct() { } #[test] -fn raw_decoder_and_batch_packaging_limits_are_transport_failures() { +fn raw_decoder_limits_are_transport_failures() { let temporary = tempdir().expect("temporary root"); let mut config = ServerConfig::for_root(temporary.path()); - config.limits.wire = Limits::new(4_096, 4_096, 8, 1).expect("wire limits"); + config.limits.wire = Limits::new(4_096, 4_096, 8).expect("wire limits"); let server = WipFsServer::new(config).expect("build server"); let nested = br#"{"path":[[[[[[[[["/"]]]]]]]]],"depth":0}"#; @@ -337,12 +307,6 @@ fn raw_decoder_and_batch_packaging_limits_are_transport_failures() { assert_eq!(response.status(), http::StatusCode::PAYLOAD_TOO_LARGE); assert!(response.body().is_empty()); assert!(!response.headers().contains_key(http::header::CONTENT_TYPE)); - - let batch = br#"{"requests":[{"id":"one","method":"observe","arguments":{"path":"/","depth":0}},{"id":"two","method":"observe","arguments":{"path":"/","depth":0}}]}"#; - let response = server.handle_http(json_request(http::Method::POST, "/wip/v1/batch", batch)); - assert_eq!(response.status(), http::StatusCode::PAYLOAD_TOO_LARGE); - assert!(response.body().is_empty()); - assert!(!response.headers().contains_key(http::header::CONTENT_TYPE)); } #[test] @@ -442,37 +406,6 @@ fn stalled_request_body_times_out_and_releases_the_only_worker() { .expect("listener exits cleanly"); } -#[test] -fn batch_keeps_known_malformed_arguments_item_local() { - let temporary = tempdir().expect("temporary root"); - let config = ServerConfig::for_root(temporary.path()); - let limits = config.limits.wire; - let server = WipFsServer::new(config).expect("build server"); - let endpoint = Endpoint::parse("http://localhost/wip").expect("endpoint"); - let body = br#"{"requests":[{"id":"ok","method":"observe","arguments":{"path":"/","depth":0}},{"id":"bad","method":"observe","arguments":{"path":"/","depth":"bad"}}]}"#; - let logical = decode_batch_request(body, limits).expect("decode item-local invalid request"); - assert!(matches!( - logical.requests[1].request, - BatchRequestKind::Invalid { .. } - )); - let request = http::Request::builder() - .method(http::Method::POST) - .uri(endpoint.route(Route::Batch).as_str()) - .header(http::header::CONTENT_TYPE, JSON_CONTENT_TYPE) - .header(http::header::ACCEPT, "application/json") - .body(body.to_vec()) - .expect("build request"); - let response = server.handle_http(request); - let batch = success( - decode_batch_response(&logical, &response, limits).expect("decode mixed batch response"), - ); - assert!(matches!( - batch.responses[0].outcome, - Ok(BatchSuccess::Observe(_)) - )); - assert!(batch.responses[1].outcome.is_err()); -} - #[test] fn call_argument_decoding_does_not_mask_missing_target() { let temporary = tempdir().expect("temporary root"); @@ -524,7 +457,7 @@ fn read_response_size_failure_is_transport_local() { let temporary = tempdir().expect("temporary root"); std::fs::write(temporary.path().join("large"), vec![b'x'; 2_000]).expect("write file"); let mut config = ServerConfig::for_root(temporary.path()); - config.limits.wire = Limits::new(4_096, 1_024, 64, 64).expect("wire limits"); + config.limits.wire = Limits::new(4_096, 1_024, 64).expect("wire limits"); let limits = config.limits.wire; let server = WipFsServer::new(config).expect("build server"); let endpoint = Endpoint::parse("http://localhost/wip").expect("endpoint"); @@ -579,22 +512,6 @@ fn read_response_size_failure_is_transport_local() { )); } -fn assert_batch_successes(batch: &BatchResponse) { - assert_eq!(batch.responses.len(), 3); - assert!(matches!( - batch.responses[0].outcome, - Ok(BatchSuccess::Observe(_)) - )); - assert!(matches!( - batch.responses[1].outcome, - Ok(BatchSuccess::Observe(_)) - )); - assert!(matches!( - batch.responses[2].outcome, - Ok(BatchSuccess::FetchInterface(_)) - )); -} - fn success(response: DecodedResponse) -> T { match response { DecodedResponse::Success(value) => value, diff --git a/crates/wip-http/src/batch.rs b/crates/wip-http/src/batch.rs deleted file mode 100644 index 85956f0..0000000 --- a/crates/wip-http/src/batch.rs +++ /dev/null @@ -1,548 +0,0 @@ -use std::collections::{BTreeMap, BTreeSet}; - -use http::header::{ACCEPT, CONTENT_TYPE}; -use http::{Method, Request, Response, StatusCode}; -use serde_json::{Map, Value as Json}; -use wip_protocol::{ - FetchInterfaceRequest, FetchInterfaceResponse, INTERFACE_FORMAT_V1, ObserveRequest, - ObserveResponse, ProtocolError, ProtocolErrorCode, ProtocolInteraction, -}; - -use crate::response::{self, DecodedResponse}; -use crate::{ - BodyKind, ClientResponseError, CodecError, EncodeHttpError, Endpoint, InvalidResponseKind, - JSON_CONTENT_TYPE, Limits, Route, codec::has_supported_content_coding, is_json_content_type, - json, -}; - -/// A retrieval method accepted by the standard v1 batch endpoint. -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum BatchMethod { - /// Observe one object and its indexable descendants. - Observe, - /// Fetch one interface descriptor. - FetchInterface, -} - -impl BatchMethod { - fn name(self) -> &'static str { - match self { - Self::Observe => "observe", - Self::FetchInterface => "fetch_interface", - } - } - - fn interaction(self) -> ProtocolInteraction { - match self { - Self::Observe => ProtocolInteraction::Observe, - Self::FetchInterface => ProtocolInteraction::FetchInterface, - } - } -} - -/// One retrieval interaction accepted by the standard v1 batch endpoint. -#[derive(Debug, Clone, PartialEq, Eq)] -pub enum BatchRequestKind { - /// Observe one object and its indexable descendants. - Observe(ObserveRequest), - /// Fetch one interface descriptor. - FetchInterface(FetchInterfaceRequest), - /// A known method whose `arguments` are not a valid logical request. - Invalid { - /// Method that was successfully identified from the item envelope. - method: BatchMethod, - /// Item-local `invalid_request` to return without rejecting other items. - error: ProtocolError, - }, -} - -impl BatchRequestKind { - fn interaction(&self) -> ProtocolInteraction { - match self { - Self::Observe(_) => ProtocolInteraction::Observe, - Self::FetchInterface(_) => ProtocolInteraction::FetchInterface, - Self::Invalid { method, .. } => method.interaction(), - } - } -} - -/// One uniquely identified batch subrequest. -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct BatchRequestItem { - /// Identifier used only to correlate the corresponding subresponse. - pub id: String, - /// Retrieval interaction and arguments. - pub request: BatchRequestKind, -} - -/// A standard v1 batch request. -#[derive(Debug, Clone, PartialEq, Eq)] -pub struct BatchRequest { - /// Independent subrequests. Identifiers must be unique. - pub requests: Vec, -} - -/// Successful result of one batch item. -#[derive(Debug, Clone, PartialEq)] -pub enum BatchSuccess { - /// Successful `observe` result. - Observe(ObserveResponse), - /// Successful `fetch_interface` result. - FetchInterface(FetchInterfaceResponse), -} - -/// One batch subresponse, correlated by `id` rather than array position. -#[derive(Debug, Clone, PartialEq)] -pub struct BatchResponseItem { - /// Identifier copied from its subrequest. - pub id: String, - /// Direct interaction result or canonical item-local protocol failure. - pub outcome: Result, -} - -/// A valid standard v1 batch response. -#[derive(Debug, Clone, PartialEq)] -pub struct BatchResponse { - /// Exactly one response for each requested identifier, in any order. - pub responses: Vec, -} - -fn validate_ids<'a>(ids: impl Iterator, maximum: usize) -> Result<(), CodecError> { - let mut seen = BTreeSet::new(); - let mut count = 0; - for id in ids { - count += 1; - if !seen.insert(id) { - return Err(CodecError::DuplicateBatchId { id: id.into() }); - } - } - if count > maximum { - return Err(CodecError::TooManyBatchItems { - actual: count, - maximum, - }); - } - Ok(()) -} - -fn request_item_to_json(item: &BatchRequestItem) -> Result { - let (method, arguments) = match &item.request { - BatchRequestKind::Observe(value) => ("observe", json::observe_request_to_json(value)), - BatchRequestKind::FetchInterface(value) => ( - "fetch_interface", - json::fetch_interface_request_to_json(value), - ), - BatchRequestKind::Invalid { .. } => { - return Err(CodecError::InvalidField { - field: "requests".into(), - reason: "item-local invalid requests cannot be encoded as client requests".into(), - }); - } - }; - Ok(serde_json::json!({"id": item.id, "method": method, "arguments": arguments})) -} - -fn request_to_json(request: &BatchRequest, limits: Limits) -> Result { - validate_ids( - request.requests.iter().map(|item| item.id.as_str()), - limits.max_batch_items, - )?; - for item in &request.requests { - match &item.request { - BatchRequestKind::Observe(value) => value.validate()?, - BatchRequestKind::FetchInterface(_) | BatchRequestKind::Invalid { .. } => {} - } - } - let requests = request - .requests - .iter() - .map(request_item_to_json) - .collect::, _>>()?; - Ok(serde_json::json!({"requests": requests})) -} - -fn request_from_json(value: &Json, limits: Limits) -> Result { - let fields = exact_object(value, "batch", &["requests"])?; - let values = array(required(fields, "requests")?, "requests")?; - if values.len() > limits.max_batch_items { - return Err(CodecError::TooManyBatchItems { - actual: values.len(), - maximum: limits.max_batch_items, - }); - } - let mut requests = Vec::with_capacity(values.len()); - for (index, value) in values.iter().enumerate() { - let field = format!("requests[{index}]"); - let fields = exact_object(value, &field, &["id", "method", "arguments"])?; - let id = string(required(fields, "id")?, &format!("{field}.id"))?; - let method_name = string(required(fields, "method")?, &format!("{field}.method"))?; - let arguments = required(fields, "arguments")?; - let method = match method_name.as_str() { - "observe" => BatchMethod::Observe, - "fetch_interface" => BatchMethod::FetchInterface, - _ => { - return Err(CodecError::InvalidField { - field: format!("{field}.method"), - reason: "batch supports only observe and fetch_interface".into(), - }); - } - }; - let decoded = match method { - BatchMethod::Observe => { - json::observe_request_from_json(arguments).map(BatchRequestKind::Observe) - } - BatchMethod::FetchInterface => json::fetch_interface_request_from_json(arguments) - .map(BatchRequestKind::FetchInterface), - }; - let request = decoded.unwrap_or_else(|error| BatchRequestKind::Invalid { - method, - error: ProtocolError { - code: ProtocolErrorCode::InvalidRequest, - message: format!("invalid {} arguments: {error}", method.name()), - }, - }); - requests.push(BatchRequestItem { id, request }); - } - validate_ids( - requests.iter().map(|item| item.id.as_str()), - limits.max_batch_items, - )?; - Ok(BatchRequest { requests }) -} - -/// Encodes a batch request using `POST v1/batch`. -pub fn encode_batch_request( - endpoint: &Endpoint, - value: &BatchRequest, - limits: Limits, -) -> Result>, EncodeHttpError> { - let body = json::serialize(&request_to_json(value, limits)?, BodyKind::Request, limits)?; - Ok(Request::builder() - .method(Method::POST) - .uri(endpoint.route(Route::Batch).as_str()) - .header(CONTENT_TYPE, JSON_CONTENT_TYPE) - .header(ACCEPT, "application/json") - .body(body)?) -} - -/// Decodes and validates a batch request body. -pub fn decode_batch_request(body: &[u8], limits: Limits) -> Result { - let value = json::parse(body, BodyKind::Request, limits)?; - request_from_json(&value, limits) -} - -fn success_to_json(success: &BatchSuccess) -> Json { - match success { - BatchSuccess::Observe(value) => json::observe_response_to_json(value), - BatchSuccess::FetchInterface(value) => json::fetch_interface_response_to_json(value), - } -} - -fn response_to_json( - request: &BatchRequest, - response: &BatchResponse, - limits: Limits, -) -> Result { - correlate(request, response, limits)?; - Ok(serde_json::json!({ - "responses": response.responses.iter().map(|item| { - let mut fields = Map::new(); - fields.insert("id".into(), Json::String(item.id.clone())); - match &item.outcome { - Ok(success) => { fields.insert("result".into(), success_to_json(success)); } - Err(error) => { fields.insert("error".into(), response::item_error_to_json(error)); } - } - Json::Object(fields) - }).collect::>() - })) -} - -fn correlate( - request: &BatchRequest, - response: &BatchResponse, - limits: Limits, -) -> Result<(), CodecError> { - validate_ids( - request.requests.iter().map(|item| item.id.as_str()), - limits.max_batch_items, - )?; - validate_ids( - response.responses.iter().map(|item| item.id.as_str()), - limits.max_batch_items, - )?; - let requested: BTreeMap<&str, &BatchRequestKind> = request - .requests - .iter() - .map(|item| (item.id.as_str(), &item.request)) - .collect(); - for item in &response.responses { - let Some(kind) = requested.get(item.id.as_str()) else { - return Err(CodecError::UnexpectedBatchId { - id: item.id.clone(), - }); - }; - match (&item.outcome, *kind) { - (Ok(BatchSuccess::Observe(value)), BatchRequestKind::Observe(request)) => { - request.validate_response(value)?; - } - ( - Ok(BatchSuccess::FetchInterface(value)), - BatchRequestKind::FetchInterface(request), - ) => { - value.validate_for(request)?; - } - ( - Err(error), - BatchRequestKind::Invalid { - error: expected, .. - }, - ) if error == expected => {} - (Err(error), kind) - if !matches!(kind, BatchRequestKind::Invalid { .. }) - && error.code.is_allowed_for(kind.interaction()) => {} - _ => { - return Err(CodecError::BatchInteractionMismatch { - id: item.id.clone(), - }); - } - } - } - for item in &request.requests { - if !response.responses.iter().any(|other| other.id == item.id) { - return Err(CodecError::MissingBatchId { - id: item.id.clone(), - }); - } - } - Ok(()) -} - -/// Encodes a valid batch response. Item failures remain inside HTTP 200. -pub fn encode_batch_response( - request: &BatchRequest, - value: &BatchResponse, - limits: Limits, -) -> Result>, EncodeHttpError> { - let body = json::serialize( - &response_to_json(request, value, limits)?, - BodyKind::Response, - limits, - )?; - Ok(Response::builder() - .status(StatusCode::OK) - .header(CONTENT_TYPE, JSON_CONTENT_TYPE) - .body(body)?) -} - -/// Encodes a top-level batch-envelope failure. -/// -/// Item-local failures belong in [`BatchResponseItem`]. Only `invalid_request` -/// and `internal` may reject the complete batch as protocol failures; packaging -/// and representation limits remain transport-local. -pub fn encode_batch_error_response( - error: &ProtocolError, - limits: Limits, -) -> Result>, EncodeHttpError> { - if !matches!( - error.code, - ProtocolErrorCode::InvalidRequest | ProtocolErrorCode::Internal - ) { - return Err(CodecError::InvalidField { - field: "error.code".into(), - reason: "code is not valid for a top-level batch failure".into(), - } - .into()); - } - let body = json::serialize(&response::error_to_json(error), BodyKind::Response, limits)?; - Ok(Response::builder() - .status(response::status_for_error(error.code)) - .header(CONTENT_TYPE, JSON_CONTENT_TYPE) - .body(body)?) -} - -fn response_from_json( - value: &Json, - request: &BatchRequest, - limits: Limits, -) -> Result { - let fields = exact_object(value, "batch", &["responses"])?; - let values = array(required(fields, "responses")?, "responses")?; - if values.len() > limits.max_batch_items { - return Err(CodecError::TooManyBatchItems { - actual: values.len(), - maximum: limits.max_batch_items, - }); - } - let requested: BTreeMap<&str, &BatchRequestKind> = request - .requests - .iter() - .map(|item| (item.id.as_str(), &item.request)) - .collect(); - let mut responses = Vec::with_capacity(values.len()); - for (index, value) in values.iter().enumerate() { - let field = format!("responses[{index}]"); - let fields = object(value, &field)?; - for name in fields.keys() { - if !["id", "result", "error"].contains(&name.as_str()) { - return Err(CodecError::UnknownField { - field: format!("{field}.{name}"), - }); - } - } - let id = string(required(fields, "id")?, &format!("{field}.id"))?; - let Some(kind) = requested.get(id.as_str()) else { - return Err(CodecError::UnexpectedBatchId { id }); - }; - let outcome = match (fields.get("result"), fields.get("error")) { - (Some(_), Some(_)) | (None, None) => { - return Err(CodecError::InvalidField { - field, - reason: "batch item must contain exactly one of result or error".into(), - }); - } - (None, Some(error)) => { - let error = response::item_error_from_json(error)?; - match kind { - BatchRequestKind::Invalid { - error: expected, .. - } if error == *expected => {} - BatchRequestKind::Invalid { .. } => { - return Err(CodecError::BatchInteractionMismatch { id }); - } - kind if error.code.is_allowed_for(kind.interaction()) => {} - _ => return Err(CodecError::BatchInteractionMismatch { id }), - } - Err(error) - } - (Some(result), None) => Ok(match kind { - BatchRequestKind::Observe(request) => { - let value = json::observe_response_from_json(result)?; - request.validate_response(&value)?; - BatchSuccess::Observe(value) - } - BatchRequestKind::FetchInterface(request) => { - let value = json::fetch_interface_response_from_json(result)?; - value.validate_for(request)?; - BatchSuccess::FetchInterface(value) - } - BatchRequestKind::Invalid { .. } => { - return Err(CodecError::BatchInteractionMismatch { id }); - } - }), - }; - responses.push(BatchResponseItem { id, outcome }); - } - let response = BatchResponse { responses }; - correlate(request, &response, limits)?; - Ok(response) -} - -/// Decodes a batch response, including item-local failures within HTTP 200. -pub fn decode_batch_response>( - request: &BatchRequest, - value: &Response, - limits: Limits, -) -> Result, ClientResponseError> { - if !has_supported_content_coding(value.headers()) { - return Err(response::unsupported_content_coding(value.status())); - } - let valid_content_type = value - .headers() - .get(CONTENT_TYPE) - .and_then(|value| value.to_str().ok()) - .is_some_and(is_json_content_type); - if !valid_content_type { - if value.status().is_success() { - return Err(ClientResponseError::invalid( - InvalidResponseKind::InvalidBatch, - "missing or non-UTF-8 application/json Content-Type", - )); - } - return Err(response::transport_failure(value.status())); - } - let decoded = response::decode( - value.status(), - value.body().as_ref(), - ProtocolInteraction::Observe, - limits, - |json| response_from_json(json, request, limits), - ) - .map_err(|error| match error { - ClientResponseError::InvalidResponse { detail, .. } => { - ClientResponseError::invalid(InvalidResponseKind::InvalidBatch, detail) - } - other => other, - })?; - if let DecodedResponse::ProtocolFailure { error, .. } = &decoded - && !matches!( - error.code, - ProtocolErrorCode::InvalidRequest | ProtocolErrorCode::Internal - ) - { - return Err(ClientResponseError::invalid( - InvalidResponseKind::InvalidBatch, - "protocol code is not valid for a top-level batch failure", - )); - } - if let DecodedResponse::Success(success) = &decoded { - for item in &success.responses { - if let Ok(BatchSuccess::FetchInterface(interface)) = &item.outcome - && interface.descriptor.format != INTERFACE_FORMAT_V1 - { - return Err(ClientResponseError::UnsupportedDescriptorFormat { - format: interface.descriptor.format.clone(), - }); - } - } - } - Ok(decoded) -} - -fn object<'a>(value: &'a Json, field: &str) -> Result<&'a Map, CodecError> { - value.as_object().ok_or_else(|| CodecError::InvalidField { - field: field.into(), - reason: "expected object".into(), - }) -} - -fn exact_object<'a>( - value: &'a Json, - field: &str, - allowed: &[&str], -) -> Result<&'a Map, CodecError> { - let fields = object(value, field)?; - for name in fields.keys() { - if !allowed.contains(&name.as_str()) { - return Err(CodecError::UnknownField { - field: format!("{field}.{name}"), - }); - } - } - Ok(fields) -} - -fn required<'a>(fields: &'a Map, name: &str) -> Result<&'a Json, CodecError> { - fields - .get(name) - .ok_or_else(|| CodecError::MissingField { field: name.into() }) -} - -fn string(value: &Json, field: &str) -> Result { - value - .as_str() - .map(str::to_owned) - .ok_or_else(|| CodecError::InvalidField { - field: field.into(), - reason: "expected string".into(), - }) -} - -fn array<'a>(value: &'a Json, field: &str) -> Result<&'a [Json], CodecError> { - value - .as_array() - .map(Vec::as_slice) - .ok_or_else(|| CodecError::InvalidField { - field: field.into(), - reason: "expected array".into(), - }) -} diff --git a/crates/wip-http/src/endpoint.rs b/crates/wip-http/src/endpoint.rs index 9de5db2..39c53d6 100644 --- a/crates/wip-http/src/endpoint.rs +++ b/crates/wip-http/src/endpoint.rs @@ -15,8 +15,6 @@ pub enum Route { FetchInterface, /// Call one operation. CallOperation, - /// Package independent retrieval interactions. - Batch, } impl Route { @@ -27,7 +25,6 @@ impl Route { Self::Observe => "v1/observe", Self::FetchInterface => "v1/fetch_interface", Self::CallOperation => "v1/call_operation", - Self::Batch => "v1/batch", } } } @@ -82,12 +79,7 @@ impl Endpoint { /// are not route components and therefore never match. #[must_use] pub fn recognize(&self, candidate: &Url) -> Option { - const ROUTES: [Route; 4] = [ - Route::Observe, - Route::FetchInterface, - Route::CallOperation, - Route::Batch, - ]; + const ROUTES: [Route; 3] = [Route::Observe, Route::FetchInterface, Route::CallOperation]; if candidate.query().is_some() || candidate.fragment().is_some() { return None; } diff --git a/crates/wip-http/src/error.rs b/crates/wip-http/src/error.rs index 5b2ddff..0ca0e58 100644 --- a/crates/wip-http/src/error.rs +++ b/crates/wip-http/src/error.rs @@ -10,8 +10,6 @@ pub struct Limits { pub(crate) max_response_bytes: usize, /// Largest accepted JSON container nesting depth. pub(crate) max_nesting: usize, - /// Largest accepted number of batch items. - pub(crate) max_batch_items: usize, } impl Limits { @@ -20,7 +18,6 @@ impl Limits { max_request_bytes: usize, max_response_bytes: usize, max_nesting: usize, - max_batch_items: usize, ) -> Result { if max_request_bytes == 0 { return Err(LimitConfigurationError::ZeroRequestBytes); @@ -31,14 +28,10 @@ impl Limits { if max_nesting == 0 { return Err(LimitConfigurationError::ZeroNesting); } - if max_batch_items == 0 { - return Err(LimitConfigurationError::ZeroBatchItems); - } Ok(Self { max_request_bytes, max_response_bytes, max_nesting, - max_batch_items, }) } @@ -59,12 +52,6 @@ impl Limits { pub const fn max_nesting(self) -> usize { self.max_nesting } - - /// Returns the batch item count limit. - #[must_use] - pub const fn max_batch_items(self) -> usize { - self.max_batch_items - } } /// Why a [`Limits`] configuration is not bounded. @@ -76,8 +63,6 @@ pub enum LimitConfigurationError { ZeroResponseBytes, /// Nesting limit was zero. ZeroNesting, - /// Batch-item limit was zero. - ZeroBatchItems, } impl Display for LimitConfigurationError { @@ -86,7 +71,6 @@ impl Display for LimitConfigurationError { Self::ZeroRequestBytes => "request byte limit must be nonzero", Self::ZeroResponseBytes => "response byte limit must be nonzero", Self::ZeroNesting => "nesting limit must be nonzero", - Self::ZeroBatchItems => "batch item limit must be nonzero", }) } } @@ -148,33 +132,6 @@ pub enum CodecError { }, /// Logical protocol validation rejected the decoded representation. ProtocolValidation(wip_protocol::ValidationError), - /// The batch exceeds its configured item count. - TooManyBatchItems { - /// Actual item count. - actual: usize, - /// Configured maximum. - maximum: usize, - }, - /// Batch item identifiers are not unique. - DuplicateBatchId { - /// Repeated identifier. - id: String, - }, - /// A response contains a batch identifier that was not requested. - UnexpectedBatchId { - /// Unexpected identifier. - id: String, - }, - /// A response omitted a requested batch identifier. - MissingBatchId { - /// Missing identifier. - id: String, - }, - /// A batch item result does not match its requested interaction. - BatchInteractionMismatch { - /// Item identifier. - id: String, - }, } impl Display for CodecError { @@ -202,15 +159,6 @@ impl Display for CodecError { write!(formatter, "field `{field}` is not canonical base64") } Self::ProtocolValidation(error) => error.fmt(formatter), - Self::TooManyBatchItems { actual, maximum } => { - write!(formatter, "batch has {actual} items; maximum is {maximum}") - } - Self::DuplicateBatchId { id } => write!(formatter, "duplicate batch id `{id}`"), - Self::UnexpectedBatchId { id } => write!(formatter, "unexpected batch id `{id}`"), - Self::MissingBatchId { id } => write!(formatter, "missing batch id `{id}`"), - Self::BatchInteractionMismatch { id } => { - write!(formatter, "batch result does not match request `{id}`") - } } } } diff --git a/crates/wip-http/src/lib.rs b/crates/wip-http/src/lib.rs index 1e3cb70..d092fe0 100644 --- a/crates/wip-http/src/lib.rs +++ b/crates/wip-http/src/lib.rs @@ -2,11 +2,11 @@ //! //! This crate owns endpoint and route derivation, UTF-8 JSON encoding, canonical //! success and error response handling, HTTP status mapping, descriptor-guided -//! operation-value conversion, and retrieval batching. It deliberately performs -//! no I/O and depends on no server framework, TLS implementation, filesystem -//! projection, client cache, or presentation layer. URL schemes, TLS, -//! certificates, authentication mechanisms, proxies, and caches are selected by -//! the HTTP implementation and deployment rather than by WIP conformance. +//! operation-value conversion. It deliberately performs no I/O and depends on no +//! server framework, TLS implementation, filesystem projection, client cache, or +//! presentation layer. URL schemes, TLS, certificates, authentication mechanisms, +//! proxies, and caches are selected by the HTTP implementation and deployment +//! rather than by WIP conformance. //! //! Logical values remain owned by [`wip_protocol`]. Validators and `Bytes` are //! encoded in JSON bodies using canonical RFC 4648 Section 4 base64; this crate @@ -17,7 +17,7 @@ //! use wip_protocol::ObserveRequest; //! //! let endpoint = Endpoint::parse("http://example.test/api/wip")?; -//! let limits = Limits::new(64 * 1024, 1024 * 1024, 64, 100)?; +//! let limits = Limits::new(64 * 1024, 1024 * 1024, 64)?; //! let request = encode_observe_request( //! &endpoint, //! &ObserveRequest { path: "/items/123".into(), depth: 0 }, @@ -30,18 +30,12 @@ #![deny(missing_docs)] -mod batch; mod codec; mod endpoint; mod error; mod json; mod response; -pub use batch::{ - BatchMethod, BatchRequest, BatchRequestItem, BatchRequestKind, BatchResponse, - BatchResponseItem, BatchSuccess, decode_batch_request, decode_batch_response, - encode_batch_error_response, encode_batch_request, encode_batch_response, -}; pub use codec::{ CallOperationMetadata, EncodeHttpError, RequestMetadataError, decode_call_operation_metadata, decode_call_operation_request, decode_call_operation_response, decode_fetch_interface_request, diff --git a/crates/wip-http/src/response.rs b/crates/wip-http/src/response.rs index 7f9263d..acdbbf6 100644 --- a/crates/wip-http/src/response.rs +++ b/crates/wip-http/src/response.rs @@ -65,8 +65,6 @@ pub enum InvalidResponseKind { NonCanonicalSuccessStatus, /// A 2xx body was malformed or semantically invalid. InvalidSuccessBody, - /// A batch response did not correlate exactly with its request. - InvalidBatch, } /// A local failure while classifying or validating a peer response. @@ -197,14 +195,7 @@ pub(crate) fn error_to_json(error: &ProtocolError) -> Json { }) } -pub(crate) fn item_error_to_json(error: &ProtocolError) -> Json { - serde_json::json!({ - "code": error_code_name(error.code), - "message": error.message, - }) -} - -pub(crate) fn item_error_from_json(value: &Json) -> Result { +fn protocol_error_from_json(value: &Json) -> Result { let fields = value .as_object() .ok_or_else(|| invalid_field("error", "expected object"))?; @@ -223,7 +214,7 @@ fn envelope_error_from_json(value: &Json) -> Result, Codec if fields.len() != 1 || !fields.contains_key("error") { return Ok(None); } - item_error_from_json(&fields["error"]).map(Some) + protocol_error_from_json(&fields["error"]).map(Some) } fn exact(fields: &Map, allowed: &[&str], parent: &str) -> Result<(), CodecError> { diff --git a/crates/wip-http/tests/batch.rs b/crates/wip-http/tests/batch.rs deleted file mode 100644 index 3fab062..0000000 --- a/crates/wip-http/tests/batch.rs +++ /dev/null @@ -1,408 +0,0 @@ -use wip_http::http::StatusCode; -use wip_http::wip_protocol::{ - FetchInterfaceRequest, FetchInterfaceResponse, INTERFACE_FORMAT_V1, InterfaceDescriptor, - Object, ObjectObservation, ObserveRequest, ProtocolError, ProtocolErrorCode, -}; -use wip_http::{ - BatchMethod, BatchRequest, BatchRequestItem, BatchRequestKind, BatchResponse, - BatchResponseItem, BatchSuccess, ClientResponseError, DecodedResponse, Endpoint, - InvalidResponseKind, Limits, TransportFailureKind, decode_batch_request, decode_batch_response, - encode_batch_error_response, encode_batch_request, encode_batch_response, -}; - -fn limits() -> Limits { - Limits::new(100_000, 100_000, 64, 4).unwrap() -} - -fn observed_item(validator: Option>) -> ObjectObservation { - ObjectObservation { - object: Object { - name: "item".into(), - description: None, - interfaces: vec![], - r#ref: None, - validator, - }, - children: None, - } -} - -fn request() -> BatchRequest { - BatchRequest { - requests: vec![ - BatchRequestItem { - id: "object".into(), - request: BatchRequestKind::Observe(ObserveRequest { - path: "/item".into(), - depth: 0, - }), - }, - BatchRequestItem { - id: "interface".into(), - request: BatchRequestKind::FetchInterface(FetchInterfaceRequest { - interface: "interface-v1".into(), - }), - }, - ], - } -} - -#[test] -fn batch_round_trips_by_unique_id_with_item_failures_and_validators() { - let request = request(); - let endpoint = Endpoint::parse("https://example.test/wip").unwrap(); - let encoded_request = encode_batch_request(&endpoint, &request, limits()).unwrap(); - assert_eq!(encoded_request.uri().path(), "/wip/v1/batch"); - assert_eq!(encoded_request.headers()["accept"], "application/json"); - assert_eq!( - decode_batch_request(encoded_request.body(), limits()).unwrap(), - request - ); - - let response = BatchResponse { - responses: vec![ - BatchResponseItem { - id: "interface".into(), - outcome: Err(ProtocolError { - code: ProtocolErrorCode::InterfaceNotFound, - message: "gone".into(), - }), - }, - BatchResponseItem { - id: "object".into(), - outcome: Ok(BatchSuccess::Observe(observed_item(Some(vec![ - 0, 1, 2, 255, - ])))), - }, - ], - }; - let encoded = encode_batch_response(&request, &response, limits()).unwrap(); - assert_eq!(encoded.status(), StatusCode::OK); - assert!( - std::str::from_utf8(encoded.body()) - .unwrap() - .contains("AAEC/w==") - ); - assert_eq!( - decode_batch_response(&request, &encoded, limits()).unwrap(), - DecodedResponse::Success(response) - ); -} - -#[test] -fn batch_interface_validator_round_trips_in_item_body() { - let request = BatchRequest { - requests: vec![BatchRequestItem { - id: "interface".into(), - request: BatchRequestKind::FetchInterface(FetchInterfaceRequest { - interface: "interface-v1".into(), - }), - }], - }; - let response = BatchResponse { - responses: vec![BatchResponseItem { - id: "interface".into(), - outcome: Ok(BatchSuccess::FetchInterface(FetchInterfaceResponse { - interface: "interface-v1".into(), - descriptor: InterfaceDescriptor { - format: INTERFACE_FORMAT_V1.into(), - documentation: None, - types: vec![], - operations: vec![], - }, - validator: Some(vec![255, 254, 253]), - })), - }], - }; - let encoded = encode_batch_response(&request, &response, limits()).unwrap(); - assert!( - std::str::from_utf8(encoded.body()) - .unwrap() - .contains("//79") - ); - assert_eq!( - decode_batch_response(&request, &encoded, limits()).unwrap(), - DecodedResponse::Success(response) - ); -} - -#[test] -fn malformed_known_method_arguments_are_item_local() { - let body = br#"{ - "requests": [ - {"id":"valid","method":"observe","arguments":{"path":"/item","depth":0}}, - {"id":"invalid","method":"observe","arguments":{"path":"/","depth":"deep"}} - ] - }"#; - let decoded = decode_batch_request(body, limits()).unwrap(); - assert!(matches!( - decoded.requests[0].request, - BatchRequestKind::Observe(_) - )); - let invalid = match &decoded.requests[1].request { - BatchRequestKind::Invalid { method, error } => { - assert_eq!(*method, BatchMethod::Observe); - assert_eq!(error.code, ProtocolErrorCode::InvalidRequest); - error.clone() - } - other => panic!("expected item-local invalid request, got {other:?}"), - }; - - let response = BatchResponse { - responses: vec![ - BatchResponseItem { - id: "valid".into(), - outcome: Ok(BatchSuccess::Observe(observed_item(None))), - }, - BatchResponseItem { - id: "invalid".into(), - outcome: Err(invalid), - }, - ], - }; - let encoded = encode_batch_response(&decoded, &response, limits()).unwrap(); - assert_eq!(encoded.status(), StatusCode::OK); - assert_eq!( - decode_batch_response(&decoded, &encoded, limits()).unwrap(), - DecodedResponse::Success(response) - ); -} - -#[test] -fn invalid_batch_envelopes_are_rejected_at_top_level() { - assert!(decode_batch_request(br#"{}"#, limits()).is_err()); - - let malformed_item = br#"{ - "requests": [ - {"id":"item","method":"observe","arguments":{"path":"/","depth":0},"extra":true} - ] - }"#; - assert!(decode_batch_request(malformed_item, limits()).is_err()); - - let duplicate = br#"{ - "requests": [ - {"id":"same","method":"observe","arguments":{"path":"/a","depth":0}}, - {"id":"same","method":"observe","arguments":{"path":"/b","depth":0}} - ] - }"#; - assert!(decode_batch_request(duplicate, limits()).is_err()); - - let operation = br#"{ - "requests": [ - {"id":"call","method":"call_operation","arguments":{}} - ] - }"#; - assert!(decode_batch_request(operation, limits()).is_err()); - - let too_many = Limits::new(100_000, 100_000, 64, 1).unwrap(); - assert!(decode_batch_request(duplicate, too_many).is_err()); -} - -#[test] -fn resource_limit_is_item_local_and_forbidden_as_a_top_level_batch_error() { - let error = ProtocolError { - code: ProtocolErrorCode::ResourceLimitExceeded, - message: "logical observation limit exceeded".into(), - }; - assert!(encode_batch_error_response(&error, limits()).is_err()); - - let request = request(); - let response = BatchResponse { - responses: vec![ - BatchResponseItem { - id: "object".into(), - outcome: Err(error.clone()), - }, - BatchResponseItem { - id: "interface".into(), - outcome: Err(ProtocolError { - code: ProtocolErrorCode::InterfaceNotFound, - message: "gone".into(), - }), - }, - ], - }; - let encoded = encode_batch_response(&request, &response, limits()).unwrap(); - assert_eq!(encoded.status(), StatusCode::OK); - assert_eq!( - decode_batch_response(&request, &encoded, limits()).unwrap(), - DecodedResponse::Success(response) - ); - - let top_level = wip_http::http::Response::builder() - .status(StatusCode::UNPROCESSABLE_ENTITY) - .header("content-type", "application/json; charset=utf-8") - .body(br#"{"error":{"code":"resource_limit_exceeded","message":"not allowed"}}"#.to_vec()) - .unwrap(); - assert!(matches!( - decode_batch_response(&request, &top_level, limits()).unwrap_err(), - ClientResponseError::InvalidResponse { - kind: InvalidResponseKind::InvalidBatch, - .. - } - )); -} - -#[test] -fn batch_transport_failures_do_not_become_protocol_errors() { - let request = request(); - let bare_413 = wip_http::http::Response::builder() - .status(StatusCode::PAYLOAD_TOO_LARGE) - .body(Vec::::new()) - .unwrap(); - assert!(matches!( - decode_batch_response(&request, &bare_413, limits()).unwrap_err(), - ClientResponseError::TransportBinding(failure) - if failure.status == StatusCode::PAYLOAD_TOO_LARGE - && failure.kind == TransportFailureKind::HttpStatus - )); - - let mut encoded = encode_batch_response( - &request, - &BatchResponse { - responses: vec![ - BatchResponseItem { - id: "object".into(), - outcome: Ok(BatchSuccess::Observe(observed_item(None))), - }, - BatchResponseItem { - id: "interface".into(), - outcome: Err(ProtocolError { - code: ProtocolErrorCode::InterfaceNotFound, - message: "gone".into(), - }), - }, - ], - }, - limits(), - ) - .unwrap(); - encoded - .headers_mut() - .insert("content-encoding", "gzip".parse().unwrap()); - assert!(matches!( - decode_batch_response(&request, &encoded, limits()).unwrap_err(), - ClientResponseError::TransportBinding(failure) - if failure.status == StatusCode::OK - && failure.kind == TransportFailureKind::UnsupportedContentCoding - )); -} - -#[test] -fn batch_success_body_requires_exactly_http_200() { - let request = request(); - let response = BatchResponse { - responses: vec![ - BatchResponseItem { - id: "object".into(), - outcome: Ok(BatchSuccess::Observe(observed_item(None))), - }, - BatchResponseItem { - id: "interface".into(), - outcome: Err(ProtocolError { - code: ProtocolErrorCode::InterfaceNotFound, - message: "gone".into(), - }), - }, - ], - }; - let encoded = encode_batch_response(&request, &response, limits()).unwrap(); - for status in [StatusCode::CREATED, StatusCode::ACCEPTED] { - let mut noncanonical = encoded.clone(); - *noncanonical.status_mut() = status; - assert!(matches!( - decode_batch_response(&request, &noncanonical, limits()).unwrap_err(), - ClientResponseError::InvalidResponse { .. } - )); - } -} - -#[test] -fn top_level_batch_errors_use_the_batch_allowed_code_set() { - let invalid = ProtocolError { - code: ProtocolErrorCode::InvalidRequest, - message: "bad envelope".into(), - }; - let encoded = encode_batch_error_response(&invalid, limits()).unwrap(); - assert_eq!( - decode_batch_response(&request(), &encoded, limits()).unwrap(), - DecodedResponse::ProtocolFailure { - error: invalid, - status_mismatch: None, - } - ); - - let not_found = wip_http::http::Response::builder() - .status(StatusCode::NOT_FOUND) - .header("content-type", "application/json; charset=utf-8") - .body(br#"{"error":{"code":"not_found","message":"not a batch failure"}}"#.to_vec()) - .unwrap(); - assert!(matches!( - decode_batch_response(&request(), ¬_found, limits()).unwrap_err(), - ClientResponseError::InvalidResponse { - kind: InvalidResponseKind::InvalidBatch, - .. - } - )); -} - -#[test] -fn unsupported_batch_descriptor_waits_for_envelope_correlation() { - let duplicate = wip_http::http::Response::builder() - .status(StatusCode::OK) - .header("content-type", "application/json; charset=utf-8") - .body( - br#"{"responses":[{"id":"interface","result":{"interface":"interface-v1","descriptor":{"format":"wip-interface/2","future":true}}},{"id":"interface","result":{"interface":"interface-v1","descriptor":{"format":"wip-interface/2"}}}]}"# - .to_vec(), - ) - .unwrap(); - assert!(matches!( - decode_batch_response(&request(), &duplicate, limits()).unwrap_err(), - ClientResponseError::InvalidResponse { - kind: InvalidResponseKind::InvalidBatch, - .. - } - )); - - let missing = wip_http::http::Response::builder() - .status(StatusCode::OK) - .header("content-type", "application/json; charset=utf-8") - .body( - br#"{"responses":[{"id":"interface","result":{"interface":"interface-v1","descriptor":{"format":"wip-interface/2"}}}]}"# - .to_vec(), - ) - .unwrap(); - assert!(matches!( - decode_batch_response(&request(), &missing, limits()).unwrap_err(), - ClientResponseError::InvalidResponse { - kind: InvalidResponseKind::InvalidBatch, - .. - } - )); - - let request = BatchRequest { - requests: vec![BatchRequestItem { - id: "interface".into(), - request: BatchRequestKind::FetchInterface(FetchInterfaceRequest { - interface: "interface-v1".into(), - }), - }], - }; - assert!(matches!( - decode_batch_response(&request, &missing, limits()).unwrap_err(), - ClientResponseError::UnsupportedDescriptorFormat { format } - if format == "wip-interface/2" - )); -} - -#[test] -fn batch_response_must_have_exactly_the_requested_ids() { - let request = request(); - let missing = BatchResponse { - responses: vec![BatchResponseItem { - id: "object".into(), - outcome: Ok(BatchSuccess::Observe(observed_item(None))), - }], - }; - assert!(encode_batch_response(&request, &missing, limits()).is_err()); -} diff --git a/crates/wip-http/tests/codecs.rs b/crates/wip-http/tests/codecs.rs index 8847ce5..c064ebb 100644 --- a/crates/wip-http/tests/codecs.rs +++ b/crates/wip-http/tests/codecs.rs @@ -18,7 +18,7 @@ use wip_http::{ }; fn limits() -> Limits { - Limits::new(1_000_000, 1_000_000, 100, 100).unwrap() + Limits::new(1_000_000, 1_000_000, 100).unwrap() } fn endpoint() -> Endpoint { @@ -405,16 +405,16 @@ fn malformed_unknown_null_and_noncanonical_base64_are_rejected() { #[test] fn caller_limits_remain_local_codec_failures() { - let tiny = Limits::new(8, 8, 2, 1).unwrap(); + let tiny = Limits::new(8, 8, 2).unwrap(); let too_large = decode_observe_request(br#"{"path":"/long","depth":0}"#, tiny).unwrap_err(); assert!(matches!(&too_large, CodecError::BodyTooLarge { .. })); let nested = br#"{"path":[[["/"]]],"depth":0}"#; - let nesting_limited = Limits::new(1024, 1024, 2, 1).unwrap(); + let nesting_limited = Limits::new(1024, 1024, 2).unwrap(); let too_deep = decode_observe_request(nested, nesting_limited).unwrap_err(); assert!(matches!(&too_deep, CodecError::NestingTooDeep { .. })); - let outbound_limited = Limits::new(1_000_000, 1_000_000, 1, 10).unwrap(); + let outbound_limited = Limits::new(1_000_000, 1_000_000, 1).unwrap(); assert!( encode_call_operation_request( &endpoint(), diff --git a/crates/wip-http/tests/responses.rs b/crates/wip-http/tests/responses.rs index fa031d8..968ac8f 100644 --- a/crates/wip-http/tests/responses.rs +++ b/crates/wip-http/tests/responses.rs @@ -9,7 +9,7 @@ use wip_http::{ }; fn limits() -> Limits { - Limits::new(64 * 1024, 64 * 1024, 32, 16).unwrap() + Limits::new(64 * 1024, 64 * 1024, 32).unwrap() } fn request() -> ObserveRequest { diff --git a/crates/wip-http/tests/routes.rs b/crates/wip-http/tests/routes.rs index 9bbe2ab..26f8810 100644 --- a/crates/wip-http/tests/routes.rs +++ b/crates/wip-http/tests/routes.rs @@ -14,7 +14,6 @@ fn endpoint_preserves_http_and_https_when_resolving_canonical_routes() { (Route::Observe, "v1/observe"), (Route::FetchInterface, "v1/fetch_interface"), (Route::CallOperation, "v1/call_operation"), - (Route::Batch, "v1/batch"), ]; for (route, suffix) in expected { let url = format!("{scheme}://example.test/root/prefix/{suffix}"); @@ -170,6 +169,7 @@ fn invalid_endpoint_components_and_non_routes_are_rejected() { let endpoint = Endpoint::parse("http://example.test/wip").unwrap(); for outside in [ "http://example.test/wip/v1/unknown", + "http://example.test/wip/v1/batch", "http://example.test/wip/v1/observe/extra", "https://example.test/wip/v1/observe", "http://other.test/wip/v1/observe", diff --git a/crates/wip-tui/src/app.rs b/crates/wip-tui/src/app.rs index 122c70f..5c80d96 100644 --- a/crates/wip-tui/src/app.rs +++ b/crates/wip-tui/src/app.rs @@ -939,7 +939,7 @@ mod tests { // A request identity has no public constructor; derive one through the runtime. let mut client = wip_client::Client::new( wip_client::ClientLimits::new(1, 4, 4, 4, 4).unwrap(), - wip_http::Limits::new(1024, 1024, 8, 8).unwrap(), + wip_http::Limits::new(1024, 1024, 8).unwrap(), ); let session = client .open_session( diff --git a/crates/wip-tui/src/runtime.rs b/crates/wip-tui/src/runtime.rs index 34ee793..c85b963 100644 --- a/crates/wip-tui/src/runtime.rs +++ b/crates/wip-tui/src/runtime.rs @@ -862,8 +862,7 @@ fn collect_entries_at( /// Standard bounded wire policy used by the executable and integration tests. #[must_use] pub fn default_wire_limits() -> Limits { - Limits::new(256 * 1024, 2 * 1024 * 1024, 64, 64) - .expect("static runtime wire limits are nonzero") + Limits::new(256 * 1024, 2 * 1024 * 1024, 64).expect("static runtime wire limits are nonzero") } /// Runs the interactive executable using process configuration.