wip: work on probe crate

Author: cilki

Cargo.lock

@@ -46,6 +46,7 @@ futures = "0.3.30"
 futures-util = "0.3.31"
 headers = "0.4.1"
 image = "0.25.5"
+macaddr = { version = "1", features = ["serde"] }
 native_db = { git = "https://github.com/vincent-herlemont/native_db", features = [
   "tokio",
 ] }

Cargo.toml

@@ -6,7 +6,7 @@
 
 use bevy::prelude::*;
 use bevy_egui::egui;
-use sandpolis_core::{InstanceId, LayerName};
+use sandpolis_core::{InstanceId, InstanceType, LayerName};
 
 /// Trait for layer-specific GUI extensions.
 ///
@@ -56,6 +56,22 @@ pub trait LayerGuiExtension: Send + Sync + 'static {
     fn register_systems(&self, app: &mut App) {
         let _ = app;
     }
+
+    /// Returns which instance types should be visible when this layer is active.
+    ///
+    /// By default, all instance types are visible. Layers can override this
+    /// to filter which nodes appear in the world view.
+    fn visible_instance_types(&self) -> &'static [InstanceType] {
+        &[InstanceType::Server, InstanceType::Agent, InstanceType::Client]
+    }
+
+    /// Returns whether probe nodes should be visible when this layer is active.
+    ///
+    /// Probes are special nodes that are attached to agents. By default, probes
+    /// are not visible. Only the Probe layer should return true.
+    fn show_probe_nodes(&self) -> bool {
+        false
+    }
 }
 
 /// Information about an activity type that can be visualized.

sandpolis-client/src/gui/layer_ext.rs

@@ -1,9 +1,10 @@
 use crate::gui::input::CurrentLayer;
+use crate::gui::layer_ext::get_extension_for_layer;
 use crate::gui::node::{NeedsScaling, NodeEntity, NodeSvg};
 use crate::gui::queries;
 use bevy::prelude::*;
 use bevy_svg::prelude::{Origin, Svg2d};
-use sandpolis_core::LayerName;
+use sandpolis_core::{InstanceType, LayerName};
 
 /// Update node SVG images when layer changes or for newly spawned nodes
 pub fn update_node_svgs_for_layer(
@@ -208,3 +209,71 @@ fn get_layer_color_tint(
         _ => Color::WHITE, // No tint for other layers
     }
 }
+
+/// Update node visibility based on the current layer's visible instance types.
+///
+/// Each layer can specify which instance types (Server, Agent, Client) should be
+/// visible when that layer is active. This system hides nodes that don't match
+/// the current layer's filter criteria.
+pub fn update_node_visibility_for_layer(
+    current_layer: Res<CurrentLayer>,
+    mut node_query: Query<(&NodeEntity, &mut Visibility)>,
+) {
+    // Only update when layer changes
+    if !current_layer.is_changed() {
+        return;
+    }
+
+    // Get the visible instance types for the current layer
+    let visible_types = get_visible_instance_types_for_layer(&current_layer);
+
+    for (node_entity, mut visibility) in node_query.iter_mut() {
+        let instance_id = node_entity.instance_id;
+
+        // Check if this node's instance type matches any of the visible types
+        let should_be_visible = visible_types.iter().any(|instance_type| {
+            instance_id.is_type(*instance_type)
+        });
+
+        *visibility = if should_be_visible {
+            Visibility::Inherited
+        } else {
+            Visibility::Hidden
+        };
+    }
+}
+
+/// Get the visible instance types for a layer.
+///
+/// This checks if there's a LayerGuiExtension for the layer and uses its
+/// visible_instance_types() method. If no extension exists, falls back to
+/// default behavior based on layer name.
+fn get_visible_instance_types_for_layer(layer: &LayerName) -> &'static [InstanceType] {
+    // First, check if there's a registered extension for this layer
+    if let Some(ext) = get_extension_for_layer(layer) {
+        return ext.visible_instance_types();
+    }
+
+    // Fall back to default behavior based on layer name
+    match layer.name() {
+        // Network layer shows all instance types
+        "Network" => &[InstanceType::Server, InstanceType::Agent, InstanceType::Client],
+
+        // Agent-focused layers only show servers and agents
+        "Inventory" | "Filesystem" | "Shell" | "Desktop" | "Probe" => {
+            &[InstanceType::Server, InstanceType::Agent]
+        }
+
+        // Client layer only shows servers and clients
+        "Client" => &[InstanceType::Server, InstanceType::Client],
+
+        // Server layer only shows servers
+        "Server" => &[InstanceType::Server],
+
+        // Agent layer only shows servers and agents
+        "Agent" => &[InstanceType::Server, InstanceType::Agent],
+
+        // Default: show all
+        _ => &[InstanceType::Server, InstanceType::Agent, InstanceType::Client],
+    }
+}

sandpolis-client/src/gui/layer_visuals.rs

@@ -194,6 +194,8 @@ pub enum InstanceType {
     /// Sandpolis network. All networks include at least one server
     /// instance.
     Server,
+    // Probes are not technically instances, but they can connect to proper
+    // agents/server instances and appear like standalone instances.
 }
 
 impl InstanceType {

sandpolis-core/src/lib.rs

@@ -142,6 +142,11 @@ impl LayerGuiExtension for DesktopGuiExtension {
             size: 10.0,
         }]
     }
+
+    fn visible_instance_types(&self) -> &'static [sandpolis_core::InstanceType] {
+        // Desktop layer shows servers and agents (not clients)
+        &[sandpolis_core::InstanceType::Server, sandpolis_core::InstanceType::Agent]
+    }
 }
 
 /// Static instance of the desktop GUI extension.

sandpolis-desktop/src/client/gui.rs

@@ -323,6 +323,11 @@ impl LayerGuiExtension for FilesystemGuiExtension {
             size: 8.0,
         }]
     }
+
+    fn visible_instance_types(&self) -> &'static [sandpolis_core::InstanceType] {
+        // Filesystem layer shows servers and agents (not clients)
+        &[sandpolis_core::InstanceType::Server, sandpolis_core::InstanceType::Agent]
+    }
 }
 
 /// Static instance of the filesystem GUI extension.

sandpolis-filesystem/src/client/gui.rs

@@ -356,6 +356,11 @@ impl LayerGuiExtension for InventoryGuiExtension {
             size: 7.0,
         }]
     }
+
+    fn visible_instance_types(&self) -> &'static [sandpolis_core::InstanceType] {
+        // Inventory layer shows servers and agents (not clients)
+        &[sandpolis_core::InstanceType::Server, sandpolis_core::InstanceType::Agent]
+    }
 }
 
 /// Static instance of the inventory GUI extension.

sandpolis-inventory/src/client/gui.rs

@@ -48,7 +48,7 @@ use url::Url;
 pub mod cli;
 pub mod config;
 pub mod messages;
-pub mod routes;
+pub mod ping;
 pub mod stream;
 
 #[cfg(feature = "server")]

sandpolis-network/src/lib.rs

@@ -1,24 +1,6 @@
 use sandpolis_core::InstanceId;
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize)]
-pub struct PingRequest {
-    pub id: InstanceId,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct PingResponse {
-    pub time: u64,
-    pub id: InstanceId,
-    pub from: Option<Box<PingResponse>>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct PollRequest;
-
-#[derive(Serialize, Deserialize)]
-pub struct PollResponse(Vec<u8>);
-
 /// Request the server for a new direct connection to an agent.
 #[cfg(any(feature = "server", feature = "client"))]
 #[derive(Serialize, Deserialize)]