Struct holochain::conductor::handle::ConductorHandleImpl

pub struct ConductorHandleImpl {
    pub dev_settings: RwLock<DevSettings>,
    /* private fields */
}

The current “production” implementation of a ConductorHandle. The implementation specifies how read/write access to the Conductor should be synchronized across multiple concurrent Handles.

Synchronization is currently achieved via a simple RwLock, but this could be swapped out with, e.g. a channel Sender/Receiver pair using an actor model.

Fields

dev_settings: RwLock<DevSettings>

Selectively enable/disable certain functionalities

Trait Implementations

impl ConductorHandleT for ConductorHandleImpl

fn check_running(&self) -> ConductorResult<()>

Check that shutdown has not been called

fn start_scheduler<'async_trait>(
    self: Arc<Self>,
    interval_period: Duration
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
    Self: 'async_trait,

Start the scheduler. None is not an option. Calling this will:

• Delete/unschedule all ephemeral scheduled functions GLOBALLY
• Add an interval that runs IN ADDITION to previous invocations So ideally this would be called ONCE per conductor lifecyle ONLY.

fn dispatch_scheduled_fns<'async_trait>(
    self: Arc<Self>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
    Self: 'async_trait,

The scheduler wants to dispatch any functions that are due.

fn add_admin_interfaces<'async_trait>(
    self: Arc<Self>,
    configs: Vec<AdminInterfaceConfig>
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,

Add a collection of admin interfaces from config

fn initialize_conductor<'async_trait>(
    self: Arc<Self>,
    admin_configs: Vec<AdminInterfaceConfig>
) -> Pin<Box<dyn Future<Output = ConductorResult<CellStartupErrors>> + Send + 'async_trait>>where
    Self: 'async_trait,

Initialize the task manager, add admin interfaces from config, start up app interfaces from db, and register all tasks.

fn add_app_interface<'async_trait>(
    self: Arc<Self>,
    port: u16
) -> Pin<Box<dyn Future<Output = ConductorResult<u16>> + Send + 'async_trait>>where
    Self: 'async_trait,

Add an app interface

fn list_app_interfaces<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = ConductorResult<Vec<u16>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

List the app interfaces currently installed.

fn register_dna<'life0, 'async_trait>(
    &'life0 self,
    dna: DnaFile
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Install a DnaFile in this Conductor

fn update_coordinators<'life0, 'life1, 'async_trait>(
    &'life0 self,
    hash: &'life1 DnaHash,
    coordinator_zomes: CoordinatorZomes,
    wasms: Vec<DnaWasm>
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Update coordinator zomes on an existing dna.

fn load_dnas<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add the DnaFiles from the wasm and dna_def databases into memory

fn list_dnas(&self) -> Vec<DnaHash>

Get the list of hashes of installed Dnas in this Conductor

fn get_dna_def(&self, hash: &DnaHash) -> Option<DnaDef>

Get a DnaDef from the RibosomeStore

fn get_dna_file(&self, hash: &DnaHash) -> Option<DnaFile>

Get a DnaFile from the RibosomeStore

fn get_ribosome(&self, dna_hash: &DnaHash) -> ConductorResult<RealRibosome>

Get an instance of a RealRibosome for the DnaHash

fn get_entry_def(&self, key: &EntryDefBufferKey) -> Option<EntryDef>

Get an EntryDef from the EntryDefBufferKey

fn get_config(&self) -> &ConductorConfig

Get the conductor config

fn chc(&self, cell_id: &CellId) -> Option<ChcImpl>

Build a ChainHeadCoordinator impl based on the conductor config

fn chc_sync<'async_trait>(
    self: Arc<Self>,
    cell_id: CellId,
    enable_app: Option<InstalledAppId>
) -> Pin<Box<dyn Future<Output = ConductorApiResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,

Make the source chain for the given Cell match the chain data in the CHC for this Cell, if applicable.

fn dispatch_holochain_p2p_event<'life0, 'async_trait>(
    &'life0 self,
    event: HolochainP2pEvent
) -> Pin<Box<dyn Future<Output = ConductorApiResult<()>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Dispatch a network event to the correct cell. Warning: returning an error from this function kills the network for the conductor.

fn call_zome<'life0, 'async_trait>(
    &'life0 self,
    call: ZomeCall
) -> Pin<Box<dyn Future<Output = ConductorApiResult<ZomeCallResult>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Invoke a zome function on a Cell

fn call_zome_with_workspace<'life0, 'async_trait>(
    &'life0 self,
    call: ZomeCall,
    workspace_lock: SourceChainWorkspace
) -> Pin<Box<dyn Future<Output = ConductorApiResult<ZomeCallResult>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Invoke a zome function on a Cell with a workspace

fn take_shutdown_handle(&self) -> Option<JoinHandle<TaskManagerResult>>

Return the JoinHandle for all managed tasks, which when resolved will signal that the Conductor has completely shut down.

fn get_arbitrary_admin_websocket_port(&self) -> Option<u16>

Get a Websocket port which will

fn get_queue_consumer_workflows(&self) -> QueueConsumerMap

Get the running queue consumer workflows per DnaHash map.

fn shutdown(&self)

Send a signal to all managed tasks asking them to end ASAP.

fn keystore(&self) -> &MetaLairClient

Request access to this conductor’s keystore

fn holochain_p2p(&self) -> &HolochainP2pRef

Request access to this conductor’s networking handle

fn prune_p2p_agents_db<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Prune expired agent_infos from the p2p agents database

fn create_clone_cell<'async_trait>(
    self: Arc<Self>,
    payload: CreateCloneCellPayload
) -> Pin<Box<dyn Future<Output = ConductorResult<InstalledCell>> + Send + 'async_trait>>where
    Self: 'async_trait,

Create a new cell in an existing app based on an existing DNA.

fn archive_clone_cell<'async_trait>(
    self: Arc<Self>,
    payload: ArchiveCloneCellPayload
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,

Archive a clone cell for deletion.

fn restore_archived_clone_cell<'async_trait>(
    self: Arc<Self>,
    payload: ArchiveCloneCellPayload
) -> Pin<Box<dyn Future<Output = ConductorResult<InstalledCell>> + Send + 'async_trait>>where
    Self: 'async_trait,

Restore an archived clone cell.

fn delete_archived_clone_cells<'async_trait>(
    self: Arc<Self>,
    payload: DeleteArchivedCloneCellsPayload
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,

Destroy all clone cells marked for deletion.

fn install_app<'async_trait>(
    self: Arc<Self>,
    installed_app_id: InstalledAppId,
    cell_data: Vec<(InstalledCell, Option<MembraneProof>)>
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,

Install Cells into ConductorState based on installation info, and run genesis on all new source chains

fn install_app_bundle<'async_trait>(
    self: Arc<Self>,
    payload: InstallAppBundlePayload
) -> Pin<Box<dyn Future<Output = ConductorResult<StoppedApp>> + Send + 'async_trait>>where
    Self: 'async_trait,

Install DNAs and set up Cells as specified by an AppBundle

fn post_commit_permit<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<OwnedPermit<PostCommitArgs>, SendError<()>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get an OwnedPermit to the post commit task.

fn reconcile_app_status_with_cell_status<'life0, 'async_trait>(
    &'life0 self,
    app_ids: Option<HashSet<InstalledAppId>>
) -> Pin<Box<dyn Future<Output = ConductorResult<AppStatusFx>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Adjust app statuses (via state transitions) to match the current reality of which Cells are present in the conductor.

fn reconcile_cell_status_with_app_status<'async_trait>(
    self: Arc<Self>
) -> Pin<Box<dyn Future<Output = ConductorResult<CellStartupErrors>> + Send + 'async_trait>>where
    Self: 'async_trait,

Adjust which cells are present in the Conductor (adding and removing as needed) to match the current reality of all app statuses.

fn enable_app<'async_trait>(
    self: Arc<Self>,
    app_id: InstalledAppId
) -> Pin<Box<dyn Future<Output = ConductorResult<(InstalledApp, CellStartupErrors)>> + Send + 'async_trait>>where
    Self: 'async_trait,

Activate an app

fn disable_app<'async_trait>(
    self: Arc<Self>,
    app_id: InstalledAppId,
    reason: DisabledAppReason
) -> Pin<Box<dyn Future<Output = ConductorResult<InstalledApp>> + Send + 'async_trait>>where
    Self: 'async_trait,

Disable an app

fn start_app<'async_trait>(
    self: Arc<Self>,
    app_id: InstalledAppId
) -> Pin<Box<dyn Future<Output = ConductorResult<InstalledApp>> + Send + 'async_trait>>where
    Self: 'async_trait,

Start an enabled but stopped (paused) app

fn pause_app<'async_trait>(
    self: Arc<Self>,
    app_id: InstalledAppId,
    reason: PausedAppReason
) -> Pin<Box<dyn Future<Output = ConductorResult<InstalledApp>> + Send + 'async_trait>>where
    Self: 'async_trait,

Stop a running app while leaving it enabled. FOR TESTING ONLY.

fn uninstall_app<'life0, 'async_trait>(
    self: Arc<Self>,
    installed_app_id: &'life0 InstalledAppId
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Uninstall an app from the state DB and remove all running Cells

fn list_cell_ids(&self, filter: Option<CellStatus>) -> Vec<CellId>

List Cell Ids

fn list_running_apps<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = ConductorResult<Vec<InstalledAppId>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

List Active AppIds

fn list_apps<'life0, 'async_trait>(
    &'life0 self,
    status_filter: Option<AppStatusFilter>
) -> Pin<Box<dyn Future<Output = ConductorResult<Vec<InstalledAppInfo>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

List Apps with their information

fn list_running_apps_for_required_cell_id<'life0, 'life1, 'async_trait>(
    &'life0 self,
    cell_id: &'life1 CellId
) -> Pin<Box<dyn Future<Output = ConductorResult<HashSet<InstalledAppId>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Get the IDs of all active installed Apps which use this Cell

fn find_cell_with_role_alongside_cell<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    cell_id: &'life1 CellId,
    role_id: &'life2 AppRoleId
) -> Pin<Box<dyn Future<Output = ConductorResult<Option<CellId>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait,

Find the ID of the first active installed App which uses this Cell

fn list_running_apps_for_required_dna_hash<'life0, 'life1, 'async_trait>(
    &'life0 self,
    dna_hash: &'life1 DnaHash
) -> Pin<Box<dyn Future<Output = ConductorResult<HashSet<InstalledAppId>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Get the IDs of all active installed Apps which use this Dna

fn dump_cell_state<'life0, 'life1, 'async_trait>(
    &'life0 self,
    cell_id: &'life1 CellId
) -> Pin<Box<dyn Future<Output = ConductorApiResult<String>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Dump the cells state

fn dump_full_cell_state<'life0, 'life1, 'async_trait>(
    &'life0 self,
    cell_id: &'life1 CellId,
    dht_ops_cursor: Option<u64>
) -> Pin<Box<dyn Future<Output = ConductorApiResult<FullStateDump>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Dump the full cells state

fn dump_network_metrics<'life0, 'async_trait>(
    &'life0 self,
    dna_hash: Option<DnaHash>
) -> Pin<Box<dyn Future<Output = ConductorApiResult<String>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Dump the network metrics

fn signal_broadcaster<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = SignalBroadcaster> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Access the broadcast Sender which will send a Signal across every attached app interface

fn get_app_info<'life0, 'life1, 'async_trait>(
    &'life0 self,
    installed_app_id: &'life1 InstalledAppId
) -> Pin<Box<dyn Future<Output = ConductorResult<Option<InstalledAppInfo>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Get info about an installed App, whether active or inactive

fn add_agent_infos<'life0, 'async_trait>(
    &'life0 self,
    agent_infos: Vec<AgentInfoSigned>
) -> Pin<Box<dyn Future<Output = ConductorApiResult<()>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add signed agent info to the conductor

fn get_agent_infos<'life0, 'async_trait>(
    &'life0 self,
    cell_id: Option<CellId>
) -> Pin<Box<dyn Future<Output = ConductorApiResult<Vec<AgentInfoSigned>>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Get signed agent info from the conductor

fn print_setup(&self)

Print the current setup in a machine readable way.

fn remove_cells<'life0, 'life1, 'async_trait>(
    &'life0 self,
    cell_ids: &'life1 [CellId]
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Manually remove some cells. Should only be used when handling errors in Cells, allowing individual Cells to be shut down.

fn graft_records_onto_source_chain<'async_trait>(
    self: Arc<Self>,
    cell_id: CellId,
    validate: bool,
    records: Vec<Record>
) -> Pin<Box<dyn Future<Output = ConductorApiResult<()>> + Send + 'async_trait>>where
    Self: 'async_trait,

Inject records into a source chain for a cell. If the records form a chain segment that can be “grafted” onto the existing chain, it will be. Otherwise, a new chain will be formed using the specified records.

fn get_authored_db(
    &self,
    dna_hash: &DnaHash
) -> ConductorApiResult<DbWrite<DbKindAuthored>>

Retrieve the authored environment for this dna. FOR TESTING ONLY.

fn get_dht_db(
    &self,
    dna_hash: &DnaHash
) -> ConductorApiResult<DbWrite<DbKindDht>>

Retrieve the dht environment for this dna. FOR TESTING ONLY.

fn get_dht_db_cache(
    &self,
    dna_hash: &DnaHash
) -> ConductorApiResult<DhtDbQueryCache>

Retrieve the dht environment for this dna. FOR TESTING ONLY.

fn get_cache_db(
    &self,
    cell_id: &CellId
) -> ConductorApiResult<DbWrite<DbKindCache>>

Retrieve the database for this cell. FOR TESTING ONLY.

fn get_p2p_db(&self, space: &DnaHash) -> DbWrite<DbKindP2pAgents>

Retrieve the database for networking. FOR TESTING ONLY.

fn get_p2p_metrics_db(&self, space: &DnaHash) -> DbWrite<DbKindP2pMetrics>

Retrieve the database for metrics. FOR TESTING ONLY.

fn get_spaces(&self) -> Spaces

Retrieve the database for networking. FOR TESTING ONLY.

fn get_cell_triggers(
    &self,
    cell_id: &CellId
) -> ConductorApiResult<QueueTriggers>

Retrieve Senders for triggering workflows. FOR TESTING ONLY.

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

Retrieve the ConductorState. FOR TESTING ONLY.

fn add_test_app_interface<'life0, 'async_trait>(
    &'life0 self,
    id: AppInterfaceId
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Add a “test” app interface for sending and receiving signals. FOR TESTING ONLY.

fn dev_settings(&self) -> DevSettings

Get the current dev settings

fn update_dev_settings(&self, delta: DevSettingsDelta)

Update the current dev settings

fn update_cell_status(&self, cell_ids: &[CellId], status: CellStatus)

Manually coerce cells to a given CellStatus. FOR TESTING ONLY.

fn transition_app_status<'life0, 'async_trait>(
    &'life0 self,
    app_id: InstalledAppId,
    transition: AppStatusTransition
) -> Pin<Box<dyn Future<Output = ConductorResult<(InstalledApp, AppStatusFx)>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Manually coerce app to a given AppStatus. FOR TESTING ONLY.

impl From<(Conductor<CellConductorApi>, RwLock<RawRwLock, DevSettings>)> for ConductorHandleImpl

fn from(original: (Conductor, RwLock<DevSettings>)) -> ConductorHandleImpl

Converts to this type from the input type.