Struct ServerInstance 

pub struct ServerInstance {

    pub id: ServerId,
    pub port: u16,
    pub protocol_name: String,
    pub instruction: String,
    pub memory: String,
    pub status: ServerStatus,
    pub connections: HashMap<ConnectionId, ConnectionState>,
    pub created_at: Instant,
    pub status_changed_at: Instant,
    pub local_addr: Option<SocketAddr>,
    pub startup_params: Option<Value>,
    pub event_handler_config: Option<EventHandlerConfig>,
    pub protocol_data: Value,
    pub log_files: HashMap<String, PathBuf>,
    pub feedback_instructions: Option<String>,
    pub feedback_buffer: Vec<Value>,
    pub last_feedback_processed: Option<Instant>,
    pub recent_connections: VecDeque<ClosedConnectionSummary>,
    pub connection_opened_at: HashMap<ConnectionId, Instant>,
}

A server instance with its own connections, state, and configuration

Clone is derived. It used to hold a JoinHandle — which is not Clone — so every caller that wanted a copy wrote the fields out by hand and each new field had to be added to all four copies or be silently dropped. Background tasks now live in AppState::register_server_task, so the handle is gone and the hand-written copies with it.

Fields

id: ServerId

Unique server ID

port: u16

Listening port

protocol_name: String

Protocol name (e.g., “TCP”, “HTTP”, “SSH”)

instruction: String

User instructions for this server

memory: String

LLM memory for this server

status: ServerStatus

Server status

connections: HashMap<ConnectionId, ConnectionState>

Active connections for this server

created_at: Instant

When the server was created

status_changed_at: Instant

When the server status last changed (for cleanup reaper)

local_addr: Option<SocketAddr>

Local listening address

startup_params: Option<Value>

Protocol-specific startup parameters

event_handler_config: Option<EventHandlerConfig>

Event handler configuration for handling protocol events

protocol_data: Value

Protocol-specific server data (flexible storage)

This replaces protocol-specific feature-gated fields. Each protocol can store any data structure here by serializing to JSON. Use get_protocol_data() and set_protocol_data() helper methods.

log_files: HashMap<String, PathBuf>

Log file paths (output_name -> log_file_path)

feedback_instructions: Option<String>

Feedback instructions for automatic server adjustment When set, network requests can provide feedback that triggers LLM-based server adjustments

feedback_buffer: Vec<Value>

Accumulated feedback buffer (cleared after processing) Each entry is a JSON value containing feedback data

last_feedback_processed: Option<Instant>

Last time feedback was processed (for debouncing)

recent_connections: VecDeque<ClosedConnectionSummary>

Recently closed connections, newest first, capped at RECENT_CONNECTION_CAPACITY.

connection_opened_at: HashMap<ConnectionId, Instant>

When each live connection was added, for ClosedConnectionSummary::opened_unix_ms. ConnectionState itself is built as a struct literal in ~117 protocol call sites, so the open-time lives here instead of as a new field there. Public only because ServerInstance is built as a struct literal in a few places; treat it as add_connection/remove_connection bookkeeping.

Implementations

impl ServerInstance

pub fn new( id: ServerId, port: u16, protocol_name: String, instruction: String, ) -> Self

Create a new server instance

pub fn get_protocol_data<T: DeserializeOwned>(&self) -> Result<T, Error>

Get protocol-specific data

pub fn set_protocol_data<T: Serialize>(&mut self, data: T) -> Result<(), Error>

Set protocol-specific data

pub fn get_protocol_field(&self, key: &str) -> Option<&Value>

Get a field from protocol data

pub fn set_protocol_field(&mut self, key: String, value: Value)

Set a field in protocol data

pub fn get_or_create_log_path(&mut self, output_name: &str) -> Result<PathBuf>

Get or create a log file path for the given output name.

Format: netget_<output_name>_<timestamp>_s<server id>.log, in the process’s working directory. The timestamp is when the server was created, so every line a server writes to one output name lands in one file for that server’s whole life.

The server id is what makes the name unique, and it was missing. The timestamp has one-second resolution, so two servers started in the same second and asked for the same output name — which is the norm, since access_logs is the name eleven tests and most example prompts use — produced the same path and appended into each other’s file. Nothing detected that: each server’s own log_files map is per-server and perfectly consistent, so both believed they owned the file.

output_name is model-authored and becomes part of a filename, so it is checked against the same allowlist as a database name and refused otherwise. The prefix and suffix meant .. could only escape through a directory literally named netget_<x> in the working directory, which is one mkdir away from an append into any file the process can write, and append_to_log is offered to the model on network events.

pub fn summary(&self) -> String

Get a summary for display

pub fn add_connection(&mut self, state: ConnectionState)

Add a connection to this server

pub fn remove_connection(&mut self, id: ConnectionId) -> Option<ConnectionState>

Remove a connection from this server, remembering it in Self::recent_connections.

pub fn get_connection(&self, id: ConnectionId) -> Option<&ConnectionState>

Get a connection by ID

pub fn get_connection_mut( &mut self, id: ConnectionId, ) -> Option<&mut ConnectionState>

Get a mutable connection by ID

pub fn get_all_connections(&self) -> Vec<&ConnectionState>

Get all connections

pub fn cleanup_old_connections(&mut self, max_age_secs: u64)

Clean up old connectionless protocol entries (UDP, DNS, etc.)

Trait Implementations

impl Clone for ServerInstance

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ServerInstance

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.