further split treetest modules and docs

2026-06-09 06:47:59 -06:00 · 2026-04-24 17:21:39 -06:00
parent 539d98a9e9
commit 943c820f30
16 changed files with 1450 additions and 1336 deletions
@@ -0,0 +1,127 @@
+//! Application-procedure handling layered over protocol calls.
+
+use unshell::protocol::{CallMessage, PacketHeader};
+
+use crate::model::{EndpointProcedureKind, EndpointProcedureSpec, NodeId};
+
+use super::super::super::types::{SimError, Simulation};
+
+impl Simulation {
+    pub(super) fn handle_application_call(
+        &mut self,
+        node_id: NodeId,
+        _header: &PacketHeader,
+        message: &CallMessage,
+    ) -> Result<(), SimError> {
+        let Some(hook) = &message.response_hook else {
+            return Ok(());
+        };
+
+        let procedure = self
+            .lookup_endpoint_procedure(node_id, &message.procedure_id)?
+            .clone();
+        match procedure.kind {
+            EndpointProcedureKind::Ping => {
+                let reply = format!("pong from {}", self.node(node_id).display_path());
+                let frame = self.nodes[node_id.0]
+                    .endpoint
+                    .make_data(
+                        hook.return_path.clone(),
+                        hook.hook_id,
+                        procedure.procedure_id.clone(),
+                        reply.clone().into_bytes(),
+                        true,
+                    )
+                    .map_err(|error| SimError::Protocol(error.to_string()))?;
+                self.record_trace(node_id, format!("endpoint sent ping reply: {reply}"));
+                self.process_local_frame(node_id, frame)?;
+            }
+            EndpointProcedureKind::ChunkedGreeting => {
+                for (index, text) in [
+                    "chunk 1: hello from the endpoint",
+                    "chunk 2: routing stayed path-based",
+                    "chunk 3: hook complete",
+                ]
+                .iter()
+                .enumerate()
+                {
+                    let frame = self.nodes[node_id.0]
+                        .endpoint
+                        .make_data(
+                            hook.return_path.clone(),
+                            hook.hook_id,
+                            procedure.procedure_id.clone(),
+                            text.as_bytes().to_vec(),
+                            index == 2,
+                        )
+                        .map_err(|error| SimError::Protocol(error.to_string()))?;
+                    self.record_trace(node_id, format!("endpoint sent chunk {}", index + 1));
+                    self.process_local_frame(node_id, frame)?;
+                }
+            }
+            EndpointProcedureKind::Chat => {
+                self.chat_sessions.insert(
+                    hook.hook_id,
+                    super::super::super::types::ChatSession {
+                        node_id,
+                        hook_id: hook.hook_id,
+                        host_path: hook.return_path.clone(),
+                        procedure_id: procedure.procedure_id.clone(),
+                    },
+                );
+                let frame = self.nodes[node_id.0]
+                    .endpoint
+                    .make_data(
+                        hook.return_path.clone(),
+                        hook.hook_id,
+                        procedure.procedure_id.clone(),
+                        b"chat ready".to_vec(),
+                        false,
+                    )
+                    .map_err(|error| SimError::Protocol(error.to_string()))?;
+                self.record_trace(node_id, "chat handler opened session".to_owned());
+                self.process_local_frame(node_id, frame)?;
+            }
+        }
+        Ok(())
+    }
+
+    pub(super) fn lookup_endpoint_procedure(
+        &self,
+        node_id: NodeId,
+        procedure_id: &str,
+    ) -> Result<&EndpointProcedureSpec, SimError> {
+        self.node(node_id)
+            .endpoint_procedures
+            .iter()
+            .find(|procedure| procedure.procedure_id == procedure_id)
+            .ok_or_else(|| SimError::UnknownProcedure {
+                node_path: self.node(node_id).display_path(),
+                procedure_id: procedure_id.to_owned(),
+            })
+    }
+
+    pub(crate) fn require_leaf(
+        &self,
+        node_id: NodeId,
+        leaf_name: &str,
+    ) -> Result<&crate::model::LeafSpec, SimError> {
+        self.node(node_id)
+            .leaves
+            .iter()
+            .find(|leaf| leaf.name == leaf_name)
+            .ok_or_else(|| SimError::UnknownLeaf {
+                node_path: self.node(node_id).display_path(),
+                leaf_name: leaf_name.to_owned(),
+            })
+    }
+
+    pub(crate) fn require_endpoint_procedure(
+        &self,
+        node_id: NodeId,
+        procedure_id: &str,
+    ) -> Result<(), SimError> {
+        self.lookup_endpoint_procedure(node_id, procedure_id)
+            .map(|_| ())
+    }
+}