Struct holochain::conductor::api::RealAppInterfaceApi

pub struct RealAppInterfaceApi { /* private fields */ }

The Conductor lives inside an Arc<RwLock<_>> which is shared with all other Api references

Implementations

impl RealAppInterfaceApi

pub fn new(conductor_handle: ConductorHandle) -> Self

Create a new instance from a shared Conductor reference

Examples found in repository

src/test_utils.rs (line 373)

pub async fn setup_app(
    dnas: Vec<DnaFile>,
    cell_data: Vec<(InstalledCell, Option<MembraneProof>)>,
) -> (Arc<TempDir>, RealAppInterfaceApi, ConductorHandle) {
    let db_dir = test_db_dir();

    let conductor_handle = ConductorBuilder::new()
        .test(db_dir.path(), &[])
        .await
        .unwrap();

    for dna in dnas {
        conductor_handle.register_dna(dna).await.unwrap();
    }

    conductor_handle
        .clone()
        .install_app("test app".to_string(), cell_data)
        .await
        .unwrap();

    conductor_handle
        .clone()
        .enable_app("test app".to_string())
        .await
        .unwrap();

    let errors = conductor_handle
        .clone()
        .reconcile_cell_status_with_app_status()
        .await
        .unwrap();

    assert!(errors.is_empty());

    let handle = conductor_handle.clone();

    (
        Arc::new(db_dir),
        RealAppInterfaceApi::new(conductor_handle),
        handle,
    )
}

/// Setup an app for testing
/// apps_data is a vec of app nicknames with vecs of their cell data
pub async fn setup_app_with_names(
    apps_data: Vec<(&str, InstalledCellsWithProofs)>,
    dnas: Vec<DnaFile>,
) -> (TempDir, RealAppInterfaceApi, ConductorHandle) {
    let dir = test_db_dir();
    let (iface, handle) = setup_app_inner(dir.path(), apps_data, dnas, None).await;
    (dir, iface, handle)
}

/// Setup an app with a custom network config for testing
/// apps_data is a vec of app nicknames with vecs of their cell data.
pub async fn setup_app_with_network(
    apps_data: Vec<(&str, InstalledCellsWithProofs)>,
    dnas: Vec<DnaFile>,
    network: KitsuneP2pConfig,
) -> (TempDir, RealAppInterfaceApi, ConductorHandle) {
    let dir = test_db_dir();
    let (iface, handle) = setup_app_inner(dir.path(), apps_data, dnas, Some(network)).await;
    (dir, iface, handle)
}

/// Setup an app with full configurability
pub async fn setup_app_inner(
    db_dir: &Path,
    apps_data: Vec<(&str, InstalledCellsWithProofs)>,
    dnas: Vec<DnaFile>,
    network: Option<KitsuneP2pConfig>,
) -> (RealAppInterfaceApi, ConductorHandle) {
    let conductor_handle = ConductorBuilder::new()
        .config(ConductorConfig {
            admin_interfaces: Some(vec![AdminInterfaceConfig {
                driver: InterfaceDriver::Websocket { port: 0 },
            }]),
            network,
            ..Default::default()
        })
        .test(db_dir, &[])
        .await
        .unwrap();

    for (app_name, cell_data) in apps_data {
        install_app(app_name, cell_data, dnas.clone(), conductor_handle.clone()).await;
    }

    let handle = conductor_handle.clone();

    (RealAppInterfaceApi::new(conductor_handle), handle)
}

src/conductor/conductor.rs (line 457)

        pub async fn add_app_interface(
            self: Arc<Self>,
            port: either::Either<u16, AppInterfaceId>,
        ) -> ConductorResult<u16> {
            let interface_id = match port {
                either::Either::Left(port) => AppInterfaceId::new(port),
                either::Either::Right(id) => id,
            };
            let port = interface_id.port();
            tracing::debug!("Attaching interface {}", port);
            let app_api = RealAppInterfaceApi::new(self.clone());
            // This receiver is thrown away because we can produce infinite new
            // receivers from the Sender
            let (signal_tx, _r) = tokio::sync::broadcast::channel(SIGNAL_BUFFER_SIZE);
            let stop_rx = self.task_manager.share_ref(|tm| {
                tm.as_ref()
                    .expect("Task manager not initialized")
                    .task_stop_broadcaster()
                    .subscribe()
            });
            let (port, task) = spawn_app_interface_task(port, app_api, signal_tx.clone(), stop_rx)
                .await
                .map_err(Box::new)?;
            // TODO: RELIABILITY: Handle this task by restarting it if it fails and log the error
            self.manage_task(ManagedTaskAdd::ignore(
                task,
                &format!("app interface, port {}", port),
            ))
            .await?;
            let interface = AppInterfaceRuntime::Websocket { signal_tx };

            self.app_interfaces.share_mut(|app_interfaces| {
                if app_interfaces.contains_key(&interface_id) {
                    return Err(ConductorError::AppInterfaceIdCollision(
                        interface_id.clone(),
                    ));
                }

                app_interfaces.insert(interface_id.clone(), interface);
                Ok(())
            })?;
            let config = AppInterfaceConfig::websocket(port);
            self.update_state(|mut state| {
                state.app_interfaces.insert(interface_id, config);
                Ok(state)
            })
            .await?;
            tracing::debug!("App interface added at port: {}", port);
            Ok(port)
        }

Trait Implementations

impl AppInterfaceApi for RealAppInterfaceApi

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

Routes the AppRequest to the AppResponse

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

Deal with error cases produced by handle_app_request_inner

impl Clone for RealAppInterfaceApi

fn clone(&self) -> RealAppInterfaceApi

Returns a copy of the value.

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

Performs copy-assignment from source.

impl InterfaceApi for RealAppInterfaceApi

type ApiRequest = AppRequest

Which request is being made

type ApiResponse = AppResponse

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