From 09d2c49aa6b46d0f82a9d5587a56dc7008fe7dd3 Mon Sep 17 00:00:00 2001 From: ytqaljn <2716693942@qq.com> Date: Thu, 16 Jan 2025 18:19:28 +0800 Subject: [PATCH 1/3] feat: multiblock migration for file-bank and sminer --- Cargo.lock | 1 + Cargo.toml | 1 + pallets/file-bank/Cargo.toml | 3 +- pallets/file-bank/src/benchmarking.rs | 1072 ++++++++++--------- pallets/file-bank/src/functions.rs | 62 +- pallets/file-bank/src/impls/receptionist.rs | 11 - pallets/file-bank/src/lib.rs | 120 +-- pallets/file-bank/src/migration.rs | 212 ++++ pallets/file-bank/src/migrations.rs | 227 ---- pallets/file-bank/src/types.rs | 12 +- pallets/file-bank/src/weights.rs | 30 +- pallets/sminer/src/benchmarking.rs | 487 +++++---- pallets/sminer/src/lib.rs | 40 +- pallets/sminer/src/migration.rs | 134 +++ pallets/sminer/src/types.rs | 2 +- pallets/sminer/src/weights.rs | 27 +- standalone/chain/runtime/src/lib.rs | 9 +- 17 files changed, 1287 insertions(+), 1163 deletions(-) create mode 100644 pallets/file-bank/src/migration.rs delete mode 100644 pallets/file-bank/src/migrations.rs create mode 100644 pallets/sminer/src/migration.rs diff --git a/Cargo.lock b/Cargo.lock index a1145f8f..85d37fb4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10510,6 +10510,7 @@ dependencies = [ "frame-support-test", "frame-system", "hex", + "impl-trait-for-tuples", "log", "pallet-bags-list", "pallet-balances", diff --git a/Cargo.toml b/Cargo.toml index a677e034..a0877764 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -333,6 +333,7 @@ hex-literal = "0.4.1" humantime = "2.1.0" h2 = { version = "0.4" } im = { version = "15", default-features = false } +impl-trait-for-tuples = { version = "0.2.2" } impl-serde = "0.5.0" insta = "1" itertools = { version = "0.13", default-features = false } diff --git a/pallets/file-bank/Cargo.toml b/pallets/file-bank/Cargo.toml index 465deac9..3b224c2e 100755 --- a/pallets/file-bank/Cargo.toml +++ b/pallets/file-bank/Cargo.toml @@ -18,6 +18,7 @@ serde_json = { workspace = true, features = ['alloc'] } log = { workspace = true } rand_chacha = { workspace = true, optional = true } hex = { workspace = true } +impl-trait-for-tuples = { workspace = true } sp-io = { workspace = true } sp-std = { workspace = true } @@ -87,4 +88,4 @@ runtime-benchmarks = [ "pallet-grandpa/runtime-benchmarks", "rand_chacha", ] -try-runtime = [ "frame-support/try-runtime" ] +try-runtime = [ "frame-support/try-runtime" ] \ No newline at end of file diff --git a/pallets/file-bank/src/benchmarking.rs b/pallets/file-bank/src/benchmarking.rs index 9bacb18e..12ab6a8f 100755 --- a/pallets/file-bank/src/benchmarking.rs +++ b/pallets/file-bank/src/benchmarking.rs @@ -1,11 +1,17 @@ use super::*; -use crate::{Pallet as FileBank, *}; +use crate::{Pallet as FileBank, *, + migration::{ + v03::{File as FileV3, DealMap as DealMapV3, OldFileInfo, OldUserBrief, OldDealInfo}, + }, +}; // use cp_cess_common::{Hash, IpAddress}; // use codec::{alloc::string::ToString, Decode}; pub use frame_benchmarking::{ - account, benchmarks, impl_benchmark_test_suite, whitelist_account, whitelisted_caller, + account, benchmarks, impl_benchmark_test_suite, whitelist_account, whitelisted_caller, }; -use frame_support::traits::Currency; +use crate::migration::MigrationStep; +use frame_support::{migrations::SteppedMigration, weights::WeightMeter, traits::Currency}; +use frame_benchmarking::v2::{*, benchmarks as benchmarksV2}; // use frame_support::{ // dispatch::UnfilteredDispatchable, // pallet_prelude::*, @@ -105,14 +111,12 @@ pub fn initialize_file_from_scratch() -> Result<(), &'static str> { let _ = buy_space::(user.clone())?; let file_name = "test-file".as_bytes().to_vec(); - let bucket_name = "test-bucket1".as_bytes().to_vec(); let file_hash: Hash = Hash([80u8; 64]); let file_size: u128 = SEGMENT_SIZE * 3; let territory_name: TerrName = "t1".as_bytes().to_vec().try_into().map_err(|_| "boundedvec error")?; let user_brief = UserBrief:: { user: user.clone(), file_name: file_name.try_into().map_err(|_e| "file name convert err")?, - bucket_name: bucket_name.try_into().map_err(|_e| "bucket name convert err")?, territory_name, }; @@ -144,523 +148,611 @@ pub fn initialize_file_from_scratch() -> Result<(), &'static str> { Ok(()) } -// pub fn create_deal_info(acc: AccountOf, length: u32, hash_seed: u8) -> Result, &'static str> { -// let mut deal_info: BoundedVec, T::SegmentCount> = Default::default(); -// let file_name = "test-file".as_bytes().to_vec(); -// let bucket_name = "test-bucket1".as_bytes().to_vec(); -// let file_hash: Hash = Hash([hash_seed; 64]); -// let user_brief = UserBrief::{ -// user: acc, -// file_name: file_name.try_into().map_err(|_e| "file name convert err")?, -// bucket_name: bucket_name.try_into().map_err(|_e| "bucket name convert err")?, -// }; - -// let mut seed = 0; -// for i in 0 .. length { -// let segment_list = SegmentList:: { -// hash: Hash([1u8; 64]), -// fragment_list: [ -// Hash([97u8; 64]), -// Hash([98u8; 64]), -// Hash([99u8; 64]), -// ].to_vec().try_into().unwrap(), -// }; +fn create_file_for_v3_migrate() { + let user: AccountOf = account("user1", 100, SEED); + let file_name = "test-file".as_bytes().to_vec(); + let bucket_name = "bucket-name".as_bytes().to_vec(); + let file_hash: Hash = Hash([80u8; 64]); + let file_size: u128 = SEGMENT_SIZE * 3; + let territory_name: TerrName = "t1".as_bytes().to_vec().try_into().unwrap(); + let user_brief = OldUserBrief:: { + user: user.clone(), + file_name: file_name.try_into().unwrap(), + bucket_name: bucket_name.try_into().unwrap(), + territory_name, + }; -// deal_info.try_push(segment_list).unwrap(); -// } + // let mut deal_info: BoundedVec, T::SegmentCount> = Default::default(); + let segment_info = SegmentInfo::{ + hash: Hash([65u8; 64]), + fragment_list: vec![ + FragmentInfo::{hash: Hash([97u8; 64]), avail: true, tag: Some(1u64.saturated_into()), miner: user.clone() }, + FragmentInfo::{hash: Hash([97u8; 64]), avail: true, tag: Some(1u64.saturated_into()), miner: user.clone() }, + FragmentInfo::{hash: Hash([97u8; 64]), avail: true, tag: Some(1u64.saturated_into()), miner: user.clone() }, + FragmentInfo::{hash: Hash([97u8; 64]), avail: true, tag: Some(1u64.saturated_into()), miner: user.clone() }, + FragmentInfo::{hash: Hash([97u8; 64]), avail: true, tag: Some(1u64.saturated_into()), miner: user.clone() }, + FragmentInfo::{hash: Hash([97u8; 64]), avail: true, tag: Some(1u64.saturated_into()), miner: user.clone() }, + FragmentInfo::{hash: Hash([97u8; 64]), avail: true, tag: Some(1u64.saturated_into()), miner: user.clone() }, + FragmentInfo::{hash: Hash([97u8; 64]), avail: true, tag: Some(1u64.saturated_into()), miner: user.clone() }, + FragmentInfo::{hash: Hash([97u8; 64]), avail: true, tag: Some(1u64.saturated_into()), miner: user.clone() }, + FragmentInfo::{hash: Hash([97u8; 64]), avail: true, tag: Some(1u64.saturated_into()), miner: user.clone() }, + FragmentInfo::{hash: Hash([97u8; 64]), avail: true, tag: Some(1u64.saturated_into()), miner: user.clone() }, + FragmentInfo::{hash: Hash([97u8; 64]), avail: true, tag: Some(1u64.saturated_into()), miner: user.clone() }, + ].try_into().unwrap(), + }; + // deal_info.try_push(segment_list).unwrap(); + + let file_info = OldFileInfo::{ + segment_list: vec![segment_info].try_into().unwrap(), + owner: vec![user_brief.clone()].try_into().unwrap(), + file_size: 1086574, + completion: 1u64.saturated_into(), + stat: FileState::Active, + }; -// Ok(DealSubmitInfo::{ -// file_hash: file_hash, -// user_brief: user_brief, -// segment_list: deal_info, -// file_size: 123, -// }) -// } + FileV3::::insert(Hash([66u8; 64]), file_info); +} -// pub fn create_new_bucket(caller: T::AccountId, name: Vec) -> Result<(), &'static str> { -// let name = name.try_into().map_err(|_| "create bucket convert error")?; -// FileBank::::create_bucket(RawOrigin::Signed(caller.clone()).into(), caller, name)?; -// Ok(()) -// } +fn create_deal_for_v3_migrate() { + let user: AccountOf = account("user1", 100, SEED); + let file_name = "test-file".as_bytes().to_vec(); + let bucket_name = "bucket-name".as_bytes().to_vec(); + let file_hash: Hash = Hash([80u8; 64]); + let file_size: u128 = SEGMENT_SIZE * 3; + let territory_name: TerrName = "t1".as_bytes().to_vec().try_into().unwrap(); + let user_brief = OldUserBrief:: { + user: user.clone(), + file_name: file_name.try_into().unwrap(), + bucket_name: bucket_name.try_into().unwrap(), + territory_name, + }; -benchmarks! { - cert_idle_space { - log::info!("start cert_idle_space"); - pallet_tee_worker::benchmarking::generate_workers::(); - let miner: AccountOf = account("miner1", 100, SEED); - let _ = pallet_sminer::benchmarking::register_positive_miner::(miner.clone())?; + let segment_list = SegmentList:: { + hash: Hash([65u8; 64]), + fragment_list: [ + Hash([66u8; 64]), + Hash([67u8; 64]), + Hash([68u8; 64]), + Hash([69u8; 64]), + Hash([70u8; 64]), + Hash([71u8; 64]), + Hash([72u8; 64]), + Hash([73u8; 64]), + Hash([74u8; 64]), + Hash([75u8; 64]), + Hash([76u8; 64]), + Hash([77u8; 64]), + ].to_vec().try_into().unwrap(), + }; - let pois_key = PoISKey { - g: [2u8; 256], - n: [3u8; 256], - }; - - let space_proof_info = SpaceProofInfo::> { - miner: miner.clone(), - front: u64::MIN, - rear: 1000, - pois_key: pois_key.clone(), - accumulator: pois_key.g, - }; - - let tee_puk = pallet_tee_worker::benchmarking::get_pubkey::(); - let tee_puk_encode = tee_puk.encode(); - let idle_sig_info_encode = space_proof_info.encode(); - let mut original = Vec::new(); - original.extend_from_slice(&idle_sig_info_encode); - original.extend_from_slice(&tee_puk_encode); - let original = sp_io::hashing::sha2_256(&original); - let sig = pallet_tee_worker::benchmarking::sign_message::(&original); - let sig: BoundedVec> = sig.0.to_vec().try_into().map_err(|_| "bounded convert error")?; - }: _(RawOrigin::Signed(miner.clone()), space_proof_info, sig.clone(), sig, tee_puk) - verify { - let (idle, service) = T::MinerControl::get_power(&miner)?; - assert_eq!(idle, 1000 * IDLE_SEG_SIZE); - } + let old_deal_info = OldDealInfo:: { + file_size: file_size, + segment_list: vec![segment_list].try_into().unwrap(), + user: user_brief, + complete_list: Default::default(), + }; - upload_declaration { - let v in 1 .. 30; - log::info!("start upload_declaration"); - pallet_tee_worker::benchmarking::generate_workers::(); - let user: AccountOf = account("user1", 100, SEED); - let miner: AccountOf = account("miner1", 100, SEED); - let _ = pallet_sminer::benchmarking::register_positive_miner::(miner.clone())?; - let _ = cert_idle_for_miner::(miner)?; - let _ = buy_space::(user.clone())?; - - let file_name = "test-file".as_bytes().to_vec(); - let bucket_name = "test-bucket1".as_bytes().to_vec(); - let file_hash: Hash = Hash([80u8; 64]); - let file_size: u128 = SEGMENT_SIZE * 3; - let territory_name: TerrName = "t1".as_bytes().to_vec().try_into().map_err(|_| "boundedvec error")?; - let user_brief = UserBrief:: { - user: user.clone(), - file_name: file_name.try_into().map_err(|_e| "file name convert err")?, - bucket_name: bucket_name.try_into().map_err(|_e| "bucket name convert err")?, - territory_name, - }; - - let mut deal_info: BoundedVec, T::SegmentCount> = Default::default(); - for i in 0 .. v { - let segment_list = SegmentList:: { - hash: Hash([65u8; 64]), - fragment_list: [ - Hash([66u8; 64]), - Hash([67u8; 64]), - Hash([68u8; 64]), - Hash([69u8; 64]), - Hash([70u8; 64]), - Hash([71u8; 64]), - Hash([72u8; 64]), - Hash([73u8; 64]), - Hash([74u8; 64]), - Hash([75u8; 64]), - Hash([76u8; 64]), - Hash([77u8; 64]), - ].to_vec().try_into().unwrap(), - }; - deal_info.try_push(segment_list).unwrap(); + DealMapV3::::insert(Hash([97u8; 64]), old_deal_info); +} + +#[benchmarksV2] +mod migrate { + use super::*; + // use frame_benchmarking::v2::benchmarks; + + #[benchmark(pov_mode = Measured)] + fn v03_migration_step() -> Result<(), BenchmarkError> { + create_deal_for_v3_migrate::(); + create_file_for_v3_migrate::(); + let mut m = crate::migration::v03::Migration::::default(); + + #[block] + { + m.step(&mut WeightMeter::new()); } - }: _(RawOrigin::Signed(user), file_hash.clone(), deal_info, user_brief, file_size) - verify { - assert!(DealMap::::contains_key(&file_hash)); + + assert!(File::::contains_key(&Hash([66u8; 64]))); + Ok(()) } - transfer_report { - let v in 1 .. 30; - log::info!("start transfer_report"); - pallet_tee_worker::benchmarking::generate_workers::(); - let user: AccountOf = account("user1", 100, SEED); - let mut positive_miner: Vec> = Default::default(); - for i in 0 .. 12 { - let miner: AccountOf = account(miner_list[i as usize], 100, SEED); - positive_miner.push(miner.clone()); - let _ = pallet_sminer::benchmarking::register_positive_miner::(miner.clone())?; - let _ = cert_idle_for_miner::(miner)?; + #[benchmark] + fn migration_noop() { + create_deal_for_v3_migrate::(); + create_file_for_v3_migrate::(); + #[block] + { + Migration::::migrate(&mut WeightMeter::new()); } - let _ = buy_space::(user.clone())?; - - let file_name = "test-file".as_bytes().to_vec(); - let bucket_name = "test-bucket1".as_bytes().to_vec(); - let file_hash: Hash = Hash([80u8; 64]); - let file_size: u128 = SEGMENT_SIZE * 3; - let territory_name: TerrName = "t1".as_bytes().to_vec().try_into().map_err(|_| "boundedvec error")?; - let user_brief = UserBrief:: { - user: user.clone(), - file_name: file_name.try_into().map_err(|_e| "file name convert err")?, - bucket_name: bucket_name.try_into().map_err(|_e| "bucket name convert err")?, - territory_name, - }; - - let mut deal_info: BoundedVec, T::SegmentCount> = Default::default(); - for i in 0 .. v { - let segment_list = SegmentList:: { - hash: Hash([65u8; 64]), - fragment_list: [ - Hash([66u8; 64]), - Hash([67u8; 64]), - Hash([68u8; 64]), - Hash([69u8; 64]), - Hash([70u8; 64]), - Hash([71u8; 64]), - Hash([72u8; 64]), - Hash([73u8; 64]), - Hash([74u8; 64]), - Hash([75u8; 64]), - Hash([76u8; 64]), - Hash([77u8; 64]), - ].to_vec().try_into().unwrap(), - }; - deal_info.try_push(segment_list).unwrap(); - } + assert_eq!(StorageVersion::get::>(), 3); + } - FileBank::::upload_declaration(RawOrigin::Signed(user).into(), file_hash.clone(), deal_info, user_brief, file_size)?; + #[benchmark] + fn on_runtime_upgrade_noop() { + create_deal_for_v3_migrate::(); + create_file_for_v3_migrate::(); + #[block] + { + as frame_support::traits::OnRuntimeUpgrade>::on_runtime_upgrade(); + } + assert!(MigrationInProgress::::get().is_none()); + } - for i in 0 .. 11 { - FileBank::::transfer_report(RawOrigin::Signed(positive_miner[i as usize].clone()).into(), i + 1, file_hash.clone())?; + #[benchmark] + fn on_runtime_upgrade_in_progress() { + create_deal_for_v3_migrate::(); + create_file_for_v3_migrate::(); + let v = vec![42u8].try_into().ok(); + MigrationInProgress::::set(v.clone()); + #[block] + { + as frame_support::traits::OnRuntimeUpgrade>::on_runtime_upgrade(); } - }: _(RawOrigin::Signed(positive_miner[11].clone()), 12, file_hash.clone()) - verify { - assert!(>::contains_key(&file_hash)); + assert!(MigrationInProgress::::get().is_some()); + assert_eq!(MigrationInProgress::::get(), v); } - calculate_report { - log::info!("start calculate_report"); - pallet_tee_worker::benchmarking::generate_workers::(); - let user: AccountOf = account("user1", 100, SEED); - let mut positive_miner: Vec> = Default::default(); - for i in 0 .. 12 { - let miner: AccountOf = account(miner_list[i as usize], 100, SEED); - positive_miner.push(miner.clone()); - let _ = pallet_sminer::benchmarking::register_positive_miner::(miner.clone())?; - let _ = cert_idle_for_miner::(miner)?; + // This benchmarks the weight of running on_runtime_upgrade when there is a migration to + // process. + #[benchmark(pov_mode = Measured)] + fn on_runtime_upgrade() { + StorageVersion::new(2).put::>(); + create_deal_for_v3_migrate::(); + create_file_for_v3_migrate::(); + #[block] + { + as frame_support::traits::OnRuntimeUpgrade>::on_runtime_upgrade(); } + assert!(MigrationInProgress::::get().is_some()); + } +} + +// benchmarks! { +// cert_idle_space { +// log::info!("start cert_idle_space"); +// pallet_tee_worker::benchmarking::generate_workers::(); +// let miner: AccountOf = account("miner1", 100, SEED); +// let _ = pallet_sminer::benchmarking::register_positive_miner::(miner.clone())?; + +// let pois_key = PoISKey { +// g: [2u8; 256], +// n: [3u8; 256], +// }; + +// let space_proof_info = SpaceProofInfo::> { +// miner: miner.clone(), +// front: u64::MIN, +// rear: 1000, +// pois_key: pois_key.clone(), +// accumulator: pois_key.g, +// }; + +// let tee_puk = pallet_tee_worker::benchmarking::get_pubkey::(); +// let tee_puk_encode = tee_puk.encode(); +// let idle_sig_info_encode = space_proof_info.encode(); +// let mut original = Vec::new(); +// original.extend_from_slice(&idle_sig_info_encode); +// original.extend_from_slice(&tee_puk_encode); +// let original = sp_io::hashing::sha2_256(&original); +// let sig = pallet_tee_worker::benchmarking::sign_message::(&original); +// let sig: BoundedVec> = sig.0.to_vec().try_into().map_err(|_| "bounded convert error")?; +// }: _(RawOrigin::Signed(miner.clone()), space_proof_info, sig.clone(), sig, tee_puk) +// verify { +// let (idle, service) = T::MinerControl::get_power(&miner)?; +// assert_eq!(idle, 1000 * IDLE_SEG_SIZE); +// } + +// upload_declaration { +// let v in 1 .. 30; +// log::info!("start upload_declaration"); +// pallet_tee_worker::benchmarking::generate_workers::(); +// let user: AccountOf = account("user1", 100, SEED); +// let miner: AccountOf = account("miner1", 100, SEED); +// let _ = pallet_sminer::benchmarking::register_positive_miner::(miner.clone())?; +// let _ = cert_idle_for_miner::(miner)?; +// let _ = buy_space::(user.clone())?; + +// let file_name = "test-file".as_bytes().to_vec(); +// let file_hash: Hash = Hash([80u8; 64]); +// let file_size: u128 = SEGMENT_SIZE * 3; +// let territory_name: TerrName = "t1".as_bytes().to_vec().try_into().map_err(|_| "boundedvec error")?; +// let user_brief = UserBrief:: { +// user: user.clone(), +// file_name: file_name.try_into().map_err(|_e| "file name convert err")?, +// territory_name, +// }; + +// let mut deal_info: BoundedVec, T::SegmentCount> = Default::default(); +// for i in 0 .. v { +// let segment_list = SegmentList:: { +// hash: Hash([65u8; 64]), +// fragment_list: [ +// Hash([66u8; 64]), +// Hash([67u8; 64]), +// Hash([68u8; 64]), +// Hash([69u8; 64]), +// Hash([70u8; 64]), +// Hash([71u8; 64]), +// Hash([72u8; 64]), +// Hash([73u8; 64]), +// Hash([74u8; 64]), +// Hash([75u8; 64]), +// Hash([76u8; 64]), +// Hash([77u8; 64]), +// ].to_vec().try_into().unwrap(), +// }; +// deal_info.try_push(segment_list).unwrap(); +// } +// }: _(RawOrigin::Signed(user), file_hash.clone(), deal_info, user_brief, file_size) +// verify { +// assert!(DealMap::::contains_key(&file_hash)); +// } - let _ = buy_space::(user.clone())?; +// transfer_report { +// let v in 1 .. 30; +// log::info!("start transfer_report"); +// pallet_tee_worker::benchmarking::generate_workers::(); +// let user: AccountOf = account("user1", 100, SEED); +// let mut positive_miner: Vec> = Default::default(); +// for i in 0 .. 12 { +// let miner: AccountOf = account(miner_list[i as usize], 100, SEED); +// positive_miner.push(miner.clone()); +// let _ = pallet_sminer::benchmarking::register_positive_miner::(miner.clone())?; +// let _ = cert_idle_for_miner::(miner)?; +// } + +// let _ = buy_space::(user.clone())?; - let file_name = "test-file".as_bytes().to_vec(); - let bucket_name = "test-bucket1".as_bytes().to_vec(); - let file_hash: Hash = Hash([80u8; 64]); - let file_size: u128 = SEGMENT_SIZE * 3; - let territory_name: TerrName = "t1".as_bytes().to_vec().try_into().map_err(|_| "boundedvec error")?; - let user_brief = UserBrief:: { - user: user.clone(), - file_name: file_name.try_into().map_err(|_e| "file name convert err")?, - bucket_name: bucket_name.try_into().map_err(|_e| "bucket name convert err")?, - territory_name, - }; +// let file_name = "test-file".as_bytes().to_vec(); +// let file_hash: Hash = Hash([80u8; 64]); +// let file_size: u128 = SEGMENT_SIZE * 3; +// let territory_name: TerrName = "t1".as_bytes().to_vec().try_into().map_err(|_| "boundedvec error")?; +// let user_brief = UserBrief:: { +// user: user.clone(), +// file_name: file_name.try_into().map_err(|_e| "file name convert err")?, +// territory_name, +// }; - let mut deal_info: BoundedVec, T::SegmentCount> = Default::default(); - - let segment_list = SegmentList:: { - hash: Hash([65u8; 64]), - fragment_list: [ - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - ].to_vec().try_into().unwrap(), - }; - deal_info.try_push(segment_list).unwrap(); - - FileBank::::upload_declaration(RawOrigin::Signed(user).into(), file_hash.clone(), deal_info, user_brief, file_size)?; - - for i in 0 .. 12 { - FileBank::::transfer_report(RawOrigin::Signed(positive_miner[i as usize].clone()).into(), i + 1, file_hash.clone())?; - } +// let mut deal_info: BoundedVec, T::SegmentCount> = Default::default(); +// for i in 0 .. v { +// let segment_list = SegmentList:: { +// hash: Hash([65u8; 64]), +// fragment_list: [ +// Hash([66u8; 64]), +// Hash([67u8; 64]), +// Hash([68u8; 64]), +// Hash([69u8; 64]), +// Hash([70u8; 64]), +// Hash([71u8; 64]), +// Hash([72u8; 64]), +// Hash([73u8; 64]), +// Hash([74u8; 64]), +// Hash([75u8; 64]), +// Hash([76u8; 64]), +// Hash([77u8; 64]), +// ].to_vec().try_into().unwrap(), +// }; +// deal_info.try_push(segment_list).unwrap(); +// } + +// FileBank::::upload_declaration(RawOrigin::Signed(user).into(), file_hash.clone(), deal_info, user_brief, file_size)?; + +// for i in 0 .. 11 { +// FileBank::::transfer_report(RawOrigin::Signed(positive_miner[i as usize].clone()).into(), i + 1, file_hash.clone())?; +// } +// }: _(RawOrigin::Signed(positive_miner[11].clone()), 12, file_hash.clone()) +// verify { +// assert!(>::contains_key(&file_hash)); +// } - let tee_puk = pallet_tee_worker::benchmarking::get_pubkey::(); - let mut digest_list: BoundedVec> = Default::default(); - let digest_info = DigestInfo { - fragment: Hash([97u8; 64]), - tee_puk : tee_puk, - }; - digest_list.try_push(digest_info).unwrap(); - let tag_sig_info = TagSigInfo::> { - miner: positive_miner[0].clone(), - digest: digest_list, - file_hash: file_hash.clone(), - }; - - let idle_sig_info_encode = tag_sig_info.encode(); - let original = sp_io::hashing::sha2_256(&idle_sig_info_encode); - let sig = pallet_tee_worker::benchmarking::sign_message::(&original); - let sig: BoundedVec> = sig.0.to_vec().try_into().map_err(|_| "bounded convert error")?; - assert!(>::contains_key(&file_hash)); - let (_, service) = T::MinerControl::get_power(&positive_miner[0]).unwrap(); - assert_eq!(service, 0); - }: _(RawOrigin::Signed(positive_miner[0].clone()), sig, tag_sig_info) - verify { - let (_, service) = T::MinerControl::get_power(&positive_miner[0]).unwrap(); - assert_eq!(service, FRAGMENT_SIZE * 1); - } +// calculate_report { +// log::info!("start calculate_report"); +// pallet_tee_worker::benchmarking::generate_workers::(); +// let user: AccountOf = account("user1", 100, SEED); +// let mut positive_miner: Vec> = Default::default(); +// for i in 0 .. 12 { +// let miner: AccountOf = account(miner_list[i as usize], 100, SEED); +// positive_miner.push(miner.clone()); +// let _ = pallet_sminer::benchmarking::register_positive_miner::(miner.clone())?; +// let _ = cert_idle_for_miner::(miner)?; +// } + +// let _ = buy_space::(user.clone())?; + +// let file_name = "test-file".as_bytes().to_vec(); +// let file_hash: Hash = Hash([80u8; 64]); +// let file_size: u128 = SEGMENT_SIZE * 3; +// let territory_name: TerrName = "t1".as_bytes().to_vec().try_into().map_err(|_| "boundedvec error")?; +// let user_brief = UserBrief:: { +// user: user.clone(), +// file_name: file_name.try_into().map_err(|_e| "file name convert err")?, +// territory_name, +// }; + +// let mut deal_info: BoundedVec, T::SegmentCount> = Default::default(); - replace_idle_space { - let v in 8 .. 30; - log::info!("start replace_idle_space"); - pallet_tee_worker::benchmarking::generate_workers::(); - let user: AccountOf = account("user1", 100, SEED); - let mut positive_miner: Vec> = Default::default(); - for i in 0 .. 12 { - let miner: AccountOf = account(miner_list[i as usize], 100, SEED); - positive_miner.push(miner.clone()); - let _ = pallet_sminer::benchmarking::register_positive_miner::(miner.clone())?; - let _ = cert_idle_for_miner::(miner)?; - } +// let segment_list = SegmentList:: { +// hash: Hash([65u8; 64]), +// fragment_list: [ +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// ].to_vec().try_into().unwrap(), +// }; +// deal_info.try_push(segment_list).unwrap(); - let _ = buy_space::(user.clone())?; - - let file_name = "test-file".as_bytes().to_vec(); - let bucket_name = "test-bucket1".as_bytes().to_vec(); - let file_hash: Hash = Hash([80u8; 64]); - let file_size: u128 = SEGMENT_SIZE * 3; - let territory_name: TerrName = "t1".as_bytes().to_vec().try_into().map_err(|_| "boundedvec error")?; - let user_brief = UserBrief:: { - user: user.clone(), - file_name: file_name.try_into().map_err(|_e| "file name convert err")?, - bucket_name: bucket_name.try_into().map_err(|_e| "bucket name convert err")?, - territory_name, - }; - - let mut deal_info: BoundedVec, T::SegmentCount> = Default::default(); - for i in 0 .. v { - let segment_list = SegmentList:: { - hash: Hash([65u8; 64]), - fragment_list: [ - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - ].to_vec().try_into().unwrap(), - }; - deal_info.try_push(segment_list).unwrap(); - } +// FileBank::::upload_declaration(RawOrigin::Signed(user).into(), file_hash.clone(), deal_info, user_brief, file_size)?; - FileBank::::upload_declaration(RawOrigin::Signed(user).into(), file_hash.clone(), deal_info, user_brief, file_size)?; +// for i in 0 .. 12 { +// FileBank::::transfer_report(RawOrigin::Signed(positive_miner[i as usize].clone()).into(), i + 1, file_hash.clone())?; +// } - for i in 0 .. 12 { - FileBank::::transfer_report(RawOrigin::Signed(positive_miner[i as usize].clone()).into(), i + 1, file_hash.clone())?; - } +// let tee_puk = pallet_tee_worker::benchmarking::get_pubkey::(); +// let mut digest_list: BoundedVec> = Default::default(); +// let digest_info = DigestInfo { +// fragment: Hash([97u8; 64]), +// tee_puk : tee_puk, +// }; +// digest_list.try_push(digest_info).unwrap(); +// let tag_sig_info = TagSigInfo::> { +// miner: positive_miner[0].clone(), +// digest: digest_list, +// file_hash: file_hash.clone(), +// }; - let tee_puk = pallet_tee_worker::benchmarking::get_pubkey::(); - let mut digest_list: BoundedVec> = Default::default(); - for i in 0 .. v { - let digest_info = DigestInfo { - fragment: Hash([97u8; 64]), - tee_puk : tee_puk, - }; - digest_list.try_push(digest_info).unwrap(); - } - let tag_sig_info = TagSigInfo::> { - miner: positive_miner[0].clone(), - digest: digest_list, - file_hash: file_hash.clone(), - }; - let idle_sig_info_encode = tag_sig_info.encode(); - let original = sp_io::hashing::sha2_256(&idle_sig_info_encode); - let sig = pallet_tee_worker::benchmarking::sign_message::(&original); - let sig: BoundedVec> = sig.0.to_vec().try_into().map_err(|_| "bounded convert error")?; - FileBank::::calculate_report(RawOrigin::Signed(positive_miner[0].clone()).into(), sig, tag_sig_info)?; - - let pois_key = PoISKey { - g: [2u8; 256], - n: [3u8; 256], - }; - - let space_proof_info = SpaceProofInfo::> { - miner: positive_miner[0].clone(), - front: 1, - rear: 1000, - pois_key: pois_key.clone(), - accumulator: pois_key.g, - }; - - let idle_sig_info_encode = space_proof_info.encode(); - let tee_puk_encode = tee_puk.encode(); - let mut original = Vec::new(); - original.extend_from_slice(&idle_sig_info_encode); - original.extend_from_slice(&tee_puk_encode); - let original = sp_io::hashing::sha2_256(&original); - - let sig = pallet_tee_worker::benchmarking::sign_message::(&original); - let sig: BoundedVec> = sig.0.to_vec().try_into().map_err(|_| "bounded convert error")?; - let replace_space = pallet_sminer::benchmarking::get_replace_space::(positive_miner[0].clone()).unwrap(); - assert_eq!(replace_space, FRAGMENT_SIZE * v as u128); - }: _(RawOrigin::Signed(positive_miner[0].clone()), space_proof_info, sig.clone(), sig, tee_puk) - verify { - let replace_space = pallet_sminer::benchmarking::get_replace_space::(positive_miner[0].clone()).unwrap(); - assert_eq!(replace_space, FRAGMENT_SIZE * v as u128 - IDLE_SEG_SIZE); - } +// let idle_sig_info_encode = tag_sig_info.encode(); +// let original = sp_io::hashing::sha2_256(&idle_sig_info_encode); +// let sig = pallet_tee_worker::benchmarking::sign_message::(&original); +// let sig: BoundedVec> = sig.0.to_vec().try_into().map_err(|_| "bounded convert error")?; +// assert!(>::contains_key(&file_hash)); +// let (_, service) = T::MinerControl::get_power(&positive_miner[0]).unwrap(); +// assert_eq!(service, 0); +// }: _(RawOrigin::Signed(positive_miner[0].clone()), sig, tag_sig_info) +// verify { +// let (_, service) = T::MinerControl::get_power(&positive_miner[0]).unwrap(); +// assert_eq!(service, FRAGMENT_SIZE * 1); +// } - delete_file { - log::info!("start delete_file"); - pallet_tee_worker::benchmarking::generate_workers::(); - let user: AccountOf = account("user1", 100, SEED); - let mut positive_miner: Vec> = Default::default(); - for i in 0 .. 12 { - let miner: AccountOf = account(miner_list[i as usize], 100, SEED); - positive_miner.push(miner.clone()); - let _ = pallet_sminer::benchmarking::register_positive_miner::(miner.clone())?; - let _ = cert_idle_for_miner::(miner)?; - } +// replace_idle_space { +// let v in 8 .. 30; +// log::info!("start replace_idle_space"); +// pallet_tee_worker::benchmarking::generate_workers::(); +// let user: AccountOf = account("user1", 100, SEED); +// let mut positive_miner: Vec> = Default::default(); +// for i in 0 .. 12 { +// let miner: AccountOf = account(miner_list[i as usize], 100, SEED); +// positive_miner.push(miner.clone()); +// let _ = pallet_sminer::benchmarking::register_positive_miner::(miner.clone())?; +// let _ = cert_idle_for_miner::(miner)?; +// } + +// let _ = buy_space::(user.clone())?; + +// let file_name = "test-file".as_bytes().to_vec(); +// let file_hash: Hash = Hash([80u8; 64]); +// let file_size: u128 = SEGMENT_SIZE * 3; +// let territory_name: TerrName = "t1".as_bytes().to_vec().try_into().map_err(|_| "boundedvec error")?; +// let user_brief = UserBrief:: { +// user: user.clone(), +// file_name: file_name.try_into().map_err(|_e| "file name convert err")?, +// territory_name, +// }; - let _ = buy_space::(user.clone())?; +// let mut deal_info: BoundedVec, T::SegmentCount> = Default::default(); +// for i in 0 .. v { +// let segment_list = SegmentList:: { +// hash: Hash([65u8; 64]), +// fragment_list: [ +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// ].to_vec().try_into().unwrap(), +// }; +// deal_info.try_push(segment_list).unwrap(); +// } + +// FileBank::::upload_declaration(RawOrigin::Signed(user).into(), file_hash.clone(), deal_info, user_brief, file_size)?; + +// for i in 0 .. 12 { +// FileBank::::transfer_report(RawOrigin::Signed(positive_miner[i as usize].clone()).into(), i + 1, file_hash.clone())?; +// } + +// let tee_puk = pallet_tee_worker::benchmarking::get_pubkey::(); +// let mut digest_list: BoundedVec> = Default::default(); +// for i in 0 .. v { +// let digest_info = DigestInfo { +// fragment: Hash([97u8; 64]), +// tee_puk : tee_puk, +// }; +// digest_list.try_push(digest_info).unwrap(); +// } +// let tag_sig_info = TagSigInfo::> { +// miner: positive_miner[0].clone(), +// digest: digest_list, +// file_hash: file_hash.clone(), +// }; +// let idle_sig_info_encode = tag_sig_info.encode(); +// let original = sp_io::hashing::sha2_256(&idle_sig_info_encode); +// let sig = pallet_tee_worker::benchmarking::sign_message::(&original); +// let sig: BoundedVec> = sig.0.to_vec().try_into().map_err(|_| "bounded convert error")?; +// FileBank::::calculate_report(RawOrigin::Signed(positive_miner[0].clone()).into(), sig, tag_sig_info)?; + +// let pois_key = PoISKey { +// g: [2u8; 256], +// n: [3u8; 256], +// }; + +// let space_proof_info = SpaceProofInfo::> { +// miner: positive_miner[0].clone(), +// front: 1, +// rear: 1000, +// pois_key: pois_key.clone(), +// accumulator: pois_key.g, +// }; + +// let idle_sig_info_encode = space_proof_info.encode(); +// let tee_puk_encode = tee_puk.encode(); +// let mut original = Vec::new(); +// original.extend_from_slice(&idle_sig_info_encode); +// original.extend_from_slice(&tee_puk_encode); +// let original = sp_io::hashing::sha2_256(&original); + +// let sig = pallet_tee_worker::benchmarking::sign_message::(&original); +// let sig: BoundedVec> = sig.0.to_vec().try_into().map_err(|_| "bounded convert error")?; +// let replace_space = pallet_sminer::benchmarking::get_replace_space::(positive_miner[0].clone()).unwrap(); +// assert_eq!(replace_space, FRAGMENT_SIZE * v as u128); +// }: _(RawOrigin::Signed(positive_miner[0].clone()), space_proof_info, sig.clone(), sig, tee_puk) +// verify { +// let replace_space = pallet_sminer::benchmarking::get_replace_space::(positive_miner[0].clone()).unwrap(); +// assert_eq!(replace_space, FRAGMENT_SIZE * v as u128 - IDLE_SEG_SIZE); +// } + +// delete_file { +// log::info!("start delete_file"); +// pallet_tee_worker::benchmarking::generate_workers::(); +// let user: AccountOf = account("user1", 100, SEED); +// let mut positive_miner: Vec> = Default::default(); +// for i in 0 .. 12 { +// let miner: AccountOf = account(miner_list[i as usize], 100, SEED); +// positive_miner.push(miner.clone()); +// let _ = pallet_sminer::benchmarking::register_positive_miner::(miner.clone())?; +// let _ = cert_idle_for_miner::(miner)?; +// } + +// let _ = buy_space::(user.clone())?; - let file_name = "test-file".as_bytes().to_vec(); - let bucket_name = "test-bucket1".as_bytes().to_vec(); - let file_hash: Hash = Hash([80u8; 64]); - let file_size: u128 = SEGMENT_SIZE * 3; - let territory_name: TerrName = "t1".as_bytes().to_vec().try_into().map_err(|_| "boundedvec error")?; - let user_brief = UserBrief:: { - user: user.clone(), - file_name: file_name.try_into().map_err(|_e| "file name convert err")?, - bucket_name: bucket_name.try_into().map_err(|_e| "bucket name convert err")?, - territory_name, - }; - - let mut deal_info: BoundedVec, T::SegmentCount> = Default::default(); - let segment_list = SegmentList:: { - hash: Hash([65u8; 64]), - fragment_list: [ - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - Hash([97u8; 64]), - ].to_vec().try_into().unwrap(), - }; - deal_info.try_push(segment_list).unwrap(); - FileBank::::upload_declaration(RawOrigin::Signed(user.clone()).into(), file_hash.clone(), deal_info, user_brief, file_size)?; - - for i in 0 .. 12 { - FileBank::::transfer_report(RawOrigin::Signed(positive_miner[i as usize].clone()).into(), i + 1, file_hash.clone())?; - } - }: _(RawOrigin::Signed(user.clone()), user.clone(), file_hash.clone()) - verify { - assert!(!>::contains_key(&file_hash)); - } +// let file_name = "test-file".as_bytes().to_vec(); +// let file_hash: Hash = Hash([80u8; 64]); +// let file_size: u128 = SEGMENT_SIZE * 3; +// let territory_name: TerrName = "t1".as_bytes().to_vec().try_into().map_err(|_| "boundedvec error")?; +// let user_brief = UserBrief:: { +// user: user.clone(), +// file_name: file_name.try_into().map_err(|_e| "file name convert err")?, +// territory_name, +// }; - create_bucket { - log::info!("start create_bucket"); - let caller: AccountOf = account("user1", 100, SEED); - let name: Vec = "test-bucket1".as_bytes().to_vec(); - let name: BoundedVec = name.try_into().map_err(|_| "name convert error")?; - }: _(RawOrigin::Signed(caller.clone()), caller.clone(), name.clone()) - verify { - assert!(Bucket::::contains_key(&caller, name)); - } +// let mut deal_info: BoundedVec, T::SegmentCount> = Default::default(); +// let segment_list = SegmentList:: { +// hash: Hash([65u8; 64]), +// fragment_list: [ +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// Hash([97u8; 64]), +// ].to_vec().try_into().unwrap(), +// }; +// deal_info.try_push(segment_list).unwrap(); +// FileBank::::upload_declaration(RawOrigin::Signed(user.clone()).into(), file_hash.clone(), deal_info, user_brief, file_size)?; + +// for i in 0 .. 12 { +// FileBank::::transfer_report(RawOrigin::Signed(positive_miner[i as usize].clone()).into(), i + 1, file_hash.clone())?; +// } +// }: _(RawOrigin::Signed(user.clone()), user.clone(), file_hash.clone()) +// verify { +// assert!(!>::contains_key(&file_hash)); +// } - delete_bucket { - log::info!("start delete_bucket"); - let caller: AccountOf = account("user1", 100, SEED); - let name: Vec = "test-bucket1".as_bytes().to_vec(); - let name_bound: BoundedVec = name.clone().try_into().map_err(|_| "bounded_vec convert err!")?; - FileBank::::create_bucket(RawOrigin::Signed(caller.clone()).into(), caller.clone(), name_bound.clone())?; - Bucket::::contains_key(&caller, name_bound.clone()); - }: _(RawOrigin::Signed(caller.clone()), caller.clone(), name_bound.clone()) - verify { - assert!(!Bucket::::contains_key(&caller, name_bound)); - } +// generate_restoral_order { +// log::info!("start generate_restoral_order"); +// initialize_file_from_scratch::()?; +// let miner = account(miner_list[0], 100, SEED); +// }: _(RawOrigin::Signed(miner), Hash([80u8; 64]), Hash([97u8; 64])) +// verify { +// assert!(>::contains_key(&Hash([97u8; 64]))); +// } - generate_restoral_order { - log::info!("start generate_restoral_order"); - initialize_file_from_scratch::()?; - let miner = account(miner_list[0], 100, SEED); - }: _(RawOrigin::Signed(miner), Hash([80u8; 64]), Hash([97u8; 64])) - verify { - assert!(>::contains_key(&Hash([97u8; 64]))); - } +// claim_restoral_order { +// log::info!("start claim_restoral_order"); +// initialize_file_from_scratch::()?; +// let miner: AccountOf = account(miner_list[0], 100, SEED); +// FileBank::::generate_restoral_order(RawOrigin::Signed(miner.clone()).into(), Hash([80u8; 64]), Hash([97u8; 64]))?; +// assert!(>::contains_key(&Hash([97u8; 64]))); +// let miner2: AccountOf = account(miner_list[12], 100, SEED); +// let _ = pallet_sminer::benchmarking::register_positive_miner::(miner2.clone())?; +// let _ = cert_idle_for_miner::(miner2.clone())?; +// }: _(RawOrigin::Signed(miner2.clone()), Hash([97u8; 64])) +// verify { +// let info = >::try_get(&Hash([97u8; 64])).unwrap(); +// assert_eq!(info.miner, miner2); +// } - claim_restoral_order { - log::info!("start claim_restoral_order"); - initialize_file_from_scratch::()?; - let miner: AccountOf = account(miner_list[0], 100, SEED); - FileBank::::generate_restoral_order(RawOrigin::Signed(miner.clone()).into(), Hash([80u8; 64]), Hash([97u8; 64]))?; - assert!(>::contains_key(&Hash([97u8; 64]))); - let miner2: AccountOf = account(miner_list[12], 100, SEED); - let _ = pallet_sminer::benchmarking::register_positive_miner::(miner2.clone())?; - let _ = cert_idle_for_miner::(miner2.clone())?; - }: _(RawOrigin::Signed(miner2.clone()), Hash([97u8; 64])) - verify { - let info = >::try_get(&Hash([97u8; 64])).unwrap(); - assert_eq!(info.miner, miner2); - } +// claim_restoral_noexist_order { +// log::info!("start claim_restoral_noexist_order"); +// initialize_file_from_scratch::()?; +// let miner: AccountOf = account(miner_list[0], 100, SEED); - claim_restoral_noexist_order { - log::info!("start claim_restoral_noexist_order"); - initialize_file_from_scratch::()?; - let miner: AccountOf = account(miner_list[0], 100, SEED); - - let tee_puk = pallet_tee_worker::benchmarking::get_pubkey::(); - let mut digest_list: BoundedVec> = Default::default(); - let digest_info = DigestInfo { - fragment: Hash([97u8; 64]), - tee_puk : tee_puk, - }; - digest_list.try_push(digest_info).unwrap(); - let tag_sig_info = TagSigInfo::> { - miner: miner.clone(), - digest: digest_list, - file_hash: Hash([80u8; 64]), - }; - let idle_sig_info_encode = tag_sig_info.encode(); - let original = sp_io::hashing::sha2_256(&idle_sig_info_encode); - let sig = pallet_tee_worker::benchmarking::sign_message::(&original); - let sig: BoundedVec> = sig.0.to_vec().try_into().map_err(|_| "bounded convert error")?; - FileBank::::calculate_report(RawOrigin::Signed(miner.clone()).into(), sig, tag_sig_info)?; - - frame_system::Pallet::::set_block_number(28805001u32.into()); - Sminer::::miner_exit_prep(RawOrigin::Signed(miner.clone()).into(), miner.clone())?; - Sminer::::miner_exit(RawOrigin::Root.into(), miner.clone())?; - - let miner2: AccountOf = account(miner_list[12], 100, SEED); - let _ = pallet_sminer::benchmarking::register_positive_miner::(miner2.clone())?; - let _ = cert_idle_for_miner::(miner2.clone())?; - }: _(RawOrigin::Signed(miner2.clone()), miner.clone(), Hash([80u8; 64]), Hash([97u8; 64])) - verify { - assert!(>::contains_key(&Hash([97u8; 64]))); - } +// let tee_puk = pallet_tee_worker::benchmarking::get_pubkey::(); +// let mut digest_list: BoundedVec> = Default::default(); +// let digest_info = DigestInfo { +// fragment: Hash([97u8; 64]), +// tee_puk : tee_puk, +// }; +// digest_list.try_push(digest_info).unwrap(); +// let tag_sig_info = TagSigInfo::> { +// miner: miner.clone(), +// digest: digest_list, +// file_hash: Hash([80u8; 64]), +// }; +// let idle_sig_info_encode = tag_sig_info.encode(); +// let original = sp_io::hashing::sha2_256(&idle_sig_info_encode); +// let sig = pallet_tee_worker::benchmarking::sign_message::(&original); +// let sig: BoundedVec> = sig.0.to_vec().try_into().map_err(|_| "bounded convert error")?; +// FileBank::::calculate_report(RawOrigin::Signed(miner.clone()).into(), sig, tag_sig_info)?; + +// frame_system::Pallet::::set_block_number(28805001u32.into()); +// Sminer::::miner_exit_prep(RawOrigin::Signed(miner.clone()).into(), miner.clone())?; +// Sminer::::miner_exit(RawOrigin::Root.into(), miner.clone())?; + +// let miner2: AccountOf = account(miner_list[12], 100, SEED); +// let _ = pallet_sminer::benchmarking::register_positive_miner::(miner2.clone())?; +// let _ = cert_idle_for_miner::(miner2.clone())?; +// }: _(RawOrigin::Signed(miner2.clone()), miner.clone(), Hash([80u8; 64]), Hash([97u8; 64])) +// verify { +// assert!(>::contains_key(&Hash([97u8; 64]))); +// } - restoral_order_complete { - log::info!("start restoral_order_complete"); - initialize_file_from_scratch::()?; - let miner: AccountOf = account(miner_list[0], 100, SEED); - FileBank::::generate_restoral_order(RawOrigin::Signed(miner.clone()).into(), Hash([80u8; 64]), Hash([97u8; 64]))?; - assert!(>::contains_key(&Hash([97u8; 64]))); - let miner2: AccountOf = account(miner_list[12], 100, SEED); - let _ = pallet_sminer::benchmarking::register_positive_miner::(miner2.clone())?; - let _ = cert_idle_for_miner::(miner2.clone())?; - frame_system::Pallet::::set_block_number(100u32.into()); - FileBank::::claim_restoral_order(RawOrigin::Signed(miner2.clone()).into(), Hash([97u8; 64]))?; - assert!(>::contains_key(&Hash([97u8; 64]))); - }: _(RawOrigin::Signed(miner2.clone()), Hash([97u8; 64])) - verify { - assert!(!>::contains_key(&Hash([97u8; 64]))); - let (_, space) = T::MinerControl::get_power(&miner2)?; - assert_eq!(space, FRAGMENT_SIZE); - } -} \ No newline at end of file +// restoral_order_complete { +// log::info!("start restoral_order_complete"); +// initialize_file_from_scratch::()?; +// let miner: AccountOf = account(miner_list[0], 100, SEED); +// FileBank::::generate_restoral_order(RawOrigin::Signed(miner.clone()).into(), Hash([80u8; 64]), Hash([97u8; 64]))?; +// assert!(>::contains_key(&Hash([97u8; 64]))); +// let miner2: AccountOf = account(miner_list[12], 100, SEED); +// let _ = pallet_sminer::benchmarking::register_positive_miner::(miner2.clone())?; +// let _ = cert_idle_for_miner::(miner2.clone())?; +// frame_system::Pallet::::set_block_number(100u32.into()); +// FileBank::::claim_restoral_order(RawOrigin::Signed(miner2.clone()).into(), Hash([97u8; 64]))?; +// assert!(>::contains_key(&Hash([97u8; 64]))); +// }: _(RawOrigin::Signed(miner2.clone()), Hash([97u8; 64])) +// verify { +// assert!(!>::contains_key(&Hash([97u8; 64]))); +// let (_, space) = T::MinerControl::get_power(&miner2)?; +// assert_eq!(space, FRAGMENT_SIZE); +// } +// } \ No newline at end of file diff --git a/pallets/file-bank/src/functions.rs b/pallets/file-bank/src/functions.rs index bdabb9f2..4e4e2797 100644 --- a/pallets/file-bank/src/functions.rs +++ b/pallets/file-bank/src/functions.rs @@ -59,48 +59,6 @@ impl Pallet { Ok(()) } - pub fn create_bucket_helper( - user: &AccountOf, - bucket_name: &BoundedVec, - file_hash: Option, - ) -> DispatchResult { - // TODO! len() & ? - ensure!(bucket_name.len() >= 3, Error::::LessMinLength); - ensure!(!>::contains_key(user, bucket_name), Error::::Existed); - ensure!(Self::check_bucket_name_spec((*bucket_name).to_vec()), Error::::SpecError); - - let mut bucket = BucketInfo:: { - object_list: Default::default(), - authority: vec![user.clone()].try_into().map_err(|_e| Error::::BoundedVecError)?, - }; - - if let Some(hash) = file_hash { - bucket.object_list.try_push(hash).map_err(|_e| Error::::BoundedVecError)?; - } - - >::insert(user, bucket_name.clone(), bucket); - - >::try_mutate(&user, |bucket_list| -> DispatchResult{ - bucket_list.try_push(bucket_name.clone()).map_err(|_e| Error::::LengthExceedsLimit)?; - Ok(()) - })?; - - Ok(()) - } - - pub fn add_file_to_bucket( - user: &AccountOf, - bucket_name: &BoundedVec, - file_hash: &Hash, - ) -> DispatchResult { - >::try_mutate(user, bucket_name, |bucket_opt| -> DispatchResult { - let bucket = bucket_opt.as_mut().ok_or(Error::::NonExistent)?; - bucket.object_list.try_push(*file_hash).map_err(|_e| Error::::BoundedVecError)?; - - Ok(()) - }) - } - pub(super) fn generate_deal( file_hash: Hash, file_info: BoundedVec, T::SegmentCount>, @@ -157,24 +115,6 @@ impl Pallet { Ok(weight) } - pub(super) fn bucket_remove_file( - file_hash: &Hash, - acc: &AccountOf, - file: &FileInfo - ) -> DispatchResult { - for user_brief in file.owner.iter() { - if &user_brief.user == acc { - >::try_mutate(acc, &user_brief.bucket_name, |bucket_opt| -> DispatchResult { - let bucket = bucket_opt.as_mut().ok_or(Error::::NonExistent)?; - bucket.object_list.retain(|file| file != file_hash); - Ok(()) - })? - } - } - - Ok(()) - } - pub(super) fn remove_user_hold_file_list( file_hash: &Hash, acc: &AccountOf, @@ -392,7 +332,7 @@ impl Pallet { false } - pub(super) fn check_bucket_name_spec(name: Vec) -> bool { + pub(super) fn check_name_spec(name: Vec) -> bool { let mut point_flag: bool = false; let mut count = 0; for elem in &name { diff --git a/pallets/file-bank/src/impls/receptionist.rs b/pallets/file-bank/src/impls/receptionist.rs index 89289fa9..7dcd7846 100644 --- a/pallets/file-bank/src/impls/receptionist.rs +++ b/pallets/file-bank/src/impls/receptionist.rs @@ -13,12 +13,6 @@ impl Receptionist { ensure!(T::StorageHandle::get_user_avail_space(&user_brief.user, &user_brief.territory_name)? > needed_space, Error::::InsufficientAvailableSpace); T::StorageHandle::add_territory_used_space(&user_brief.user, &user_brief.territory_name, needed_space)?; - if >::contains_key(&user_brief.user, &user_brief.bucket_name) { - Pallet::::add_file_to_bucket(&user_brief.user, &user_brief.bucket_name, &file_hash)?; - } else { - Pallet::::create_bucket_helper(&user_brief.user, &user_brief.bucket_name, Some(file_hash))?; - } - Pallet::::add_user_hold_fileslice(&user_brief.user, file_hash, needed_space, user_brief.territory_name.clone())?; file.owner.try_push(user_brief.clone()).map_err(|_e| Error::::BoundedVecError)?; @@ -63,11 +57,6 @@ impl Receptionist { T::StorageHandle::sub_total_idle_space(needed_space)?; T::StorageHandle::add_total_service_space(needed_space)?; - if >::contains_key(&deal_info.user.user, &deal_info.user.bucket_name) { - Pallet::::add_file_to_bucket(&deal_info.user.user, &deal_info.user.bucket_name, &deal_hash)?; - } else { - Pallet::::create_bucket_helper(&deal_info.user.user, &deal_info.user.bucket_name, Some(deal_hash))?; - } Pallet::::add_user_hold_fileslice(&deal_info.user.user, deal_hash.clone(), needed_space, deal_info.user.territory_name.clone())?; >::remove(deal_hash); Pallet::::deposit_event(Event::::StorageCompleted{ file_hash: deal_hash }); diff --git a/pallets/file-bank/src/lib.rs b/pallets/file-bank/src/lib.rs index f3499c05..46bd48cc 100755 --- a/pallets/file-bank/src/lib.rs +++ b/pallets/file-bank/src/lib.rs @@ -34,7 +34,7 @@ pub use pallet::*; #[cfg(feature = "runtime-benchmarks")] pub mod benchmarking; pub mod weights; -// pub mod migrations; +pub mod migration; mod types; pub use types::*; @@ -54,7 +54,7 @@ use frame_support::{ PalletId, dispatch::DispatchResult, pallet_prelude::*, - weights::Weight, + weights::{Weight, WeightMeter}, }; use frame_system::pallet_prelude::*; use scale_info::TypeInfo; @@ -83,7 +83,7 @@ pub use weights::WeightInfo; type AccountOf = ::AccountId; -const STORAGE_VERSION: StorageVersion = StorageVersion::new(2); +const STORAGE_VERSION: StorageVersion = StorageVersion::new(3); #[frame_support::pallet] pub mod pallet { @@ -129,8 +129,6 @@ pub mod pallet { #[pallet::constant] type NameStrLimit: Get + Clone + Eq + PartialEq; // Maximum number of containers that users can create. - #[pallet::constant] - type BucketLimit: Get + Clone + Eq + PartialEq; // Minimum length of bucket name. #[pallet::constant] type NameMinLength: Get + Clone + Eq + PartialEq; @@ -170,10 +168,6 @@ pub mod pallet { IdleSpaceCert { acc: AccountOf, space: u128 }, ReplaceIdleSpace { acc: AccountOf, space: u128 }, - //Event to successfully create a bucket - CreateBucket { operator: AccountOf, owner: AccountOf, bucket_name: Vec}, - //Successfully delete the bucket event - DeleteBucket { operator: AccountOf, owner: AccountOf, bucket_name: Vec}, GenerateRestoralOrder { miner: AccountOf, fragment_hash: Hash }, @@ -219,8 +213,6 @@ pub mod pallet { ConvertHashError, /// No operation permission. Perhaps it was not authorized NoPermission, - /// User had same name bucket - SameBucketName, /// Bucket, file, and scheduling errors do not exist NonExistent, /// Logically speaking, errors that should not occur @@ -278,29 +270,6 @@ pub mod pallet { BoundedVec, ValueQuery, >; - - #[pallet::storage] - #[pallet::getter(fn bucket)] - pub(super) type Bucket = - StorageDoubleMap< - _, - Blake2_128Concat, - AccountOf, - Blake2_128Concat, - BoundedVec, - BucketInfo, - >; - - #[pallet::storage] - #[pallet::getter(fn user_bucket_list)] - pub(super) type UserBucketList = - StorageMap< - _, - Blake2_128Concat, - AccountOf, - BoundedVec, T::BucketLimit>, - ValueQuery, - >; #[pallet::storage] #[pallet::getter(fn restoral_order)] @@ -365,16 +334,10 @@ pub mod pallet { weight = weight.saturating_add(temp_weight); } } - - if let Err(e) = Self::bucket_remove_file(&file_info.file_hash, &acc, &file) { - log::error!("[FileBank]: space lease, delete file from bucket report a bug! {:?}", e); - } } else { log::error!("space lease, delete file bug!"); log::error!("acc: {:?}, file_hash: {:?}", &acc, &file_info.file_hash); } - - } ClearUserList::::mutate(|target_list| { @@ -419,7 +382,6 @@ pub mod pallet { let minimum = T::NameMinLength::get(); ensure!(user_brief.file_name.len() as u32 >= minimum, Error::::SpecError); - ensure!(user_brief.bucket_name.len() as u32 >= minimum, Error::::SpecError); if >::contains_key(&file_hash) { Receptionist::::fly_upload_file(file_hash, user_brief.clone())?; @@ -775,7 +737,6 @@ pub mod pallet { let file = >::try_get(&file_hash).map_err(|_| Error::::NonExistent)?; let _ = Self::delete_user_file(&file_hash, &owner, &file)?; - Self::bucket_remove_file(&file_hash, &owner, &file)?; Self::remove_user_hold_file_list(&file_hash, &owner)?; Self::deposit_event(Event::::DeleteFile{ operator: sender, owner, file_hash }); @@ -848,80 +809,6 @@ pub mod pallet { Ok(()) } - /// Create a Data Storage Bucket - /// - /// This function allows a user with appropriate permissions to create a new data storage bucket. - /// - /// Parameters: - /// - `origin`: The origin of the transaction. - /// - `owner`: The account identifier of the bucket owner. - /// - `name`: The name of the new bucket. - #[pallet::call_index(11)] - #[transactional] - #[pallet::weight(::WeightInfo::create_bucket())] - pub fn create_bucket( - origin: OriginFor, - owner: AccountOf, - name: BoundedVec, - ) -> DispatchResult { - let sender = ensure_signed(origin)?; - ensure!(Self::check_permission(sender.clone(), owner.clone()), Error::::NoPermission); - - Self::create_bucket_helper(&owner, &name, None)?; - - Self::deposit_event(Event::::CreateBucket { - operator: sender, - owner, - bucket_name: name.to_vec(), - }); - - Ok(()) - } - - /// Delete a Bucket - /// - /// This function allows a user to delete an empty storage bucket that they own. - /// Deleting a bucket is only possible if it contains no files. - /// - /// Parameters: - /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. - /// - `owner`: The owner's account for whom the bucket should be deleted. - /// - `name`: The name of the bucket to be deleted. - #[pallet::call_index(12)] - #[transactional] - #[pallet::weight(::WeightInfo::delete_bucket())] - pub fn delete_bucket( - origin: OriginFor, - owner: AccountOf, - name: BoundedVec, - ) -> DispatchResult { - let sender = ensure_signed(origin)?; - ensure!(Self::check_permission(sender.clone(), owner.clone()), Error::::NoPermission); - ensure!(>::contains_key(&owner, &name), Error::::NonExistent); - let bucket = >::try_get(&owner, &name).map_err(|_| Error::::Unexpected)?; - ensure!(bucket.object_list.len() == 0, Error::::NotEmpty); - - >::remove(&owner, &name); - >::try_mutate(&owner, |bucket_list| -> DispatchResult { - let mut index = 0; - for name_tmp in bucket_list.iter() { - if *name_tmp == name { - break; - } - index = index.checked_add(&1).ok_or(Error::::Overflow)?; - } - bucket_list.remove(index); - Ok(()) - })?; - - Self::deposit_event(Event::::DeleteBucket { - operator: sender, - owner, - bucket_name: name.to_vec(), - }); - Ok(()) - } - /// Generate a Restoration Order /// /// This function allows a user to generate a restoration order for a specific fragment of a file. @@ -1178,7 +1065,6 @@ pub mod pallet { let file = >::try_get(&file_hash).map_err(|_| Error::::NonExistent)?; let _ = Self::delete_user_file(&file_hash, &owner, &file)?; - Self::bucket_remove_file(&file_hash, &owner, &file)?; Self::remove_user_hold_file_list(&file_hash, &owner)?; Ok(()) diff --git a/pallets/file-bank/src/migration.rs b/pallets/file-bank/src/migration.rs new file mode 100644 index 00000000..83ccf198 --- /dev/null +++ b/pallets/file-bank/src/migration.rs @@ -0,0 +1,212 @@ +use super::*; +use sp_std::collections::btree_map::BTreeMap; +use sp_runtime::{TryRuntimeError}; +use frame_support::{ + storage_alias, weights::WeightMeter, + migrations::{MigrationId, SteppedMigration, SteppedMigrationError}, +}; + +#[cfg(feature = "try-runtime")] +use sp_runtime::Vec; + +pub const PALLET_MIGRATIONS_ID: &[u8; 26] = b"pallet-file-bank-migration"; + +pub struct SteppedFileBank(PhantomData<(T, W)>); +impl SteppedMigration for SteppedFileBank { + type Cursor = (Option, Option); + + type Identifier = MigrationId<26>; + + fn id() -> Self::Identifier { + MigrationId { pallet_id: *PALLET_MIGRATIONS_ID, version_from: 2, version_to: 3 } + } + + fn step( + mut cursor: Option, + meter: &mut WeightMeter + ) -> Result, SteppedMigrationError> { + let required = W::migration_step(); + + if meter.remaining().any_lt(required) { + return Err(SteppedMigrationError::InsufficientWeight { required }); + } + + loop { + if meter.try_consume(required).is_err() { + break; + } + + let (file_key_opt, deal_key_opt) = if let Some((file_key_opt, deal_key_opt)) = cursor { + ( + v3::file_step_migration::(true, file_key_opt), + v3::dealmap_step_migration::(true, deal_key_opt), + ) + } else { + ( + v3::file_step_migration::(false, None), + v3::dealmap_step_migration::(false, None), + ) + }; + + if file_key_opt.is_none() && deal_key_opt.is_none() { + cursor = None; + break + } else { + cursor = Some((file_key_opt, deal_key_opt)); + } + } + + Ok(cursor) + } + + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, TryRuntimeError> { + use codec::Encode; + + let file_records: BTreeMap<_, _> = v3::File::::iter() + .take(10) + .collect(); + let deal_records: BTreeMap<_, _> = v3::DealMap::::iter() + .take(10) + .collect(); + + let res = (file_records.encode(), deal_records.encode()); + Ok(res.encode()) + } + #[cfg(feature = "try-runtime")] + fn post_upgrade(prev_state: Vec) -> Result<(), TryRuntimeError> { + let res = <(Vec, Vec)>::decode(&mut &prev_state[..]) + .expect("Failed to decode the previous storage state"); + + let (file_state, deal_state) = ( + >>::decode(&mut &res.0[..]) + .expect("Failed to decode the previous file state"), + >>::decode(&mut &res.1[..]) + .expect("Failed to decode the previous deal state"), + ); + + for (key, value) in file_state { + let file = File::::get(key) + .expect("Migrated file should exist"); + assert!(file.file_size == value.file_size, "File size mismatch"); + } + + for (key, value) in deal_state { + let deal = DealMap::::get(key) + .expect("Migrated deal should exist"); + assert!(deal.file_size == value.file_size, "Deal size mismatch"); + } + + log::info!( + "file-bank check access success: verified first 10 records of File and DealMap" + ); + Ok(()) + } +} + +pub mod v3 { + use super::{*, DealMap as NewDealMap, File as NewFile}; + + #[storage_alias] + pub type File = StorageMap, Blake2_128Concat, Hash, OldFileInfo>; + + #[storage_alias] + pub type DealMap = StorageMap, Blake2_128Concat, Hash, OldDealInfo>; + + #[derive(Clone, Encode, Decode, RuntimeDebug, TypeInfo)] + pub struct OldUserBrief { + pub user: AccountOf, + pub file_name: BoundedVec, + pub bucket_name: BoundedVec, + pub territory_name: TerrName, + } + + #[derive(Clone, Encode, Decode, RuntimeDebug, TypeInfo)] + pub struct OldFileInfo { + pub segment_list: BoundedVec, T::SegmentCount>, + pub owner: BoundedVec, T::OwnerLimit>, + pub file_size: u128, + pub completion: BlockNumberFor, + pub stat: FileState, + } + + #[derive(Clone, Encode, Decode, RuntimeDebug, TypeInfo)] + pub struct OldDealInfo { + pub file_size: u128, + pub segment_list: BoundedVec, T::SegmentCount>, + pub user: OldUserBrief, + pub complete_list: BoundedVec, T::FragmentCount>, + } + + pub fn dealmap_step_migration(done_flag: bool, mut cursor: Option) -> Option { + let mut iter = if let Some(last_key) = cursor { + v3::DealMap::::iter_from(v3::DealMap::::hashed_key_for(last_key)) + } else { + if done_flag { + return None; + } + v3::DealMap::::iter() + }; + + if let Some((last_key, value)) = iter.next() { + let user_brief = UserBrief::{ + user: value.user.user, + file_name: value.user.file_name, + territory_name: value.user.territory_name, + }; + + let new_info = DealInfo::{ + file_size: value.file_size, + segment_list: value.segment_list, + user: user_brief, + complete_list: value.complete_list, + }; + + NewDealMap::::insert(last_key, new_info); + + cursor = Some(last_key); + } else { + cursor = None; + } + + cursor + } + + pub fn file_step_migration(done_flag: bool, mut cursor: Option) -> Option { + let mut iter = if let Some(last_key) = cursor { + v3::File::::iter_from(v3::File::::hashed_key_for(last_key)) + } else { + if done_flag { + return None; + } + v3::File::::iter() + }; + + if let Some((last_key, value)) = iter.next() { + let mut new_owner: BoundedVec, T::OwnerLimit> = Default::default(); + for owner in value.owner { + new_owner.try_push(UserBrief::{ + user: owner.user, + file_name: owner.file_name, + territory_name: owner.territory_name, + }).unwrap(); + } + + let file = FileInfo::{ + segment_list: value.segment_list, + owner: new_owner, + file_size: value.file_size, + completion: value.completion, + stat: value.stat, + }; + + NewFile::::insert(last_key, file); + + cursor = Some(last_key); + } else { + cursor = None; + } + + cursor + } +} \ No newline at end of file diff --git a/pallets/file-bank/src/migrations.rs b/pallets/file-bank/src/migrations.rs deleted file mode 100644 index 44359e08..00000000 --- a/pallets/file-bank/src/migrations.rs +++ /dev/null @@ -1,227 +0,0 @@ -use crate::{AccountOf, Config, Pallet, Weight, BoundedString}; -use codec::{Decode, Encode}; -use frame_support::{ - codec, generate_storage_alias, - pallet_prelude::*, - traits::{Get}, -}; -use frame_support::traits::OnRuntimeUpgrade; - -/// A struct that does not migration, but only checks that the counter prefix exists and is correct. -pub struct TestMigrationFileBank(sp_std::marker::PhantomData); -impl OnRuntimeUpgrade for TestMigrationFileBank { - fn on_runtime_upgrade() -> Weight { - migrate::() - } - - #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result<(), &'static str> { - log::info!("๐Ÿ™‹๐Ÿฝโ€file-bank check access"); - return Ok(()) - } - - #[cfg(feature = "try-runtime")] - fn post_upgrade() -> Result<(), &'static str> { - let weights = migrate::(); - return Ok(()) - } -} - -pub fn migrate() -> Weight { - use frame_support::traits::StorageVersion; - - let version = StorageVersion::get::>(); - let mut weight: Weight = 0; - - if version < 2 { - weight = weight.saturating_add(v2::migrate::()); - StorageVersion::new(2).put::>(); - } - - weight -} - -mod example { - use super::*; - - #[derive(Decode, Encode)] - struct OldFillerInfo { - filler_size: u64, - index: u32, - block_num: u32, - segment_size: u32, - scan_size: u32, - miner_address: AccountOf, - filler_id: BoundedVec, - filler_hash: BoundedVec, - } - - #[derive(Decode, Encode)] - struct NewFillerInfo { - filler_size: u64, - index: u32, - block_num: u32, - segment_size: u32, - miner_address: AccountOf, - filler_id: BoundedVec, - filler_hash: BoundedVec, - is_delete: bool, - } - - generate_storage_alias!( - FileBank, - FillerMap => DoubleMap< - (Blake2_128Concat, T::AccountId), - (Blake2_128Concat, BoundedString), - NewFillerInfo - > - ); - - pub fn migrate() -> Weight { - let mut weight: Weight = 0; - - >::translate(|_key1, _key2, old: OldFillerInfo| { - weight = weight.saturating_add(T::DbWeight::get().reads_writes(1, 1)); - Some(NewFillerInfo::{ - filler_size: old.filler_size, - index: old.index, - block_num: old.block_num, - segment_size: old.segment_size, - miner_address: old.miner_address, - filler_id: old.filler_id, - filler_hash: old.filler_hash, - is_delete: false, - }) - }); - - weight - } -} - -mod v2 { - use super::*; - use cp_cess_common::Hash; - use crate::{FillerInfo, FillerMap as NewFillerMap}; - - #[derive(Decode, Encode)] - struct OldFillerInfo { - filler_size: u64, - index: u32, - block_num: u32, - segment_size: u32, - scan_size: u32, - miner_address: AccountOf, - filler_id: BoundedVec, - filler_hash: BoundedVec, - } - - #[derive(Decode, Encode)] - struct NewFillerInfo { - filler_size: u64, - index: u32, - block_num: u32, - segment_size: u32, - scan_size: u32, - miner_address: AccountOf, - filler_hash: Hash, - } - - generate_storage_alias!( - FileBank, - FillerMap => DoubleMap< - (Blake2_128Concat, AccountOf), - (Blake2_128Concat, BoundedVec), - OldFillerInfo - > - ); - - // generate_storage_alias!( - // FileBank, - // FillerMap => DoubleMap< - // (Blake2_128Concat, T::AccountId), - // (Blake2_128Concat, Hash), - // NewFillerInfo - // > - // ); - - // #[derive(Decode, Encode)] - // struct OldSliceInfo { - // miner_id: u64, - // shard_size: u64, - // block_num: u32, - // shard_id: BoundedVec, - // miner_ip: BoundedVec, - // miner_acc: AccountOf, - // } - // - // #[derive(Decode, Encode)] - // struct NewSliceInfo { - // miner_id: u64, - // shard_size: u64, - // block_num: u32, - // shard_id: [u8; 72], - // miner_ip: BoundedVec, - // miner_acc: AccountOf, - // } - // - // generate_storage_alias!( - // FileBank, - // File - // ); - // - // struct OldPackageDetails { - // pub(super) space: u128, - // pub(super) used_space: u128, - // pub(super) remaining_space: u128, - // pub(super) tenancy: u32, - // pub(super) package_type: u8, - // pub(super) start: BlockNumberOf, - // pub(super) deadline: BlockNumberOf, - // pub(super) state: BoundedVec, - // } - // - // struct NewPackageDetails { - // pub(super) space: u128, - // pub(super) used_space: u128, - // pub(super) remaining_space: u128, - // pub(super) tenancy: u32, - // pub(super) package_type: PackageType, - // pub(super) start: BlockNumberOf, - // pub(super) deadline: BlockNumberOf, - // pub(super) state: BoundedVec, - // } - - pub fn migrate() -> Weight { - let mut weight: Weight = 0; - log::info!("-----------------------------test migrations start-----------------------------------"); - for (miner_acc, filler_id, old) in >::iter() { - log::info!("-----------------------------migrations value filler_id:{:?}, len: {}", filler_id.clone(), filler_id.as_slice().len()); - log::info!("old value filler_size: {}, index: {}, block_num: {}", old.filler_size, old.index, old.block_num); - weight = weight.saturating_add(T::DbWeight::get().reads_writes(1, 1)); - let filler_hash = Hash::slice_to_array_64(&filler_id).expect("error!"); - // { - // Ok(slice) => slice, - // Err(e) => { - // log::info!("convert err: {:?}", e); - // continue; - // }, - // }; - log::info!("convert success!"); - let filler_hash = Hash(filler_hash); - let new_value = FillerInfo::{ - filler_size: old.filler_size, - index: old.index, - block_num: old.block_num, - segment_size: old.segment_size, - scan_size: old.scan_size, - miner_address: old.miner_address.clone(), - filler_hash: filler_hash.clone(), - }; - log::info!("start insert"); - >::insert(miner_acc, filler_hash, new_value); - log::info!("end insert"); - } - log::info!("migrations end!"); - weight - } -} diff --git a/pallets/file-bank/src/types.rs b/pallets/file-bank/src/types.rs index 08c5a289..edc72179 100755 --- a/pallets/file-bank/src/types.rs +++ b/pallets/file-bank/src/types.rs @@ -88,21 +88,12 @@ pub struct UserFileSliceInfo { pub(super) file_size: u128, } -#[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, MaxEncodedLen, TypeInfo)] -#[scale_info(skip_type_params(T))] -#[codec(mel_bound())] -pub struct BucketInfo { - pub(super) object_list: BoundedVec, - pub(super) authority: BoundedVec, ConstU32<1032>>, -} - #[derive(PartialEq, Eq, Clone, Encode, Decode, RuntimeDebug, MaxEncodedLen, TypeInfo)] #[scale_info(skip_type_params(T))] #[codec(mel_bound())] pub struct UserBrief { pub user: AccountOf, pub file_name: BoundedVec, - pub bucket_name: BoundedVec, pub territory_name: TerrName, } @@ -138,5 +129,4 @@ pub struct TagSigInfo { pub struct DigestInfo { pub(super) fragment: Hash, pub(super) tee_puk: WorkerPublicKey, -} - +} \ No newline at end of file diff --git a/pallets/file-bank/src/weights.rs b/pallets/file-bank/src/weights.rs index ed201e7b..1f3626d7 100644 --- a/pallets/file-bank/src/weights.rs +++ b/pallets/file-bank/src/weights.rs @@ -48,6 +48,7 @@ pub trait WeightInfo { fn claim_restoral_order() -> Weight; fn claim_restoral_noexist_order() -> Weight; fn restoral_order_complete() -> Weight; + fn migration_step() -> Weight; } /// Weights for `pallet_file_bank` using the Substrate node and recommended hardware. @@ -278,6 +279,20 @@ impl WeightInfo for SubstrateWeight { .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(5_u64)) } + + /// Storage: `FileBank::File` (r:2 w:1) + /// Proof: `FileBank::File` (`max_values`: None, `max_size`: Some(9289107), added: 9291582, mode: `MaxEncodedLen`) + /// Storage: `FileBank::DealMap` (r:2 w:1) + /// Proof: `FileBank::DealMap` (`max_values`: None, `max_size`: Some(833655), added: 836130, mode: `MaxEncodedLen`) + fn migration_step() -> Weight { + // Proof Size summary in bytes: + // Measured: `2670` + // Estimated: `18584154` + // Minimum execution time: 37_302_000 picoseconds. + Weight::from_parts(39_078_000, 18584154) + .saturating_add(T::DbWeight::get().reads(4_u64)) + .saturating_add(T::DbWeight::get().writes(2_u64)) + } } // For backwards compatibility and tests. @@ -507,4 +522,17 @@ impl WeightInfo for () { .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(5_u64)) } -} + /// Storage: `FileBank::File` (r:2 w:1) + /// Proof: `FileBank::File` (`max_values`: None, `max_size`: Some(9289107), added: 9291582, mode: `MaxEncodedLen`) + /// Storage: `FileBank::DealMap` (r:2 w:1) + /// Proof: `FileBank::DealMap` (`max_values`: None, `max_size`: Some(833655), added: 836130, mode: `MaxEncodedLen`) + fn migration_step() -> Weight { + // Proof Size summary in bytes: + // Measured: `2670` + // Estimated: `18584154` + // Minimum execution time: 37_302_000 picoseconds. + Weight::from_parts(39_078_000, 18584154) + .saturating_add(RocksDbWeight::get().reads(4_u64)) + .saturating_add(RocksDbWeight::get().writes(2_u64)) + } +} \ No newline at end of file diff --git a/pallets/sminer/src/benchmarking.rs b/pallets/sminer/src/benchmarking.rs index 8c7ec662..83694184 100644 --- a/pallets/sminer/src/benchmarking.rs +++ b/pallets/sminer/src/benchmarking.rs @@ -1,12 +1,20 @@ #![cfg(feature = "runtime-benchmarks")] use super::*; -use crate::{Pallet as Sminer}; +use crate::{Pallet as Sminer, + migrations::{ + SteppedSminer, + v2::{MinerItems as OldMinerItems, OldMinerInfo}, + }, +}; // use codec::{alloc::string::ToString, Decode}; +use frame_support::{weights::WeightMeter, migrations::SteppedMigration}; pub use frame_benchmarking::{ account, benchmarks, impl_benchmark_test_suite, whitelist_account, whitelisted_caller, }; use frame_system::RawOrigin; +use frame_benchmarking::v2::{*, benchmarks as benchmarksV2}; + // use frame_support::{ // traits::{Currency, Get}, // }; @@ -31,7 +39,7 @@ pub fn register_miner(account: AccountOf) -> Result<(), &'static s &account, 160_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"), ); - let peer_id: PeerId = [5u8; 38]; + let peer_id: EndPoint = "https://123123:123".as_bytes().to_vec().try_into().unwrap(); let staking_val: BalanceOf = 4_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); let tib_count = 1; Sminer::::regnstk(RawOrigin::Signed(account.clone()).into(), account.clone(), peer_id, staking_val, tib_count).map_err(|_| "miner register prep failed")?; @@ -71,241 +79,282 @@ pub fn set_facuet_whitelist_for_bench(acc: AccountOf) -> Result<() Ok(()) } -benchmarks! { - regnstk { - log::info!("regnstk start"); - pallet_tee_worker::benchmarking::generate_workers::(); +#[benchmarksV2] +mod migrate { + use super::*; + // use frame_benchmarking::v2::benchmarks; + + #[benchmark] + fn migration_step() { let caller = account("user1", 100, SEED); - let peer_id: PeerId = [5u8; 38]; ::Currency::make_free_balance_be( &caller, 160_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"), ); - + // let peer_id: EndPoint = "https://123123:123".as_bytes().to_vec().try_into().unwrap(); let staking_val: BalanceOf = 4_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); - let tib_count = 1; - }: _(RawOrigin::Signed(caller.clone()), caller.clone(), peer_id, staking_val, tib_count) - verify { - assert!(>::contains_key(&caller)) - } + let old_miner_items = OldMinerInfo::{ + beneficiary: caller.clone(), + staking_account: caller.clone(), + peer_id: [0u8; 38], + collaterals: staking_val, + debt: 0u64.saturated_into(), + state: Sminer::::str_to_bound(STATE_POSITIVE).unwrap(), + declaration_space: 0, + idle_space: 0, + service_space: 0, + lock_space: 0, + space_proof_info: Option::None, + service_bloom_filter: Default::default(), + tee_signature: Default::default(), + }; - increase_collateral { - log::info!("increase_collateral start"); - let caller: AccountOf = account("user1", 100, SEED); - register_miner::(caller.clone())?; - let staking_val: BalanceOf = 4_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); - }: _(RawOrigin::Signed(caller.clone()), caller.clone(), staking_val) - verify { - assert!(>::contains_key(&caller)); - let miner_info = >::get(caller).unwrap(); - assert_eq!(miner_info.collaterals, 8_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!")) - } + OldMinerItems::::insert(&caller, old_miner_items); - register_pois_key { - log::info!("register pois key start"); - pallet_tee_worker::benchmarking::generate_workers::(); - let caller: AccountOf = account("user1", 100, SEED); - register_miner::(caller.clone())?; - let pois_key = PoISKey { - g: [5u8; 256], - n: [6u8; 256], - }; - let space_proof_info = SpaceProofInfo::> { - miner: caller.clone(), - front: u64::MIN, - rear: u64::MIN, - pois_key: pois_key.clone(), - accumulator: pois_key.g, - }; - let encoding = space_proof_info.encode(); - let tee_puk = pallet_tee_worker::benchmarking::get_pubkey::(); - let tee_puk_encode = tee_puk.encode(); - let mut original = Vec::new(); - original.extend_from_slice(&encoding); - original.extend_from_slice(&tee_puk_encode); - let original_text = sp_io::hashing::sha2_256(&original); - let sig = pallet_tee_worker::benchmarking::sign_message::(&original_text); - let sig: BoundedVec> = sig.0.to_vec().try_into().map_err(|_| "bounded convert error")?; - }: _(RawOrigin::Signed(caller.clone()), pois_key, sig.clone(), sig, tee_puk) - verify { - assert!(>::contains_key(&caller)); - let miner_info = >::get(caller).unwrap(); - assert_eq!(miner_info.state, Sminer::::str_to_bound(STATE_POSITIVE)?) - } + let mut meter = WeightMeter::new(); - update_beneficiary { - log::info!("update beneficiary start"); - let caller: AccountOf = account("user1", 100, SEED); - register_miner::(caller.clone())?; - let beneficiary: AccountOf = account("user2", 100, SEED); - }: _(RawOrigin::Signed(caller.clone()), beneficiary.clone()) - verify { - assert!(>::contains_key(&caller)); - let miner_info = >::get(caller).unwrap(); - assert_eq!(miner_info.beneficiary, beneficiary) - } + #[block] + { + SteppedSminer::>::step(None, &mut meter).unwrap(); + } + } +} - update_peer_id { - log::info!("update peer id start"); - let caller: AccountOf = account("user1", 100, SEED); - register_miner::(caller.clone())?; - let new_peer_id: PeerId = [5u8; 38]; - }: _(RawOrigin::Signed(caller.clone()), new_peer_id) - verify { - assert!(>::contains_key(&caller)); - let miner_info = >::get(caller).unwrap(); - assert_eq!(miner_info.peer_id, new_peer_id) - } +// benchmarks! { +// regnstk { +// log::info!("regnstk start"); +// pallet_tee_worker::benchmarking::generate_workers::(); +// let caller = account("user1", 100, SEED); +// let peer_id: EndPoint = "https://123123:123".as_bytes().to_vec().try_into().unwrap(); +// ::Currency::make_free_balance_be( +// &caller, +// 160_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"), +// ); - receive_reward { - let v in 1 .. 80; - log::info!("receive_reward start"); - pallet_tee_worker::benchmarking::generate_workers::(); - pallet_cess_treasury::benchmarking::initialize_reward::(); - let caller: AccountOf = account("user1", 100, SEED); - register_positive_miner::(caller.clone())?; - let mut total_reward: BalanceOf = BalanceOf::::zero(); - let mut order_list: BoundedVec, BlockNumberFor>, ConstU32<90>> = Default::default(); - let order_reward: BalanceOf = 1_800_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); - let each_amount: BalanceOf = 10_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); - for i in 0 .. v { - let reward_order = RewardOrder::, BlockNumberFor> { - receive_count: 0, - max_count: 90, - atonce: false, - order_reward: order_reward, - each_amount: each_amount, - last_receive_block: 1u32.saturated_into(), - }; - total_reward = total_reward + order_reward; - order_list.try_push(reward_order).unwrap(); - } +// let staking_val: BalanceOf = 4_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); +// let tib_count = 1; +// }: _(RawOrigin::Signed(caller.clone()), caller.clone(), peer_id, staking_val, tib_count) +// verify { +// assert!(>::contains_key(&caller)) +// } - let reward = Reward:: { - total_reward: total_reward, - reward_issued: BalanceOf::::zero(), - order_list: order_list, - }; +// increase_collateral { +// log::info!("increase_collateral start"); +// let caller: AccountOf = account("user1", 100, SEED); +// register_miner::(caller.clone())?; +// let staking_val: BalanceOf = 4_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); +// }: _(RawOrigin::Signed(caller.clone()), caller.clone(), staking_val) +// verify { +// assert!(>::contains_key(&caller)); +// let miner_info = >::get(caller).unwrap(); +// assert_eq!(miner_info.collaterals, 8_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!")) +// } - >::insert(&caller, reward); - frame_system::Pallet::::set_block_number(28805u32.into()); - }: _(RawOrigin::Signed(caller.clone())) - verify { - let reward_info = >::get(&caller).unwrap(); - let vreward: BalanceOf = (((900 * BASE_UNIT) + (20 * BASE_UNIT)) * v as u128).try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); - assert_eq!(reward_info.reward_issued, vreward); - } +// register_pois_key { +// log::info!("register pois key start"); +// pallet_tee_worker::benchmarking::generate_workers::(); +// let caller: AccountOf = account("user1", 100, SEED); +// register_miner::(caller.clone())?; +// let pois_key = PoISKey { +// g: [5u8; 256], +// n: [6u8; 256], +// }; +// let space_proof_info = SpaceProofInfo::> { +// miner: caller.clone(), +// front: u64::MIN, +// rear: u64::MIN, +// pois_key: pois_key.clone(), +// accumulator: pois_key.g, +// }; +// let encoding = space_proof_info.encode(); +// let tee_puk = pallet_tee_worker::benchmarking::get_pubkey::(); +// let tee_puk_encode = tee_puk.encode(); +// let mut original = Vec::new(); +// original.extend_from_slice(&encoding); +// original.extend_from_slice(&tee_puk_encode); +// let original_text = sp_io::hashing::sha2_256(&original); +// let sig = pallet_tee_worker::benchmarking::sign_message::(&original_text); +// let sig: BoundedVec> = sig.0.to_vec().try_into().map_err(|_| "bounded convert error")?; +// }: _(RawOrigin::Signed(caller.clone()), pois_key, sig.clone(), sig, tee_puk) +// verify { +// assert!(>::contains_key(&caller)); +// let miner_info = >::get(caller).unwrap(); +// assert_eq!(miner_info.state, Sminer::::str_to_bound(STATE_POSITIVE)?) +// } - miner_exit_prep { - log::info!("miner exit prep start"); - pallet_tee_worker::benchmarking::generate_workers::(); - pallet_cess_treasury::benchmarking::initialize_reward::(); - let caller: AccountOf = account("user1", 100, SEED); - register_positive_miner::(caller.clone())?; - frame_system::Pallet::::set_block_number(28805000u32.into()); - }: _(RawOrigin::Signed(caller.clone()), caller.clone()) - verify { - assert!(>::contains_key(&caller)); - let miner_info = >::get(caller).unwrap(); - assert_eq!(miner_info.state, Sminer::::str_to_bound(STATE_LOCK)?) - } +// update_beneficiary { +// log::info!("update beneficiary start"); +// let caller: AccountOf = account("user1", 100, SEED); +// register_miner::(caller.clone())?; +// let beneficiary: AccountOf = account("user2", 100, SEED); +// }: _(RawOrigin::Signed(caller.clone()), beneficiary.clone()) +// verify { +// assert!(>::contains_key(&caller)); +// let miner_info = >::get(caller).unwrap(); +// assert_eq!(miner_info.beneficiary, beneficiary) +// } - miner_exit { - log::info!("miner exit start"); - pallet_tee_worker::benchmarking::generate_workers::(); - pallet_cess_treasury::benchmarking::initialize_reward::(); - let caller: AccountOf = account("user1", 100, SEED); - register_positive_miner::(caller.clone())?; - frame_system::Pallet::::set_block_number(28805000u32.into()); - Sminer::::miner_exit_prep(RawOrigin::Signed(caller.clone()).into(), caller.clone())?; - }: _(RawOrigin::Root, caller.clone()) - verify { - assert!(>::contains_key(&caller)); - } +// update_endpoint { +// log::info!("update peer id start"); +// let caller: AccountOf = account("user1", 100, SEED); +// register_miner::(caller.clone())?; +// let new_peer_id: EndPoint = "https://123123:123".as_bytes().to_vec().try_into().unwrap(); +// }: _(RawOrigin::Signed(caller.clone()), new_peer_id.clone()) +// verify { +// assert!(>::contains_key(&caller)); +// let miner_info = >::get(caller).unwrap(); +// assert_eq!(miner_info.endpoint, new_peer_id) +// } - miner_withdraw { - log::info!("miner miner_exit"); - log::info!("miner exit start"); - pallet_tee_worker::benchmarking::generate_workers::(); - pallet_cess_treasury::benchmarking::initialize_reward::(); - let caller: AccountOf = account("user1", 100, SEED); - register_positive_miner::(caller.clone())?; - frame_system::Pallet::::set_block_number(28805000u32.into()); - Sminer::::miner_exit_prep(RawOrigin::Signed(caller.clone()).into(), caller.clone())?; - Sminer::::miner_exit(RawOrigin::Root.into(), caller.clone()); - frame_system::Pallet::::set_block_number(28835000u32.into()); - let origin_free_balance = ::Currency::free_balance(&caller); - }: _(RawOrigin::Signed(caller.clone())) - verify { - let current_free_balance = ::Currency::free_balance(&caller); - let staking_val: BalanceOf = 4_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); - assert_eq!(current_free_balance, origin_free_balance + staking_val); - } +// receive_reward { +// let v in 1 .. 80; +// log::info!("receive_reward start"); +// pallet_tee_worker::benchmarking::generate_workers::(); +// pallet_cess_treasury::benchmarking::initialize_reward::(); +// let caller: AccountOf = account("user1", 100, SEED); +// register_positive_miner::(caller.clone())?; +// let mut total_reward: BalanceOf = BalanceOf::::zero(); +// let mut order_list: BoundedVec, BlockNumberFor>, ConstU32<90>> = Default::default(); +// let order_reward: BalanceOf = 1_800_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); +// let each_amount: BalanceOf = 10_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); +// for i in 0 .. v { +// let reward_order = RewardOrder::, BlockNumberFor> { +// receive_count: 0, +// max_count: 90, +// atonce: false, +// order_reward: order_reward, +// each_amount: each_amount, +// last_receive_block: 1u32.saturated_into(), +// }; +// total_reward = total_reward + order_reward; +// order_list.try_push(reward_order).unwrap(); +// } - faucet_top_up { - let caller: T::AccountId = whitelisted_caller(); - let existential_deposit = ::Currency::minimum_balance(); - let faucet_reward: BalanceOf = 365_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); - ::Currency::make_free_balance_be( - &caller, - faucet_reward, - ); - let fa: BalanceOf = existential_deposit.checked_mul(&10u32.saturated_into()).ok_or("over flow")?; - }: _(RawOrigin::Signed(caller), fa) - verify { - let pallet_acc = ::FaucetId::get().into_account_truncating(); - let free = ::Currency::free_balance(&pallet_acc); - assert_eq!(free, fa) - } +// let reward = Reward:: { +// total_reward: total_reward, +// reward_issued: BalanceOf::::zero(), +// order_list: order_list, +// }; - faucet { - let caller: T::AccountId = whitelisted_caller(); - let faucet_acc: AccountOf = T::FaucetId::get().into_account_truncating(); - let existential_deposit = ::Currency::minimum_balance(); - let faucet_reward: BalanceOf = 365_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); - ::Currency::make_free_balance_be( - &caller, - existential_deposit, - ); - ::Currency::make_free_balance_be( - &faucet_acc, - faucet_reward, - ); - set_facuet_whitelist_for_bench::(caller.clone()); - }: _(RawOrigin::Signed(caller.clone()), caller.clone()) - verify { - assert!(>::contains_key(&caller)) - } +// >::insert(&caller, reward); +// frame_system::Pallet::::set_block_number(28805u32.into()); +// }: _(RawOrigin::Signed(caller.clone())) +// verify { +// let reward_info = >::get(&caller).unwrap(); +// let vreward: BalanceOf = (((900 * BASE_UNIT) + (20 * BASE_UNIT)) * v as u128).try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); +// assert_eq!(reward_info.reward_issued, vreward); +// } - regnstk_assign_staking { - log::info!("regnstk_assign_staking start"); - pallet_tee_worker::benchmarking::generate_workers::(); - let caller = account("user1", 100, SEED); - let staking_account = account("user2", 100, SEED); - let peer_id: PeerId = [5u8; 38]; - ::Currency::make_free_balance_be( - &caller, - 160_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"), - ); +// miner_exit_prep { +// log::info!("miner exit prep start"); +// pallet_tee_worker::benchmarking::generate_workers::(); +// pallet_cess_treasury::benchmarking::initialize_reward::(); +// let caller: AccountOf = account("user1", 100, SEED); +// register_positive_miner::(caller.clone())?; +// frame_system::Pallet::::set_block_number(28805000u32.into()); +// }: _(RawOrigin::Signed(caller.clone()), caller.clone()) +// verify { +// assert!(>::contains_key(&caller)); +// let miner_info = >::get(caller).unwrap(); +// assert_eq!(miner_info.state, Sminer::::str_to_bound(STATE_LOCK)?) +// } - let staking_val: BalanceOf = 4_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); - let tib_count = 1; - }: _(RawOrigin::Signed(caller.clone()), caller.clone(), peer_id, staking_account, tib_count) - verify { - assert!(>::contains_key(&caller)) - } +// miner_exit { +// log::info!("miner exit start"); +// pallet_tee_worker::benchmarking::generate_workers::(); +// pallet_cess_treasury::benchmarking::initialize_reward::(); +// let caller: AccountOf = account("user1", 100, SEED); +// register_positive_miner::(caller.clone())?; +// frame_system::Pallet::::set_block_number(28805000u32.into()); +// Sminer::::miner_exit_prep(RawOrigin::Signed(caller.clone()).into(), caller.clone())?; +// }: _(RawOrigin::Root, caller.clone()) +// verify { +// assert!(>::contains_key(&caller)); +// } + +// miner_withdraw { +// log::info!("miner miner_exit"); +// log::info!("miner exit start"); +// pallet_tee_worker::benchmarking::generate_workers::(); +// pallet_cess_treasury::benchmarking::initialize_reward::(); +// let caller: AccountOf = account("user1", 100, SEED); +// register_positive_miner::(caller.clone())?; +// frame_system::Pallet::::set_block_number(28805000u32.into()); +// Sminer::::miner_exit_prep(RawOrigin::Signed(caller.clone()).into(), caller.clone())?; +// Sminer::::miner_exit(RawOrigin::Root.into(), caller.clone()); +// frame_system::Pallet::::set_block_number(28835000u32.into()); +// let origin_free_balance = ::Currency::free_balance(&caller); +// }: _(RawOrigin::Signed(caller.clone())) +// verify { +// let current_free_balance = ::Currency::free_balance(&caller); +// let staking_val: BalanceOf = 4_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); +// assert_eq!(current_free_balance, origin_free_balance + staking_val); +// } + +// faucet_top_up { +// let caller: T::AccountId = whitelisted_caller(); +// let existential_deposit = ::Currency::minimum_balance(); +// let faucet_reward: BalanceOf = 365_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); +// ::Currency::make_free_balance_be( +// &caller, +// faucet_reward, +// ); +// let fa: BalanceOf = existential_deposit.checked_mul(&10u32.saturated_into()).ok_or("over flow")?; +// }: _(RawOrigin::Signed(caller), fa) +// verify { +// let pallet_acc = ::FaucetId::get().into_account_truncating(); +// let free = ::Currency::free_balance(&pallet_acc); +// assert_eq!(free, fa) +// } + +// faucet { +// let caller: T::AccountId = whitelisted_caller(); +// let faucet_acc: AccountOf = T::FaucetId::get().into_account_truncating(); +// let existential_deposit = ::Currency::minimum_balance(); +// let faucet_reward: BalanceOf = 365_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); +// ::Currency::make_free_balance_be( +// &caller, +// existential_deposit, +// ); +// ::Currency::make_free_balance_be( +// &faucet_acc, +// faucet_reward, +// ); +// set_facuet_whitelist_for_bench::(caller.clone()); +// }: _(RawOrigin::Signed(caller.clone()), caller.clone()) +// verify { +// assert!(>::contains_key(&caller)) +// } + +// regnstk_assign_staking { +// log::info!("regnstk_assign_staking start"); +// pallet_tee_worker::benchmarking::generate_workers::(); +// let caller = account("user1", 100, SEED); +// let staking_account = account("user2", 100, SEED); +// let peer_id: EndPoint = "https://123123:123".as_bytes().to_vec().try_into().unwrap(); +// ::Currency::make_free_balance_be( +// &caller, +// 160_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"), +// ); + +// let staking_val: BalanceOf = 4_000_000_000_000_000_000_000u128.try_into().map_err(|_| "tryinto error!").expect("tryinto error!"); +// let tib_count = 1; +// }: _(RawOrigin::Signed(caller.clone()), caller.clone(), peer_id, staking_account, tib_count) +// verify { +// assert!(>::contains_key(&caller)) +// } - increase_declaration_space { - log::info!("increase_declaration_space start"); - pallet_tee_worker::benchmarking::generate_workers::(); - pallet_cess_treasury::benchmarking::initialize_reward::(); - let caller: AccountOf = account("user1", 100, SEED); - register_positive_miner::(caller.clone())?; - let tib_count = 5; - }: _(RawOrigin::Signed(caller.clone()), tib_count) - verify { - assert!(>::contains_key(&caller)); - let miner_info = >::get(caller).unwrap(); - assert_eq!(miner_info.state, Sminer::::str_to_bound(STATE_FROZEN)?) - } -} \ No newline at end of file +// increase_declaration_space { +// log::info!("increase_declaration_space start"); +// pallet_tee_worker::benchmarking::generate_workers::(); +// pallet_cess_treasury::benchmarking::initialize_reward::(); +// let caller: AccountOf = account("user1", 100, SEED); +// register_positive_miner::(caller.clone())?; +// let tib_count = 5; +// }: _(RawOrigin::Signed(caller.clone()), tib_count) +// verify { +// assert!(>::contains_key(&caller)); +// let miner_info = >::get(caller).unwrap(); +// assert_eq!(miner_info.state, Sminer::::str_to_bound(STATE_FROZEN)?) +// } +// } \ No newline at end of file diff --git a/pallets/sminer/src/lib.rs b/pallets/sminer/src/lib.rs index c8bb8932..020f5337 100644 --- a/pallets/sminer/src/lib.rs +++ b/pallets/sminer/src/lib.rs @@ -23,7 +23,7 @@ use cp_bloom_filter::BloomFilter; use cp_cess_common::*; use frame_support::{ dispatch::DispatchResult, - ensure, + ensure, weights::{Weight, WeightMeter}, pallet_prelude::DispatchError, storage::bounded_vec::BoundedVec, traits::{ @@ -32,7 +32,7 @@ use frame_support::{ v3::{Anon as ScheduleAnon, Named as ScheduleNamed}, DispatchTime, }, - Currency, + Currency, StorageVersion, ExistenceRequirement::KeepAlive, Get, ReservableCurrency, }, @@ -51,7 +51,6 @@ use sp_runtime::{ }; use sp_staking::StakingInterface; use sp_std::{convert::TryInto, marker::PhantomData, prelude::*}; - pub use pallet::*; #[cfg(feature = "runtime-benchmarks")] @@ -75,6 +74,10 @@ mod helper; pub mod weights; pub use weights::WeightInfo; +pub mod migration; + +const STORAGE_VERSION: StorageVersion = StorageVersion::new(1); + type AccountOf = ::AccountId; type BalanceOf = <::Currency as Currency<::AccountId>>::Balance; type ProposalCallOf = ::SProposal; @@ -186,10 +189,10 @@ pub mod pallet { acc: AccountOf, new: AccountOf, }, - UpdatePeerId { + UpdateEndPoint { acc: AccountOf, - old: PeerId, - new: PeerId, + old: EndPoint, + new: EndPoint, }, Receive { acc: AccountOf, @@ -348,6 +351,7 @@ pub mod pallet { pub(super) type FacuetWhitelist = StorageValue<_, AccountOf>; #[pallet::pallet] + #[pallet::storage_version(STORAGE_VERSION)] pub struct Pallet(_); #[pallet::genesis_config] @@ -408,7 +412,7 @@ pub mod pallet { /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. Typically, /// this is the account that wishes to register as a Miner. /// - `beneficiary`: The account that will receive the rewards for mining. - /// - `peer_id`: A unique identifier for the Miner on the network. + /// - `endpoint`: A unique identifier for the Miner on the network. /// - `staking_val`: The amount of collateral that the Miner is staking to participate in mining. /// - `pois_key`: The PoS key provided by the Miner. /// - `tee_sig`: A TeeRSA signature for verifying the authenticity of the PoS key. @@ -418,7 +422,7 @@ pub mod pallet { pub fn regnstk( origin: OriginFor, beneficiary: AccountOf, - peer_id: PeerId, + endpoint: EndPoint, staking_val: BalanceOf, tib_count: u32, ) -> DispatchResult { @@ -442,7 +446,7 @@ pub mod pallet { MinerInfo:: { beneficiary: beneficiary.clone(), staking_account: sender.clone(), - peer_id, + endpoint, collaterals: staking_val, debt: BalanceOf::::zero(), state: Self::str_to_bound(STATE_NOT_READY)?, @@ -595,22 +599,22 @@ pub mod pallet { /// Parameters: /// - `origin`: The origin from which the function is called, ensuring the caller's authorization. Typically, /// this is the account that is a registered Miner. - /// - `peer_id`: The new Peer ID to be associated with the Miner for network communication. + /// - `endpoint`: The new Peer ID to be associated with the Miner for network communication. #[pallet::call_index(3)] #[transactional] #[pallet::weight(::WeightInfo::update_peer_id())] - pub fn update_peer_id(origin: OriginFor, peer_id: PeerId) -> DispatchResult { + pub fn update_endpoint(origin: OriginFor, endpoint: EndPoint) -> DispatchResult { let sender = ensure_signed(origin)?; ensure!(MinerItems::::contains_key(&sender), Error::::NotMiner); - let old = >::try_mutate(&sender, |miner_info_opt| -> Result { + let old = >::try_mutate(&sender, |miner_info_opt| -> Result { let miner_info = miner_info_opt.as_mut().ok_or(Error::::ConversionError)?; - let old = miner_info.peer_id.clone(); - miner_info.peer_id = peer_id.clone(); + let old = miner_info.endpoint.clone(); + miner_info.endpoint = endpoint.clone(); Ok(old) })?; - Self::deposit_event(Event::::UpdatePeerId { acc: sender, old, new: peer_id.into() }); + Self::deposit_event(Event::::UpdateEndPoint { acc: sender, old, new: endpoint.into() }); Ok(()) } @@ -1001,7 +1005,7 @@ pub mod pallet { pub fn regnstk_assign_staking( origin: OriginFor, beneficiary: AccountOf, - peer_id: PeerId, + endpoint: EndPoint, staking_account: AccountOf, tib_count: u32, ) -> DispatchResult { @@ -1028,7 +1032,7 @@ pub mod pallet { MinerInfo:: { beneficiary: beneficiary.clone(), staking_account: staking_account.clone(), - peer_id, + endpoint, collaterals: need_staking, debt: BalanceOf::::zero(), state: Self::str_to_bound(STATE_NOT_READY)?, @@ -1413,4 +1417,4 @@ impl MinerControl<::AccountId, BlockNumber Ok(()) }) } -} +} \ No newline at end of file diff --git a/pallets/sminer/src/migration.rs b/pallets/sminer/src/migration.rs new file mode 100644 index 00000000..2356644a --- /dev/null +++ b/pallets/sminer/src/migration.rs @@ -0,0 +1,134 @@ +use super::*; +use sp_runtime::{TryRuntimeError}; +#[cfg(feature = "try-runtime")] +use sp_std::collections::btree_map::BTreeMap; +#[cfg(feature = "try-runtime")] +use sp_std::vec::Vec; + +use frame_support::{ + storage_alias, weights::WeightMeter, Blake2_128Concat, + migrations::{MigrationId, SteppedMigration, SteppedMigrationError}, +}; + +pub const PALLET_MIGRATIONS_ID: &[u8; 23] = b"pallet-sminer-migration"; +pub struct SteppedSminer(PhantomData<(T, W)>); + +impl SteppedMigration for SteppedSminer { + type Cursor = T::AccountId; + + type Identifier = MigrationId<23>; + + fn id() -> Self::Identifier { + MigrationId { pallet_id: *PALLET_MIGRATIONS_ID, version_from: 0, version_to: 1 } + } + + fn step( + mut cursor: Option, + meter: &mut WeightMeter + ) -> Result, SteppedMigrationError> { + let required = W::migration_step(); + + if meter.remaining().any_lt(required) { + return Err(SteppedMigrationError::InsufficientWeight { required }); + } + + loop { + if meter.try_consume(required).is_err() { + break; + } + + let mut iter = if let Some(last_key) = cursor { + v2::MinerItems::::iter_from(v2::MinerItems::::hashed_key_for(last_key)) + } else { + v2::MinerItems::::iter() + }; + + if let Some((last_key, value)) = iter.next() { + // We can just insert here since the old and the new map share the same key-space. + // Otherwise it would have to invert the concat hash function and re-hash it. + let miner_info = MinerInfo::{ + beneficiary: value.beneficiary, + staking_account: value.staking_account, + endpoint: Default::default(), + collaterals: value.collaterals, + debt: value.debt, + state: value.state, + declaration_space: value.declaration_space, + idle_space: value.idle_space, + service_space: value.service_space, + lock_space: value.lock_space, + space_proof_info: value.space_proof_info, + service_bloom_filter: value.service_bloom_filter, + tee_signature: value.tee_signature, + }; + MinerItems::::insert(&last_key, miner_info); + + cursor = Some(last_key) // Return the processed key as the new cursor. + } else { + cursor = None; // Signal that the migration is complete (no more items to process). + break + } + } + + Ok(cursor) + } + + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, TryRuntimeError> { + use codec::Encode; + let miner_records: BTreeMap<_, _> = v2::MinerItems::::iter() + .take(10) + .collect(); + Ok(miner_records.encode()) + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade(prev_state: Vec) -> Result<(), TryRuntimeError> { + let miner_state = , v2::OldMinerInfo>>::decode(&mut &prev_state[..]) + .expect("Failed to decode the previous storage state"); + + for (key, value) in miner_state { + let miner = MinerItems::::get(key) + .expect("Migrated miner should exist"); + + assert!(miner.idle_space == value.idle_space, "Idle space mismatch"); + assert!(miner.service_space == value.service_space, "Service space mismatch"); + assert!(miner.lock_space == value.lock_space, "Lock space mismatch"); + assert!(miner.declaration_space == value.declaration_space, "Declaration space mismatch"); + assert!(miner.collaterals == value.collaterals, "Collaterals mismatch"); + assert!(miner.debt == value.debt, "Debt mismatch"); + assert!(miner.state == value.state, "State mismatch"); + assert!(miner.space_proof_info == value.space_proof_info, "Space proof info mismatch"); + assert!(miner.service_bloom_filter == value.service_bloom_filter, "Service bloom filter mismatch"); + assert!(miner.tee_signature == value.tee_signature, "TEE signature mismatch"); + assert_eq!(miner.endpoint, EndPoint::default(), "Endpoint mismatch"); + } + + log::info!("sminer check access success: verified first 10 records of MinerItems"); + Ok(()) + } +} + +pub mod v2 { + use super::{*, MinerItems as NewMinerItems}; + + #[storage_alias] + pub type MinerItems = StorageMap, Blake2_128Concat, AccountOf, OldMinerInfo>; + + #[derive(Encode, Decode, RuntimeDebug, TypeInfo)] + pub struct OldMinerInfo { + pub beneficiary: AccountOf, + pub staking_account: AccountOf, + pub peer_id: PeerId, + pub collaterals: BalanceOf, + pub debt: BalanceOf, + pub state: BoundedVec, + pub declaration_space: u128, + pub idle_space: u128, + pub service_space: u128, + pub lock_space: u128, + pub space_proof_info: Option>>, + pub service_bloom_filter: BloomFilter, + pub tee_signature: TeeSig, + } +} \ No newline at end of file diff --git a/pallets/sminer/src/types.rs b/pallets/sminer/src/types.rs index deba81a7..9309d110 100644 --- a/pallets/sminer/src/types.rs +++ b/pallets/sminer/src/types.rs @@ -9,7 +9,7 @@ pub struct MinerInfo { //Income account pub beneficiary: AccountOf, pub staking_account: AccountOf, - pub peer_id: PeerId, + pub endpoint: EndPoint, pub collaterals: BalanceOf, pub debt: BalanceOf, //nomal, exit, frozen, e_frozen diff --git a/pallets/sminer/src/weights.rs b/pallets/sminer/src/weights.rs index ef286cb6..6810779e 100644 --- a/pallets/sminer/src/weights.rs +++ b/pallets/sminer/src/weights.rs @@ -49,6 +49,7 @@ pub trait WeightInfo { fn faucet() -> Weight; fn regnstk_assign_staking() -> Weight; fn increase_declaration_space() -> Weight; + fn migration_step() -> Weight; } /// Weights for `pallet_sminer` using the Substrate node and recommended hardware. @@ -67,7 +68,7 @@ impl WeightInfo for SubstrateWeight { fn regnstk() -> Weight { // Proof Size summary in bytes: // Measured: `183` - // Estimated: `206644` + // Estimated: `206644` 0.04 // Minimum execution time: 40_185_000 picoseconds. Weight::from_parts(61_828_000, 206644) .saturating_add(T::DbWeight::get().reads(3_u64)) @@ -256,6 +257,17 @@ impl WeightInfo for SubstrateWeight { .saturating_add(T::DbWeight::get().reads(1_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } + /// Storage: `Sminer::MinerItems` (r:2 w:1) + /// Proof: `Sminer::MinerItems` (`max_values`: None, `max_size`: Some(203243), added: 205718, mode: `MaxEncodedLen`) + fn migration_step() -> Weight { + // Proof Size summary in bytes: + // Measured: `2582` + // Estimated: `412426` + // Minimum execution time: 19_449_000 picoseconds. + Weight::from_parts(20_632_000, 412426) + .saturating_add(RocksDbWeight::get().reads(2_u64)) + .saturating_add(RocksDbWeight::get().writes(1_u64)) + } } // For backwards compatibility and tests. @@ -462,4 +474,15 @@ impl WeightInfo for () { .saturating_add(RocksDbWeight::get().reads(1_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } -} + /// Storage: `Sminer::MinerItems` (r:2 w:1) + /// Proof: `Sminer::MinerItems` (`max_values`: None, `max_size`: Some(203243), added: 205718, mode: `MaxEncodedLen`) + fn migration_step() -> Weight { + // Proof Size summary in bytes: + // Measured: `2582` + // Estimated: `412426` + // Minimum execution time: 19_449_000 picoseconds. + Weight::from_parts(20_632_000, 412426) + .saturating_add(RocksDbWeight::get().reads(2_u64)) + .saturating_add(RocksDbWeight::get().writes(1_u64)) + } +} \ No newline at end of file diff --git a/standalone/chain/runtime/src/lib.rs b/standalone/chain/runtime/src/lib.rs index 502c71e6..ea09de5c 100644 --- a/standalone/chain/runtime/src/lib.rs +++ b/standalone/chain/runtime/src/lib.rs @@ -86,6 +86,8 @@ use sp_staking::currency_to_vote::CurrencyToVote; use sp_version::NativeVersion; use sp_version::RuntimeVersion; use static_assertions::const_assert; +use pallet_file_bank::migration::SteppedFileBank; +use pallet_sminer::migration::SteppedSminer; // Frontier use fp_rpc::TransactionStatus; @@ -152,7 +154,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { // and set impl_version to 0. If only runtime // implementation changes and behavior does not, then leave spec_version as // is and increment impl_version. - spec_version: 125, + spec_version: 126, impl_version: 0, apis: RUNTIME_API_VERSIONS, transaction_version: 1, @@ -1188,7 +1190,7 @@ parameter_types! { impl pallet_migrations::Config for Runtime { type RuntimeEvent = RuntimeEvent; #[cfg(not(feature = "runtime-benchmarks"))] - type Migrations = (); + type Migrations = (SteppedFileBank::WeightInfo>, SteppedSminer::WeightInfo>); // Benchmarks need mocked migrations to guarantee that they succeed. #[cfg(feature = "runtime-benchmarks")] type Migrations = pallet_migrations::mock_helpers::MockedMigrations; @@ -1660,7 +1662,6 @@ impl pallet_file_bank::Config for Runtime { type OneDay = OneDay; type CreditCounter = SchedulerCredit; type OssFindAuthor = Oss; - type BucketLimit = BucketLimit; type NameStrLimit = NameStrLimit; type SegmentCount = SegmentCount; type FragmentCount = FragmentCount; @@ -2635,4 +2636,4 @@ mod tests { size, ); } -} +} \ No newline at end of file From b9a8048e9855f12e72f8da3b0b539287786b6c10 Mon Sep 17 00:00:00 2001 From: ytqaljn <2716693942@qq.com> Date: Fri, 17 Jan 2025 09:39:01 +0800 Subject: [PATCH 2/3] fix: fix try-runtime error --- pallets/file-bank/src/lib.rs | 2 +- pallets/sminer/src/lib.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/pallets/file-bank/src/lib.rs b/pallets/file-bank/src/lib.rs index 46bd48cc..ad35aa9e 100755 --- a/pallets/file-bank/src/lib.rs +++ b/pallets/file-bank/src/lib.rs @@ -83,7 +83,7 @@ pub use weights::WeightInfo; type AccountOf = ::AccountId; -const STORAGE_VERSION: StorageVersion = StorageVersion::new(3); +const STORAGE_VERSION: StorageVersion = StorageVersion::new(2); #[frame_support::pallet] pub mod pallet { diff --git a/pallets/sminer/src/lib.rs b/pallets/sminer/src/lib.rs index 020f5337..2cfd19b5 100644 --- a/pallets/sminer/src/lib.rs +++ b/pallets/sminer/src/lib.rs @@ -76,7 +76,7 @@ pub use weights::WeightInfo; pub mod migration; -const STORAGE_VERSION: StorageVersion = StorageVersion::new(1); +const STORAGE_VERSION: StorageVersion = StorageVersion::new(0); type AccountOf = ::AccountId; type BalanceOf = <::Currency as Currency<::AccountId>>::Balance; From 9f8f8c6ee8d0ca433311b9fca8a07865d5da7e83 Mon Sep 17 00:00:00 2001 From: ytqaljn <2716693942@qq.com> Date: Fri, 17 Jan 2025 10:37:01 +0800 Subject: [PATCH 3/3] style: update runtime crate version --- Cargo.lock | 2 +- standalone/chain/runtime/Cargo.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 85d37fb4..03e7becc 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2211,7 +2211,7 @@ dependencies = [ [[package]] name = "cess-node-runtime" -version = "0.9.1" +version = "0.10.0" dependencies = [ "ces-pallet-mq", "ces-pallet-mq-runtime-api", diff --git a/standalone/chain/runtime/Cargo.toml b/standalone/chain/runtime/Cargo.toml index d4ac53e4..3dbabd3c 100644 --- a/standalone/chain/runtime/Cargo.toml +++ b/standalone/chain/runtime/Cargo.toml @@ -4,7 +4,7 @@ edition = "2021" license = "Unlicense" name = "cess-node-runtime" repository = "https://github.com/CESSProject/cess" -version = "0.9.1" +version = "0.10.0" [package.metadata.docs.rs] targets = ["x86_64-unknown-linux-gnu"]