Struct IpcResponse 

pub struct IpcResponse {
    pub request_id: String,
    pub ok: bool,
    pub result: Option<IpcResult>,
    pub error: Option<DashboardError>,
}

IPC response sent by the target process.

Fields

request_id: String

Request identifier copied from the request.

ok: bool

Whether the request succeeded.

result: Option<IpcResult>

Optional successful result.

error: Option<DashboardError>

Optional structured error.

Implementations

impl IpcResponse

pub fn ok(request_id: impl Into<String>, result: IpcResult) -> Self

Creates a successful IPC response.

Arguments

• request_id: Request identifier copied from the request.
• result: Successful result payload.

Returns

Returns an IpcResponse with ok=true.

Examples found in repository

examples/demo/bootstrap.rs (line 325)

    async fn handle_request(&self, request: IpcRequest) -> IpcResponse {
        // Dispatch the request.
        match self.dispatch(&request).await {
            // Return success response.
            Ok(result) => IpcResponse::ok(request.request_id, result),
            // Return error response.
            Err(error) => IpcResponse::error(request.request_id, error),
            // End dispatch match.
        }
        // End request handling.
    }

pub fn error(request_id: impl Into<String>, error: DashboardError) -> Self

Creates an error IPC response.

Arguments

• request_id: Request identifier copied from the request.
• error: Structured error payload.

Returns

Returns an IpcResponse with ok=false.

Examples found in repository

examples/demo/bootstrap.rs (line 327)

    async fn handle_request(&self, request: IpcRequest) -> IpcResponse {
        // Dispatch the request.
        match self.dispatch(&request).await {
            // Return success response.
            Ok(result) => IpcResponse::ok(request.request_id, result),
            // Return error response.
            Err(error) => IpcResponse::error(request.request_id, error),
            // End dispatch match.
        }
        // End request handling.
    }

    /// Dispatches one request by method.
    ///
    /// # Arguments
    ///
    /// - `request`: Parsed IPC request.
    ///
    /// # Returns
    ///
    /// Returns a typed IPC result.
    async fn dispatch(&self, request: &IpcRequest) -> Result<IpcResult, DashboardError> {
        // Parse the request method.
        let method = IpcMethod::parse(&request.method)?;
        // Dispatch by method.
        match method {
            // Return protocol hello response.
            IpcMethod::Hello => Ok(IpcResult::Hello {
                // Include protocol version.
                protocol_version: DASHBOARD_IPC_PROTOCOL_VERSION.to_owned(),
                // Include registration payload.
                registration: build_registration_payload(&self.config)?,
                // End hello payload.
            }),
            // Return the current demo state.
            IpcMethod::CurrentState => {
                // Build current scenario state.
                let state = self.scenario.state();
                // Return state payload.
                Ok(IpcResult::State {
                    // Include target identifier.
                    target_id: state.target.target_id.clone(),
                    // Include boxed dashboard state.
                    state: Box::new(state),
                    // End state payload.
                })
                // End current state branch.
            }
            // Accept event subscription.
            IpcMethod::EventsSubscribe => Ok(self.subscription("events")),
            // Accept log subscription.
            IpcMethod::LogsTail => Ok(self.subscription("logs")),
            // Dispatch control command methods.
            IpcMethod::CommandRestartChild
            // Continue the demo expression.
            | IpcMethod::CommandPauseChild
            // Continue the demo expression.
            | IpcMethod::CommandResumeChild
            // Continue the demo expression.
            | IpcMethod::CommandQuarantineChild
            // Continue the demo expression.
            | IpcMethod::CommandRemoveChild
            // Continue the demo expression.
            | IpcMethod::CommandAddChild
            // Continue the demo expression.
            | IpcMethod::CommandShutdownTree => self.command_result(request),
            // End method match.
        }
        // End dispatch.
    }

    /// Builds one subscription response.
    ///
    /// # Arguments
    ///
    /// - `subscription`: Subscription kind.
    ///
    /// # Returns
    ///
    /// Returns a subscription result.
    fn subscription(&self, subscription: &str) -> IpcResult {
        // Build the subscription payload.
        IpcResult::Subscription {
            // Include target identifier.
            target_id: self.scenario.target_id().to_owned(),
            // Include subscription kind.
            subscription: subscription.to_owned(),
            // End subscription payload.
        }
        // End subscription construction.
    }

    /// Handles one command request.
    ///
    /// # Arguments
    ///
    /// - `request`: IPC request.
    ///
    /// # Returns
    ///
    /// Returns a command result IPC payload.
    fn command_result(&self, request: &IpcRequest) -> Result<IpcResult, DashboardError> {
        // Decode command parameters.
        let command = decode_command_params(request)?;
        // Apply the command to the scenario.
        let result = self.scenario.command_result(command)?;
        // Return command result payload.
        Ok(IpcResult::CommandResult {
            // Include target identifier.
            target_id: self.scenario.target_id().to_owned(),
            // Include command result.
            result,
            // End command result payload.
        })
        // End command result handling.
    }
    // Continue the demo expression.
}

/// Accepts demo IPC connections until the task is aborted.
///
/// # Arguments
///
/// - `listener`: Bound Unix listener.
/// - `service`: Shared demo service.
/// - `target_id`: Target process identifier.
///
/// # Returns
///
/// This async task has no returned value.
async fn run_accept_loop(listener: UnixListener, service: Arc<DemoIpcService>, target_id: String) {
    // Track connection tasks.
    let mut connections = JoinSet::new();
    // Accept connections until listener failure.
    loop {
        // Wait for either a new connection or a completed task.
        tokio::select! {
            // Accept one socket connection.
            accepted = listener.accept() => {
                // Handle accept result.
                match accepted {
                    // Spawn a connection task.
                    Ok((stream, _)) => {
                        // Clone the shared service.
                        let service = Arc::clone(&service);
                        // Clone the target identifier.
                        let target_id = target_id.clone();
                        // Spawn the per-connection task.
                        connections.spawn(async move {
                            // Handle the socket connection.
                            handle_connection(stream, service, target_id).await
                            // End connection task.
                        });
                    // Continue the demo expression.
                    }
                    // Stop when accept fails.
                    Err(error) => {
                        // Print accept failure.
                        eprintln!("demo IPC accept loop stopped: {error}");
                        // Leave the accept loop.
                        break;
                    // Continue the demo expression.
                    }
                    // End accept match.
                }
            // Continue the demo expression.
            }
            // Collect completed connection tasks.
            Some(joined) = connections.join_next() => {
                // Report task failures.
                if let Err(error) = joined {
                    // Print task failure.
                    eprintln!("demo IPC connection task failed: {error}");
                    // End task error branch.
                }
            // Continue the demo expression.
            }
        // Continue the demo expression.
        }
        // Continue accept loop.
    }
    // End accept loop.
}

/// Handles one newline-delimited JSON IPC connection.
///
/// # Arguments
///
/// - `stream`: Accepted Unix socket.
/// - `service`: Shared demo service.
/// - `target_id`: Target process identifier.
///
/// # Returns
///
/// Returns success when the socket closes cleanly.
async fn handle_connection(
    // Continue the demo expression.
    stream: UnixStream,
    // Continue the demo expression.
    service: Arc<DemoIpcService>,
    // Continue the demo expression.
    target_id: String,
    // Continue the demo expression.
) -> Result<(), DashboardError> {
    // Wrap the stream in a line reader.
    let mut reader = BufReader::new(stream);
    // Read requests until EOF.
    loop {
        // Allocate the request line.
        let mut line = String::new();
        // Read one newline-delimited request.
        let bytes = reader.read_line(&mut line).await.map_err(|error| {
            // Build read error.
            io_error(
                // Continue the demo expression.
                "ipc_read_failed",
                // Continue the demo expression.
                "ipc_read",
                // Continue the demo expression.
                Some(target_id.clone()),
                // Continue the demo expression.
                error,
                // Continue the demo expression.
            )
            // End read error construction.
        })?;
        // Stop when the peer closes the socket.
        if bytes == 0 {
            // Return clean close.
            return Ok(());
            // End EOF branch.
        }
        // Convert the request line into a response.
        let response = response_for_line(&service, line.trim_end()).await;
        // Write the response to the socket.
        write_response(&mut reader, &response, &target_id).await?;
        // Continue reading requests.
    }
    // End connection handling.
}

/// Converts one request line into a response.
///
/// # Arguments
///
/// - `service`: Demo IPC service.
/// - `line`: One request line.
///
/// # Returns
///
/// Returns an IPC response.
async fn response_for_line(service: &DemoIpcService, line: &str) -> IpcResponse {
    // Parse the line.
    match parse_request_line(line) {
        // Dispatch parsed requests.
        Ok(request) => service.handle_request(request).await,
        // Return protocol errors.
        Err(error) => IpcResponse::error("invalid-request", error),
        // End parse match.
    }
    // End response conversion.
}

Trait Implementations

impl Clone for IpcResponse

fn clone(&self) -> IpcResponse

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IpcResponse

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IpcResponse

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for IpcResponse

fn eq(&self, other: &IpcResponse) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for IpcResponse

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for IpcResponse