Struct holochain::conductor::handle::ConductorHandleImpl

pub struct ConductorHandleImpl<DS: DnaStore + 'static> {
    pub dev_settings: RwLock<DevSettings>,
    // some fields omitted
}

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<DS: DnaStore + 'static> ConductorHandleT for ConductorHandleImpl<DS>

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 install.

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 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(&self, hash: &DnaHash) -> Option<DnaFile>

Get a Dna from the DnaStore

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 a EntryDef from the [EntryDefBuffer]

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: HostFnWorkspace
) -> 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 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 create_clone_cell<'async_trait>(
    self: Arc<Self>,
    payload: CreateCloneCellPayload
) -> Pin<Box<dyn Future<Output = ConductorResult<CellId>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Create a new Cell in an existing App based on an existing DNA

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

Destroy a cloned Cell

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 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 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 get_cell_env_readonly(&self, cell_id: &CellId) -> ConductorApiResult<EnvRead>

Retrieve the environment for this cell.

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 get_cell_env(&self, cell_id: &CellId) -> ConductorApiResult<EnvWrite>

Retrieve the environment for this cell. FOR TESTING ONLY.

fn get_cache_env(&self, cell_id: &CellId) -> ConductorApiResult<EnvWrite>

Retrieve the database for this cell. FOR TESTING ONLY.

fn get_p2p_env(&self, space: Arc<KitsuneSpace>) -> EnvWrite

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<DS: DnaStore + 'static> From<(Conductor<DS, CellConductorApi>, MetaLairClient, GhostSender<HolochainP2p>, EnvironmentRootPath, Arc<Mutex<RawMutex, HashMap<Arc<KitsuneSpace>, EnvWrite, RandomState>>>, Arc<Mutex<RawMutex, HashMap<Arc<KitsuneSpace>, EnvWrite, RandomState>>>, DbSyncLevel, Arc<Mutex<RawMutex, HashMap<Arc<KitsuneSpace>, Sender<P2pBatch>, RandomState>>>, RwLock<RawRwLock, DevSettings>)> for ConductorHandleImpl<DS>

fn from(
    original: (Conductor<DS>, MetaLairClient, HolochainP2pRef, EnvironmentRootPath, Arc<Mutex<HashMap<Arc<KitsuneSpace>, EnvWrite>>>, Arc<Mutex<HashMap<Arc<KitsuneSpace>, EnvWrite>>>, DbSyncLevel, Arc<Mutex<HashMap<Arc<KitsuneSpace>, Sender<P2pBatch>>>>, RwLock<DevSettings>)
) -> ConductorHandleImpl<DS>

Performs the conversion.