pruntime: Add RPC try_upgrade_pink_runtime

crates/phactory/src/contracts/pink.rs

@@ -19,7 +19,7 @@ use pink::{
     },
     local_cache::{self, StorageQuotaExceeded},
     runtimes::v1::{get_runtime, using_ocalls},
-    types::ExecutionMode,
+    types::{BlockNumber, ExecutionMode},
 };
 use serde::{Deserialize, Serialize};
 use sidevm::service::{Command as SidevmCommand, CommandSender, Metric, SystemMessage};
@@ -861,6 +861,29 @@ impl Cluster {
     pub(crate) fn snapshot(&self) -> Self {
         self.clone()
     }
+
+    pub(crate) fn upgrade_runtime(&mut self, version: (u32, u32)) {
+        let current = self.config.runtime_version;
+        info!("Try to upgrade runtime to {version:?}, current version is {current:?}");
+        if version <= current {
+            info!("Runtime version is already {current:?}");
+            return;
+        }
+        if current == (1, 0) {
+            // The 1.0 runtime didn't call on_genesis on cluster setup, so we need to call it
+            // manually to make sure the storage_versions are correct before migration.
+            self.default_runtime_mut().on_genesis();
+        }
+        self.config.runtime_version = version;
+        self.default_runtime_mut().on_runtime_upgrade();
+        info!("Runtime upgraded to {version:?}");
+    }
+
+    pub(crate) fn on_idle(&mut self, block_number: BlockNumber) {
+        if pink::types::ECallsAvailable::on_idle(self.config.runtime_version) {
+            self.default_runtime_mut().on_idle(block_number);
+        }
+    }
 }
 
 pub trait ClusterContainer {

crates/phactory/src/prpc_service.rs

@@ -2014,4 +2014,24 @@ impl<Platform: pal::Platform + Serialize + DeserializeOwned> PhactoryApi for Rpc
             .load_cluster_state(&req.filename)
             .map_err(from_debug)
     }
+    async fn try_upgrade_pink_runtime(
+        &mut self,
+        req: pb::PinkRuntimeVersion,
+    ) -> Result<(), prpc::server::Error> {
+        let version = (req.major, req.minor);
+        let block_number;
+        let mut cluster = {
+            let mut phactory = self.lock_phactory(true, false)?;
+            block_number = phactory.current_block()?.0;
+            let system = phactory.system()?;
+            let cluster = system
+                .contract_cluster
+                .as_ref()
+                .ok_or_else(|| from_display("Worker not in cluster"))?;
+            cluster.clone()
+        };
+        cluster.upgrade_runtime(version);
+        cluster.on_idle(block_number);
+        Ok(())
+    }
 }

crates/phactory/src/system/mod.rs

@@ -14,7 +14,7 @@ use core::fmt;
 use phala_scheduler::RequestScheduler;
 use pink::{
     capi::v1::ecall::{ClusterSetupConfig, ECalls},
-    types::{AccountId, ECallsAvailable, ExecSideEffects, ExecutionMode, TransactionArguments},
+    types::{AccountId, ExecSideEffects, ExecutionMode, TransactionArguments},
 };
 use runtime::BlockNumber;
 
@@ -664,7 +664,6 @@ impl<Platform: pal::Platform> System<Platform> {
     }
 
     fn process_contract_messages(&mut self, block: &mut BlockInfo) {
-        let log_handler = self.get_system_message_handler();
         // Iterate over all contracts to handle their incoming commands.
         //
         // Since the wasm contracts can instantiate new contracts, it means that it will mutate the `self.contracts`.
@@ -675,6 +674,7 @@ impl<Platform: pal::Platform> System<Platform> {
             // Inner loop to handle commands. One command per iteration and apply the command side-effects to make it
             // availabe for next command.
             loop {
+                let log_handler = self.get_system_message_handler();
                 let Some(cluster) = &mut self.contract_cluster else {
                     return;
                 };
@@ -698,15 +698,13 @@ impl<Platform: pal::Platform> System<Platform> {
                     block,
                     &self.egress,
                     &self.sidevm_spawner,
-                    log_handler.clone(),
+                    log_handler,
                     block.storage,
                 );
             }
         }
         if let Some(cluster) = &mut self.contract_cluster {
-            if ECallsAvailable::on_idle(cluster.config.runtime_version) {
-                cluster.runtime_mut(log_handler).on_idle(block.block_number);
-            }
+            cluster.on_idle(block.block_number);
         };
     }
 
@@ -1830,19 +1828,7 @@ pub(crate) fn apply_pink_events(
             }
             PinkEvent::UpgradeRuntimeTo { version } => {
                 ensure_system!();
-                info!("Try to upgrade runtime to {version:?}");
-                if version <= cluster.config.runtime_version {
-                    info!("Runtime version is already {version:?}");
-                    continue;
-                }
-                if cluster.config.runtime_version == (1, 0) {
-                    // The 1.0 runtime didn't call on_genesis on cluster setup, so we need to call it
-                    // manually to make sure the storage_versions are correct before migration.
-                    cluster.default_runtime_mut().on_genesis();
-                }
-                cluster.config.runtime_version = version;
-                cluster.default_runtime_mut().on_runtime_upgrade();
-                info!("Runtime upgraded to {version:?}");
+                cluster.upgrade_runtime(version);
             }
         }
     }

standalone/pruntime/src/api_server.rs

@@ -206,6 +206,7 @@ fn rpc_type(method: &str) -> RpcType {
             GenerateClusterStateRequest => Private,
             SaveClusterState => Public,
             LoadClusterState => Private,
+            TryUpgradePinkRuntime => Private,
         },
     }
 }
@@ -250,6 +251,7 @@ fn default_payload_limit_for_method(method: PhactoryAPIMethod) -> ByteUnit {
         GenerateClusterStateRequest => 1.kibibytes(),
         SaveClusterState => 1.kibibytes(),
         LoadClusterState => 1.kibibytes(),
+        TryUpgradePinkRuntime => 1.kibibytes(),
     }
 }