Struct holochain::conductor::api::RealAdminInterfaceApi

pub struct RealAdminInterfaceApi { /* private fields */ }

The admin interface that external connections can use to make requests to the conductor The concrete (non-mock) implementation of the AdminInterfaceApi

Implementations

impl RealAdminInterfaceApi

pub fn new(conductor_handle: ConductorHandle) -> Self

Create an admin interface api.

Examples found in repository

src/conductor/conductor.rs (line 376)

        pub(crate) async fn add_admin_interfaces(
            self: Arc<Self>,
            configs: Vec<AdminInterfaceConfig>,
        ) -> ConductorResult<()> {
            let admin_api = RealAdminInterfaceApi::new(self.clone());
            let stop_tx = self.task_manager.share_ref(|tm| {
                tm.as_ref()
                    .expect("Task manager not started yet")
                    .task_stop_broadcaster()
                    .clone()
            });

            // Closure to process each admin config item
            let spawn_from_config = |AdminInterfaceConfig { driver, .. }| {
                let admin_api = admin_api.clone();
                let stop_tx = stop_tx.clone();
                async move {
                    match driver {
                        InterfaceDriver::Websocket { port } => {
                            let (listener_handle, listener) =
                                spawn_websocket_listener(port).await?;
                            let port = listener_handle.local_addr().port().unwrap_or(port);
                            let handle: ManagedTaskHandle = spawn_admin_interface_task(
                                listener_handle,
                                listener,
                                admin_api.clone(),
                                stop_tx.subscribe(),
                            )?;
                            InterfaceResult::Ok((port, handle))
                        }
                    }
                }
            };

            // spawn interface tasks, collect their JoinHandles,
            // panic on errors.
            let handles: Result<Vec<_>, _> =
                future::join_all(configs.into_iter().map(spawn_from_config))
                    .await
                    .into_iter()
                    .collect();
            // Exit if the admin interfaces fail to be created
            let handles = handles.map_err(Box::new)?;

            {
                let mut ports = Vec::new();

                // First, register the keepalive task, to ensure the conductor doesn't shut down
                // in the absence of other "real" tasks
                self.manage_task(ManagedTaskAdd::ignore(
                    tokio::spawn(keep_alive_task(stop_tx.subscribe())),
                    "keepalive task",
                ))
                .await?;

                // Now that tasks are spawned, register them with the TaskManager
                for (port, handle) in handles {
                    ports.push(port);
                    self.manage_task(ManagedTaskAdd::ignore(
                        handle,
                        &format!("admin interface, port {}", port),
                    ))
                    .await?
                }
                for p in ports {
                    self.add_admin_port(p);
                }
            }
            Ok(())
        }

Trait Implementations

impl AdminInterfaceApi for RealAdminInterfaceApi

fn handle_admin_request_inner<'life0, 'async_trait>(
    &'life0 self,
    request: AdminRequest
) -> Pin<Box<dyn Future<Output = ConductorApiResult<AdminResponse>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Call an admin function to modify this Conductor’s behavior

fn handle_admin_request<'life0, 'async_trait>(
    &'life0 self,
    request: AdminRequest
) -> Pin<Box<dyn Future<Output = AdminResponse> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Deal with error cases produced by handle_admin_request_inner

impl Clone for RealAdminInterfaceApi

fn clone(&self) -> RealAdminInterfaceApi

Returns a copy of the value.

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

Performs copy-assignment from source.

impl InterfaceApi for RealAdminInterfaceApi

type ApiRequest = AdminRequest

Which request is being made

type ApiResponse = AdminResponse

Which response is sent to the above request

fn handle_request<'life0, 'async_trait>(
    &'life0 self,
    request: Result<Self::ApiRequest, SerializedBytesError>
) -> Pin<Box<dyn Future<Output = InterfaceResult<Self::ApiResponse>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,

Handle a request on this API