Struct coreemu::core::core_api_client::CoreApiClient

pub struct CoreApiClient<T> { /* fields omitted */ }

Implementations

impl CoreApiClient<Channel>

pub async fn connect<D>(dst: D) -> Result<Self, Error> where
    D: TryInto<Endpoint>,
    D::Error: Into<StdError>, 

Attempt to create a new client by connecting to a given endpoint.

impl<T> CoreApiClient<T> where
    T: GrpcService<BoxBody>,
    T::ResponseBody: Body + Send + Sync + 'static,
    T::Error: Into<StdError>,
    <T::ResponseBody as Body>::Error: Into<StdError> + Send, 

pub fn new(inner: T) -> Self

pub fn with_interceptor<F>(
    inner: T,
    interceptor: F
) -> CoreApiClient<InterceptedService<T, F>> where
    F: Interceptor,
    T: Service<Request<BoxBody>, Response = Response<<T as GrpcService<BoxBody>>::ResponseBody>>,
    <T as Service<Request<BoxBody>>>::Error: Into<StdError> + Send + Sync, 

pub fn send_gzip(self) -> Self

Compress requests with gzip.

This requires the server to support it otherwise it might respond with an error.

pub fn accept_gzip(self) -> Self

Enable decompressing responses with gzip.

pub async fn start_session(
    &mut self,
    request: impl IntoRequest<StartSessionRequest>
) -> Result<Response<StartSessionResponse>, Status>

session rpc

pub async fn stop_session(
    &mut self,
    request: impl IntoRequest<StopSessionRequest>
) -> Result<Response<StopSessionResponse>, Status>

pub async fn create_session(
    &mut self,
    request: impl IntoRequest<CreateSessionRequest>
) -> Result<Response<CreateSessionResponse>, Status>

pub async fn delete_session(
    &mut self,
    request: impl IntoRequest<DeleteSessionRequest>
) -> Result<Response<DeleteSessionResponse>, Status>

pub async fn get_sessions(
    &mut self,
    request: impl IntoRequest<GetSessionsRequest>
) -> Result<Response<GetSessionsResponse>, Status>

pub async fn get_session(
    &mut self,
    request: impl IntoRequest<GetSessionRequest>
) -> Result<Response<GetSessionResponse>, Status>

pub async fn check_session(
    &mut self,
    request: impl IntoRequest<CheckSessionRequest>
) -> Result<Response<CheckSessionResponse>, Status>

pub async fn get_session_options(
    &mut self,
    request: impl IntoRequest<GetSessionOptionsRequest>
) -> Result<Response<GetSessionOptionsResponse>, Status>

pub async fn set_session_options(
    &mut self,
    request: impl IntoRequest<SetSessionOptionsRequest>
) -> Result<Response<SetSessionOptionsResponse>, Status>

pub async fn set_session_metadata(
    &mut self,
    request: impl IntoRequest<SetSessionMetadataRequest>
) -> Result<Response<SetSessionMetadataResponse>, Status>

pub async fn get_session_metadata(
    &mut self,
    request: impl IntoRequest<GetSessionMetadataRequest>
) -> Result<Response<GetSessionMetadataResponse>, Status>

pub async fn get_session_location(
    &mut self,
    request: impl IntoRequest<GetSessionLocationRequest>
) -> Result<Response<GetSessionLocationResponse>, Status>

pub async fn set_session_location(
    &mut self,
    request: impl IntoRequest<SetSessionLocationRequest>
) -> Result<Response<SetSessionLocationResponse>, Status>

pub async fn set_session_state(
    &mut self,
    request: impl IntoRequest<SetSessionStateRequest>
) -> Result<Response<SetSessionStateResponse>, Status>

pub async fn set_session_user(
    &mut self,
    request: impl IntoRequest<SetSessionUserRequest>
) -> Result<Response<SetSessionUserResponse>, Status>

pub async fn add_session_server(
    &mut self,
    request: impl IntoRequest<AddSessionServerRequest>
) -> Result<Response<AddSessionServerResponse>, Status>

pub async fn session_alert(
    &mut self,
    request: impl IntoRequest<SessionAlertRequest>
) -> Result<Response<SessionAlertResponse>, Status>

pub async fn events(
    &mut self,
    request: impl IntoRequest<EventsRequest>
) -> Result<Response<Streaming<Event>>, Status>

streams

pub async fn throughputs(
    &mut self,
    request: impl IntoRequest<ThroughputsRequest>
) -> Result<Response<Streaming<ThroughputsEvent>>, Status>

pub async fn cpu_usage(
    &mut self,
    request: impl IntoRequest<CpuUsageRequest>
) -> Result<Response<Streaming<CpuUsageEvent>>, Status>

pub async fn add_node(
    &mut self,
    request: impl IntoRequest<AddNodeRequest>
) -> Result<Response<AddNodeResponse>, Status>

node rpc

pub async fn get_node(
    &mut self,
    request: impl IntoRequest<GetNodeRequest>
) -> Result<Response<GetNodeResponse>, Status>

pub async fn edit_node(
    &mut self,
    request: impl IntoRequest<EditNodeRequest>
) -> Result<Response<EditNodeResponse>, Status>

pub async fn delete_node(
    &mut self,
    request: impl IntoRequest<DeleteNodeRequest>
) -> Result<Response<DeleteNodeResponse>, Status>

pub async fn node_command(
    &mut self,
    request: impl IntoRequest<NodeCommandRequest>
) -> Result<Response<NodeCommandResponse>, Status>

pub async fn get_node_terminal(
    &mut self,
    request: impl IntoRequest<GetNodeTerminalRequest>
) -> Result<Response<GetNodeTerminalResponse>, Status>

pub async fn move_nodes(
    &mut self,
    request: impl IntoStreamingRequest<Message = MoveNodesRequest>
) -> Result<Response<MoveNodesResponse>, Status>

pub async fn get_node_links(
    &mut self,
    request: impl IntoRequest<GetNodeLinksRequest>
) -> Result<Response<GetNodeLinksResponse>, Status>

link rpc

pub async fn add_link(
    &mut self,
    request: impl IntoRequest<AddLinkRequest>
) -> Result<Response<AddLinkResponse>, Status>

pub async fn edit_link(
    &mut self,
    request: impl IntoRequest<EditLinkRequest>
) -> Result<Response<EditLinkResponse>, Status>

pub async fn delete_link(
    &mut self,
    request: impl IntoRequest<DeleteLinkRequest>
) -> Result<Response<DeleteLinkResponse>, Status>

pub async fn get_hooks(
    &mut self,
    request: impl IntoRequest<GetHooksRequest>
) -> Result<Response<GetHooksResponse>, Status>

hook rpc

pub async fn add_hook(
    &mut self,
    request: impl IntoRequest<AddHookRequest>
) -> Result<Response<AddHookResponse>, Status>

pub async fn get_mobility_configs(
    &mut self,
    request: impl IntoRequest<GetMobilityConfigsRequest>
) -> Result<Response<GetMobilityConfigsResponse>, Status>

mobility rpc

pub async fn get_mobility_config(
    &mut self,
    request: impl IntoRequest<GetMobilityConfigRequest>
) -> Result<Response<GetMobilityConfigResponse>, Status>

pub async fn set_mobility_config(
    &mut self,
    request: impl IntoRequest<SetMobilityConfigRequest>
) -> Result<Response<SetMobilityConfigResponse>, Status>

pub async fn mobility_action(
    &mut self,
    request: impl IntoRequest<MobilityActionRequest>
) -> Result<Response<MobilityActionResponse>, Status>

pub async fn get_services(
    &mut self,
    request: impl IntoRequest<GetServicesRequest>
) -> Result<Response<GetServicesResponse>, Status>

service rpc

pub async fn get_service_defaults(
    &mut self,
    request: impl IntoRequest<GetServiceDefaultsRequest>
) -> Result<Response<GetServiceDefaultsResponse>, Status>

pub async fn set_service_defaults(
    &mut self,
    request: impl IntoRequest<SetServiceDefaultsRequest>
) -> Result<Response<SetServiceDefaultsResponse>, Status>

pub async fn get_node_service_configs(
    &mut self,
    request: impl IntoRequest<GetNodeServiceConfigsRequest>
) -> Result<Response<GetNodeServiceConfigsResponse>, Status>

pub async fn get_node_service(
    &mut self,
    request: impl IntoRequest<GetNodeServiceRequest>
) -> Result<Response<GetNodeServiceResponse>, Status>

pub async fn get_node_service_file(
    &mut self,
    request: impl IntoRequest<GetNodeServiceFileRequest>
) -> Result<Response<GetNodeServiceFileResponse>, Status>

pub async fn set_node_service(
    &mut self,
    request: impl IntoRequest<SetNodeServiceRequest>
) -> Result<Response<SetNodeServiceResponse>, Status>

pub async fn set_node_service_file(
    &mut self,
    request: impl IntoRequest<SetNodeServiceFileRequest>
) -> Result<Response<SetNodeServiceFileResponse>, Status>

pub async fn service_action(
    &mut self,
    request: impl IntoRequest<ServiceActionRequest>
) -> Result<Response<ServiceActionResponse>, Status>

pub async fn get_config_services(
    &mut self,
    request: impl IntoRequest<GetConfigServicesRequest>
) -> Result<Response<GetConfigServicesResponse>, Status>

config services

pub async fn get_config_service_defaults(
    &mut self,
    request: impl IntoRequest<GetConfigServiceDefaultsRequest>
) -> Result<Response<GetConfigServiceDefaultsResponse>, Status>

pub async fn get_node_config_service_configs(
    &mut self,
    request: impl IntoRequest<GetNodeConfigServiceConfigsRequest>
) -> Result<Response<GetNodeConfigServiceConfigsResponse>, Status>

pub async fn get_node_config_service(
    &mut self,
    request: impl IntoRequest<GetNodeConfigServiceRequest>
) -> Result<Response<GetNodeConfigServiceResponse>, Status>

pub async fn get_node_config_services(
    &mut self,
    request: impl IntoRequest<GetNodeConfigServicesRequest>
) -> Result<Response<GetNodeConfigServicesResponse>, Status>

pub async fn set_node_config_service(
    &mut self,
    request: impl IntoRequest<SetNodeConfigServiceRequest>
) -> Result<Response<SetNodeConfigServiceResponse>, Status>

pub async fn get_wlan_configs(
    &mut self,
    request: impl IntoRequest<GetWlanConfigsRequest>
) -> Result<Response<GetWlanConfigsResponse>, Status>

wlan rpc

pub async fn get_wlan_config(
    &mut self,
    request: impl IntoRequest<GetWlanConfigRequest>
) -> Result<Response<GetWlanConfigResponse>, Status>

pub async fn set_wlan_config(
    &mut self,
    request: impl IntoRequest<SetWlanConfigRequest>
) -> Result<Response<SetWlanConfigResponse>, Status>

pub async fn wlan_link(
    &mut self,
    request: impl IntoRequest<WlanLinkRequest>
) -> Result<Response<WlanLinkResponse>, Status>

pub async fn get_emane_config(
    &mut self,
    request: impl IntoRequest<GetEmaneConfigRequest>
) -> Result<Response<GetEmaneConfigResponse>, Status>

emane rpc

pub async fn set_emane_config(
    &mut self,
    request: impl IntoRequest<SetEmaneConfigRequest>
) -> Result<Response<SetEmaneConfigResponse>, Status>

pub async fn get_emane_models(
    &mut self,
    request: impl IntoRequest<GetEmaneModelsRequest>
) -> Result<Response<GetEmaneModelsResponse>, Status>

pub async fn get_emane_model_config(
    &mut self,
    request: impl IntoRequest<GetEmaneModelConfigRequest>
) -> Result<Response<GetEmaneModelConfigResponse>, Status>

pub async fn set_emane_model_config(
    &mut self,
    request: impl IntoRequest<SetEmaneModelConfigRequest>
) -> Result<Response<SetEmaneModelConfigResponse>, Status>

pub async fn get_emane_model_configs(
    &mut self,
    request: impl IntoRequest<GetEmaneModelConfigsRequest>
) -> Result<Response<GetEmaneModelConfigsResponse>, Status>

pub async fn get_emane_event_channel(
    &mut self,
    request: impl IntoRequest<GetEmaneEventChannelRequest>
) -> Result<Response<GetEmaneEventChannelResponse>, Status>

pub async fn emane_pathlosses(
    &mut self,
    request: impl IntoStreamingRequest<Message = EmanePathlossesRequest>
) -> Result<Response<EmanePathlossesResponse>, Status>

pub async fn save_xml(
    &mut self,
    request: impl IntoRequest<SaveXmlRequest>
) -> Result<Response<SaveXmlResponse>, Status>

xml rpc

pub async fn open_xml(
    &mut self,
    request: impl IntoRequest<OpenXmlRequest>
) -> Result<Response<OpenXmlResponse>, Status>

pub async fn get_interfaces(
    &mut self,
    request: impl IntoRequest<GetInterfacesRequest>
) -> Result<Response<GetInterfacesResponse>, Status>

utilities

pub async fn emane_link(
    &mut self,
    request: impl IntoRequest<EmaneLinkRequest>
) -> Result<Response<EmaneLinkResponse>, Status>

pub async fn execute_script(
    &mut self,
    request: impl IntoRequest<ExecuteScriptRequest>
) -> Result<Response<ExecuteScriptResponse>, Status>

Trait Implementations

impl<T: Clone> Clone for CoreApiClient<T>

fn clone(&self) -> CoreApiClient<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for CoreApiClient<T>

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

Formats the value using the given formatter.