chore(ICP-Archive): remove migration to stable structures code (#4478)

This allows us to also remove the dependency on deprecated
`dfn_core::stable` which was used during the migration.

Author: maciejdfinity

Cargo.lock

@@ -36,7 +36,6 @@ rust_canister(
         "//rs/ledger_suite/common/ledger_core",
         "//rs/ledger_suite/icp:icp_ledger",
         "//rs/nns/constants",
-        "//rs/rust_canisters/dfn_core",
         "//rs/rust_canisters/http_types",
         "//rs/types/base_types",
         "@crate_index//:candid",

rs/ledger_suite/icp/archive/BUILD.bazel

@@ -9,7 +9,6 @@ documentation.workspace = true
 [dependencies]
 candid = { workspace = true }
 ciborium = { workspace = true }
-dfn_core = { path = "../../../rust_canisters/dfn_core" }
 ic-base-types = { path = "../../../types/base_types" }
 ic-canisters-http-types = { path = "../../../rust_canisters/http_types" }
 ic-cdk = { workspace = true }

rs/ledger_suite/icp/archive/Cargo.toml

@@ -1,12 +1,13 @@
 use candid::{candid_method, Decode};
-use dfn_core::stable;
 use ic_base_types::{CanisterId, PrincipalId};
 use ic_canisters_http_types::{HttpRequest, HttpResponse, HttpResponseBuilder};
-use ic_cdk::api::{
-    call::{arg_data_raw, reply, reply_raw},
-    caller, print,
+use ic_cdk::{
+    api::{
+        call::{arg_data_raw, reply, reply_raw},
+        caller, print,
+    },
+    post_upgrade, query,
 };
-use ic_cdk::query;
 use ic_icp_archive::ArchiveUpgradeArgument;
 use ic_ledger_canister_core::range_utils;
 use ic_ledger_canister_core::runtime::heap_memory_size_bytes;
@@ -28,15 +29,6 @@ use icp_ledger::{
 use serde::{Deserialize, Serialize};
 use std::{borrow::Cow, cell::RefCell};
 
-#[derive(Debug, Deserialize, Serialize)]
-struct ArchiveNodeState {
-    pub max_memory_size_bytes: usize,
-    pub block_height_offset: u64,
-    pub blocks: Vec<EncodedBlock>,
-    pub total_block_size: usize,
-    pub ledger_canister_id: CanisterId,
-}
-
 #[derive(Clone, Copy, Debug, Deserialize, Serialize)]
 struct ArchiveState {
     pub max_memory_size_bytes: u64,
@@ -382,63 +374,24 @@ fn get_blocks_candid_() {
     reply((get_blocks(args),));
 }
 
-#[export_name = "canister_post_upgrade"]
-fn post_upgrade() {
-    ic_cdk::setup();
-
+#[post_upgrade]
+fn post_upgrade(upgrade_arg: Option<ArchiveUpgradeArgument>) {
     set_last_upgrade_timestamp(ic_cdk::api::time());
 
-    let args = arg_data_raw();
-    let arg_max_memory_size_bytes = if args.is_empty() {
-        print("Upgrading archive without an upgrade argument.");
-        None
-    } else {
-        match Decode!(&args, ArchiveUpgradeArgument) {
-            Ok(args) => args.max_memory_size_bytes,
-            Err(e) => {
-                ic_cdk::trap(&format!("Unable to decode archive upgrade argument: {}", e));
-            }
-        }
+    let arg_max_memory_size_bytes = match upgrade_arg {
+        Some(upgrade_arg) => upgrade_arg.max_memory_size_bytes,
+        None => None,
     };
 
-    let bytes = stable::get();
-    let state: ArchiveNodeState = match ciborium::de::from_reader(std::io::Cursor::new(&bytes)) {
-        Ok(state) => state,
-        Err(_) => {
-            // Already migrated to stable structures
-            assert_eq!(stable_memory_version(), MEMORY_VERSION_MEM_MGR_INSTALLED);
-            if let Some(max_memory_size_bytes) = arg_max_memory_size_bytes {
-                print(format!(
-                    "Changing the max_memory_size_bytes to {}",
-                    max_memory_size_bytes
-                ));
-                set_max_memory_size_bytes(max_memory_size_bytes);
-            }
-            print("Archive state already migrated to stable structures, exiting post_upgrade.");
-            return;
-        }
-    };
-
-    assert_eq!(stable_memory_version(), MEMORY_VERSION_NO_MEM_MGR);
-    set_stable_memory_version();
-
-    for block in &state.blocks {
-        append_block(block);
-    }
-
-    set_ledger_canister_id(state.ledger_canister_id);
-    set_block_height_offset(state.block_height_offset);
-    match arg_max_memory_size_bytes {
-        Some(max_memory_size_bytes) => {
-            print(format!(
-                "Changing the max_memory_size_bytes to {}",
-                max_memory_size_bytes
-            ));
-            set_max_memory_size_bytes(max_memory_size_bytes);
-        }
-        None => set_max_memory_size_bytes(state.max_memory_size_bytes as u64),
+    // We do not support migration from scratch stable memory anymore
+    assert_eq!(stable_memory_version(), MEMORY_VERSION_MEM_MGR_INSTALLED);
+    if let Some(max_memory_size_bytes) = arg_max_memory_size_bytes {
+        print(format!(
+            "Changing the max_memory_size_bytes to {}",
+            max_memory_size_bytes
+        ));
+        set_max_memory_size_bytes(max_memory_size_bytes);
     }
-    assert_eq!(state.total_block_size as u64, total_block_size());
 }
 
 fn encode_metrics(w: &mut MetricsEncoder<Vec<u8>>) -> std::io::Result<()> {

rs/ledger_suite/icp/archive/src/main.rs

@@ -79,11 +79,7 @@ impl Setup {
     }
 
     fn upgrade(&self, upgrade_arg: Option<ArchiveUpgradeArgument>, expected_error: Option<String>) {
-        let upgrade_arg = if let Some(upgrade_arg) = upgrade_arg {
-            Encode!(&upgrade_arg).expect("should encode archive upgrade args")
-        } else {
-            vec![]
-        };
+        let upgrade_arg = Encode!(&upgrade_arg).expect("should encode archive upgrade args");
         match self.pocket_ic.upgrade_canister(
             Principal::from(self.canister_id),
             self.archive_wasm.clone(),

rs/ledger_suite/icp/archive/tests/tests.rs

@@ -1,7 +1,6 @@
 use candid::{Decode, Encode};
-use canister_test::{Wasm, WasmResult};
+use canister_test::Wasm;
 use ic_base_types::CanisterId;
-use ic_icp_archive::ArchiveUpgradeArgument;
 use ic_ledger_core::block::BlockType;
 use ic_ledger_core::Tokens;
 use ic_ledger_suite_state_machine_tests::in_memory_ledger::{
@@ -27,8 +26,6 @@ use ic_state_machine_tests::{ErrorCode, StateMachine, UserError};
 use icp_ledger::{
     AccountIdentifier, Archives, Block, FeatureFlags, LedgerCanisterPayload, UpgradeArgs,
 };
-use std::collections::BTreeMap;
-use std::str::FromStr;
 use std::time::Instant;
 
 /// The number of instructions that can be executed in a single canister upgrade as per
@@ -259,7 +256,7 @@ fn should_create_state_machine_with_golden_nns_state() {
     // For breaking changes, e.g., if mainnet is running a version with balances and allowances in
     // stable structures, but master also has blocks in stable structures, `ledger_is_downgradable`
     // should be set to `false`, otherwise `true`.
-    setup.downgrade_to_mainnet(true, true);
+    setup.downgrade_to_mainnet(true);
 
     // Verify ledger balance and allowance state
     // As before, the allowance check needs to be skipped for the mainnet version of the ledger.
@@ -285,8 +282,6 @@ enum ExpectMigration {
     No,
 }
 
-const LARGE_ARCHIVE_CAPACITY: u64 = 10 * 1024 * 1024 * 1024;
-
 impl Setup {
     pub fn new() -> Self {
         let state_machine = new_state_machine_with_golden_nns_state_or_panic();
@@ -320,18 +315,13 @@ impl Setup {
             wait_ledger_ready(&self.state_machine, LEDGER_CANISTER_ID, 100);
         }
         self.check_ledger_metrics(expect_migration);
-        let upgrade_args = BTreeMap::from([(
-            CanisterId::from_str("q3fc5-haaaa-aaaaa-aaahq-cai").unwrap(),
-            2 * LARGE_ARCHIVE_CAPACITY,
-        )]);
-        self.upgrade_archive_canisters(&self.master_wasms.archive, true, upgrade_args);
+        self.upgrade_archive_canisters(
+            &self.master_wasms.archive,
+            Encode!(&()).expect("failed to encode archive upgrade arg"),
+        );
     }
 
-    pub fn downgrade_to_mainnet(
-        &self,
-        ledger_is_downgradable: bool,
-        archive_is_downgradable: bool,
-    ) {
+    pub fn downgrade_to_mainnet(&self, ledger_is_downgradable: bool) {
         println!("Downgrading to mainnet version");
         self.upgrade_index(&self.mainnet_wasms.index);
         match (
@@ -362,11 +352,7 @@ impl Setup {
             }
         }
         self.check_ledger_metrics(ExpectMigration::No);
-        self.upgrade_archive_canisters(
-            &self.mainnet_wasms.archive,
-            archive_is_downgradable,
-            BTreeMap::new(),
-        );
+        self.upgrade_archive_canisters(&self.mainnet_wasms.archive, vec![]);
     }
 
     pub fn perform_upgrade_downgrade_testing(
@@ -426,85 +412,16 @@ impl Setup {
         .expect("failed to decode archives response")
     }
 
-    fn get_remaining_capacity(&self, archive_canister_id: CanisterId) -> u64 {
-        let wasm_result = self
-            .state_machine
-            .execute_ingress(
-                archive_canister_id,
-                "remaining_capacity",
-                Encode!(&()).expect("should encode empty args"),
-            )
-            .unwrap();
-        match wasm_result {
-            WasmResult::Reply(bytes) => Decode!(&bytes, u64).expect("failed to decode usize"),
-            WasmResult::Reject(reason) => panic!("failed to query remaining_capacity: {reason}"),
-        }
-    }
-
-    fn upgrade_archive(
-        &self,
-        archive_canister_id: CanisterId,
-        wasm_bytes: Vec<u8>,
-        archive_is_upgradable: bool,
-        upgrade_arg_max_capacity: Option<u64>,
-    ) {
-        let (upgrade_arg, expect_large_capacity) =
-            if let Some(upgrade_arg_max_capacity) = upgrade_arg_max_capacity {
-                (
-                    Encode!(&ArchiveUpgradeArgument {
-                        max_memory_size_bytes: Some(upgrade_arg_max_capacity)
-                    })
-                    .expect("should encode archive upgrade args"),
-                    archive_is_upgradable,
-                )
-            } else {
-                (vec![], false)
-            };
-        let initial_capacity = self.get_remaining_capacity(archive_canister_id);
-        match self
-            .state_machine
-            .upgrade_canister(archive_canister_id, wasm_bytes, upgrade_arg)
-        {
-            Ok(_) => {
-                if !archive_is_upgradable {
-                    panic!("upgrade should fail")
-                }
-            }
-            Err(e) => {
-                if archive_is_upgradable {
-                    panic!(
-                        "should successfully upgrade archive '{}' to new local version: {}",
-                        archive_canister_id, e
-                    )
-                } else {
-                    assert!(e.description().contains("Decoding stable memory failed"));
-                }
-            }
-        }
-        let final_capacity = self.get_remaining_capacity(archive_canister_id);
-        if expect_large_capacity {
-            // We increased the total capacity to 2 * LARGE_ARCHIVE_CAPACITY,
-            // so the remaining capacity should be larger than LARGE_ARCHIVE_CAPACITY.
-            assert!(final_capacity > LARGE_ARCHIVE_CAPACITY);
-        } else {
-            assert_eq!(initial_capacity, final_capacity);
-        }
-    }
-
-    fn upgrade_archive_canisters(
-        &self,
-        wasm: &Wasm,
-        archive_is_upgradable: bool,
-        upgrade_arg: BTreeMap<CanisterId, u64>,
-    ) {
+    fn upgrade_archive_canisters(&self, wasm: &Wasm, upgrade_arg: Vec<u8>) {
         let archives = self.list_archives().archives;
         for archive_info in &archives {
-            self.upgrade_archive(
-                archive_info.canister_id,
-                wasm.clone().bytes(),
-                archive_is_upgradable,
-                upgrade_arg.get(&archive_info.canister_id).cloned(),
-            );
+            self.state_machine
+                .upgrade_canister(
+                    archive_info.canister_id,
+                    wasm.clone().bytes(),
+                    upgrade_arg.clone(),
+                )
+                .expect("failed to upgrade archive");
         }
     }
 

rs/ledger_suite/icp/tests/golden_nns_state.rs

@@ -177,45 +177,32 @@ impl Setup {
         );
     }
 
-    fn upgrade_archive_canisters(
-        &self,
-        upgrade_to_version: UpgradeToVersion,
-        should_succeed: bool,
-    ) {
-        let archive_wasm_bytes = match upgrade_to_version {
-            UpgradeToVersion::MainNet => build_mainnet_ledger_archive_wasm().bytes(),
-            UpgradeToVersion::Latest => build_ledger_archive_wasm().bytes(),
+    fn upgrade_archive_canisters(&self, upgrade_to_version: UpgradeToVersion) {
+        let (archive_wasm_bytes, upgrade_arg) = match upgrade_to_version {
+            UpgradeToVersion::MainNet => (build_mainnet_ledger_archive_wasm().bytes(), vec![]),
+            UpgradeToVersion::Latest => {
+                (build_ledger_archive_wasm().bytes(), Encode!(&()).unwrap())
+            }
         };
         let mainnet_archive_module_hash = mainnet_archive_canister_sha256sum();
         let ledger_archives = archives(&self.pocket_ic);
         for archive_canister_id in ledger_archives
             .iter()
             .map(|archive| candid::Principal::from(archive.canister_id))
         {
-            match self.pocket_ic.upgrade_canister(
-                archive_canister_id,
-                archive_wasm_bytes.clone(),
-                vec![],
-                None,
-            ) {
-                Ok(_) => {
-                    if !should_succeed {
-                        panic!("Upgrade should fail!");
-                    }
-                }
-                Err(e) => {
-                    if should_succeed {
-                        panic!("Upgrade should succeed!");
-                    } else {
-                        assert!(e.reject_message.contains("Decoding stable memory failed"));
-                    }
-                }
-            };
+            self.pocket_ic
+                .upgrade_canister(
+                    archive_canister_id,
+                    archive_wasm_bytes.clone(),
+                    upgrade_arg.clone(),
+                    None,
+                )
+                .expect("failed to upgrade the archive canister");
 
             self.assert_canister_module_hash(
                 archive_canister_id,
                 &mainnet_archive_module_hash,
-                upgrade_to_version == UpgradeToVersion::MainNet && should_succeed,
+                upgrade_to_version == UpgradeToVersion::MainNet,
             );
         }
     }
@@ -457,13 +444,13 @@ fn should_upgrade_and_downgrade_canister_suite() {
 
     setup.upgrade_index_canister(UpgradeToVersion::Latest);
     setup.upgrade_ledger_canister(UpgradeToVersion::Latest, true);
-    setup.upgrade_archive_canisters(UpgradeToVersion::Latest, true);
+    setup.upgrade_archive_canisters(UpgradeToVersion::Latest);
 
     setup.assert_index_ledger_parity(true);
 
     setup.upgrade_index_canister(UpgradeToVersion::MainNet);
     setup.upgrade_ledger_canister(UpgradeToVersion::MainNet, true);
-    setup.upgrade_archive_canisters(UpgradeToVersion::MainNet, true);
+    setup.upgrade_archive_canisters(UpgradeToVersion::MainNet);
 
     setup.assert_index_ledger_parity(true);
 }