Struct MountainVinegRPCService 

pub struct MountainVinegRPCService {
    ApplicationHandle: AppHandle,
    RunTime: Arc<ApplicationRunTime>,
    ActiveOperations: Arc<RwLock<HashMap<u64, CancellationToken>>>,
}

The concrete implementation of the MountainService gRPC service.

This service handles all incoming RPC calls from the Cocoon sidecar, validating requests, dispatching to appropriate handlers, and returning responses in the expected gRPC format.

Fields

ApplicationHandle: AppHandle

Tauri application handle for VS Code integration

RunTime: Arc<ApplicationRunTime>

Application runtime containing core dependencies

ActiveOperations: Arc<RwLock<HashMap<u64, CancellationToken>>>

Registry of active operations with their cancellation tokens Maps request ID to cancellation token for operation cancellation

Implementations

impl MountainVinegRPCService

pub fn ApplicationHandle(&self) -> &AppHandle

Accessor for Tauri AppHandle - used by the per-wire-method atoms in Vine::Server::Notification::* that need to emit sky:// / cocoon:* events downstream. Kept as a thin read so the struct’s fields can stay private; atoms should never mutate the handle, only emit through it.

pub fn RunTime(&self) -> &Arc<ApplicationRunTime>

Accessor for the shared ApplicationRunTime. Notification atoms reach Environment.ApplicationState.* (provider registry, extension registry, scheduler) through this. Clone from Arc when the atom needs to keep it across an .await boundary.

impl MountainVinegRPCService

pub fn Create( ApplicationHandle: AppHandle, RunTime: Arc<ApplicationRunTime>, ) -> Self

Creates a new instance of the Mountain gRPC service.

Parameters

• ApplicationHandle: Tauri app handle for framework integration
• RunTime: Application runtime with core dependencies

Returns

New MountainVinegRPCService instance

pub async fn RegisterOperation(&self, request_id: u64) -> CancellationToken

Registers an operation for potential cancellation

Parameters

• request_id: The request identifier for the operation

Returns

A cancellation token that can be used to cancel the operation

pub async fn UnregisterOperation(&self, request_id: u64)

Unregisters an operation after completion

Parameters

• request_id: The request identifier to unregister

fn ValidateRequest(&self, request: &GenericRequest) -> Result<(), Status>

Validates a generic request before processing.

Parameters

• request: The request to validate

Returns

• Ok(()): Request is valid
• Err(Status): Validation failed with appropriate gRPC status

fn CreateErrorResponse( RequestIdentifier: u64, code: i32, message: String, data: Option<Vec<u8>>, ) -> GenericResponse

Creates a JSON-RPC compliant error response.

Parameters

• RequestIdentifier: The request ID to echo back
• code: JSON-RPC error code
• message: Error message
• data: Optional error data (serialized)

Returns

GenericResponse with error populated

fn CreateSuccessResponse( RequestIdentifier: u64, result: &Value, ) -> GenericResponse

Creates a successful JSON-RPC response.

Parameters

• RequestIdentifier: The request ID to echo back
• result: Result value to serialize

Returns

GenericResponse with result populated, or error if serialization fails

Trait Implementations

impl MountainService for MountainVinegRPCService

fn process_cocoon_request<'life0, 'async_trait>( &'life0 self, request: Request<GenericRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GenericResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handles generic request-response RPCs from Cocoon.

This is the main entry point for Cocoon to request operations from Mountain. It validates the request, deserializes parameters, dispatches to the Track module, and returns the result or error in JSON-RPC format.

Parameters

• request: GenericRequest containing method name and serialized parameters

Returns

• Ok(Response<GenericResponse>): Response with result or error
• Err(Status): gRPC status error (only for critical failures)

fn send_cocoon_notification<'life0, 'async_trait>( &'life0 self, request: Request<GenericNotification>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handles generic fire-and-forget notifications from Cocoon.

Notifications do not expect a response beyond acknowledgment. They are used for status updates, events, and other asynchronous notifications.

Parameters

• request: GenericNotification with method name and parameters

Returns

• Ok(Response<Empty>): Notification was received and logged
• Err(Status): Critical error during processing

TODO

Future implementation should route notifications to dedicated handlers:

let Parameter: Value = serde_json::from_slice(&notification.parameter)?;
NotificationHandler::Handle(MethodName, Parameter).await?;

fn cancel_operation<'life0, 'async_trait>( &'life0 self, request: Request<CancelOperationRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handles a request from Cocoon to cancel a long-running operation.

This method is called when Cocoon wants to cancel an operation that was previously initiated via process_cocoon_request.

Parameters

• request: CancelOperationRequest with the request ID to cancel

Returns

• Ok(Response<Empty>): Cancellation was initiated
• Err(Status): Critical error during cancellation

type OpenChannelFromCocoonStream = Pin<Box<dyn Stream<Item = Result<Envelope, Status>> + Send>>

Server streaming response type for the OpenChannelFromCocoon method.

fn open_channel_from_cocoon<'life0, 'async_trait>( &'life0 self, _request: Request<Streaming<Envelope>>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::OpenChannelFromCocoonStream>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

LAND-PATCH B7-S6 P2: bidirectional streaming channel.