Enum DaemonInterfaceRequest 

pub enum DaemonInterfaceRequest {
    CreateInstance {
        flow: FlattenDataFlowDescriptor,
    },
    DeleteInstance {
        instance_id: Uuid,
    },
    Instantiate {
        flow: FlattenDataFlowDescriptor,
    },
    Teardown {
        instance_id: Uuid,
    },
    StartInstance {
        instance_id: Uuid,
    },
    StopInstance {
        instance_id: Uuid,
    },
    StartNode {
        instance_id: Uuid,
        node: String,
    },
    StopNode {
        instance_id: Uuid,
        node: String,
    },
}

The request sent over the wire from the client to the server.

Variants

CreateInstance

Fields

flow: FlattenDataFlowDescriptor

DeleteInstance

Fields

instance_id: Uuid

Instantiate

Fields

flow: FlattenDataFlowDescriptor

Teardown

Fields

instance_id: Uuid

StartInstance

Fields

instance_id: Uuid

StopInstance

Fields

instance_id: Uuid

StartNode

Fields

instance_id: Uuid

node: String

StopNode

Fields

instance_id: Uuid

node: String

Trait Implementations

impl Clone for DaemonInterfaceRequest

fn clone(&self) -> DaemonInterfaceRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DaemonInterfaceRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DaemonInterfaceRequest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for DaemonInterfaceRequest

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S> ZServe<DaemonInterfaceRequest> for ServeDaemonInterface<S>

where S: DaemonInterface + Send + 'static,

type Resp = DaemonInterfaceResponse

Type of the response

fn instance_uuid(&self) -> ZenohId

fn connect( &self, ) -> Pin<Box<dyn Future<Output = ZRPCResult<(AbortHandle, JoinHandle<Result<ZRPCResult<()>, Aborted>>)>> + '_>>

Connects to Zenoh, do nothing in this case, state is HALTED

fn initialize(&self) -> Pin<Box<dyn Future<Output = ZRPCResult<()>> + '_>>

Authenticates to Zenoh, state changes to INITIALIZING

fn register(&self) -> Pin<Box<dyn Future<Output = ZRPCResult<()>> + '_>>

fn start( &self, ) -> Pin<Box<dyn Future<Output = ZRPCResult<(AbortHandle, JoinHandle<Result<ZRPCResult<()>, Aborted>>)>> + '_>>

State changes to SERVING, calls serve on a task::spawn, returns a stop sender and the serve task handle

fn run(&self) -> Pin<Box<dyn Future<Output = ZRPCResult<()>> + '_>>

The actual run loop serving the queriable

fn serve( &self, barrier: Arc<Barrier>, ) -> Pin<Box<dyn Future<Output = ZRPCResult<()>> + '_>>

Starts serving all requests

fn stop( &self, stop: AbortHandle, ) -> Pin<Box<dyn Future<Output = ZRPCResult<()>> + '_>>

State changes to REGISTERED, will stop serve/work

fn unregister(&self) -> Pin<Box<dyn Future<Output = ZRPCResult<()>> + '_>>

fn disconnect( &self, stop: AbortHandle, ) -> Pin<Box<dyn Future<Output = ZRPCResult<()>> + '_>>

removes state from Zenoh