Method update_module

crates/core/src/host/host_controller.rs:1193–1261

(
        &mut self,
        runtimes: Arc<HostRuntimes>,
        program: Program,
        policy: MigrationPolicy,
        energy_monitor: Arc<dyn EnergyMonitor>,
        on_panic: impl Fn() + Send 

    /// Either way, the [`UpdateDatabaseResult`] is returned.
    #[allow(clippy::too_many_arguments)]
    async fn update_module(
        &mut self,
        runtimes: Arc<HostRuntimes>,
        program: Program,
        policy: MigrationPolicy,
        energy_monitor: Arc<dyn EnergyMonitor>,
        on_panic: impl Fn() + Send + Sync + 'static,
        core: AllocatedJobCore,
    ) -> anyhow::Result<UpdateDatabaseResult> {
        let replica_ctx = &self.replica_ctx;
        let (scheduler, scheduler_starter) = Scheduler::open(self.replica_ctx.relational_db().clone());

        let (program, module) = make_module_host(
            runtimes,
            replica_ctx.clone(),
            scheduler.clone(),
            program,
            energy_monitor,
            on_panic,
            core,
        )
        .await?;

        // Get the old module info to diff against when building a migration plan.
        let old_module_info = self.module.borrow().info.clone();

        let update_result =
            update_module(replica_ctx.relational_db(), &module, program, old_module_info, policy).await?;

        // Only replace the module + scheduler if the update succeeded.
        // Otherwise, we want the database to continue running with the old state.
        match update_result {
            UpdateDatabaseResult::NoUpdateNeeded | UpdateDatabaseResult::UpdatePerformed { .. } => {
                self.scheduler = scheduler;
                scheduler_starter.start(&module)?;
                let old_module = self.module.send_replace(module);
                old_module.exit().await;
            }

            // In this case, we need to disconnect all clients connected to the old module
            UpdateDatabaseResult::UpdatePerformedWithClientDisconnect { .. } => {
                // Replace the module first, so that new clients get the new module.
                let old_watcher = std::mem::replace(&mut self.module, watch::Sender::new(module.clone()));

                // Disconnect all clients connected to the old module.
                let connected_clients = replica_ctx.relational_db().connected_clients()?;
                for (identity, connection_id) in connected_clients {
                    let client_actor_id = ClientActorId {
                        identity,
                        connection_id,
                        name: ClientName(0),
                    };
                    //NOTE: This will call disconnect reducer of the new module, not the old one.
                    //It makes sense, as relationaldb is already updated to the new module.
                    module.disconnect_client(client_actor_id).await;
                }

                self.scheduler = scheduler;