refactor: Bundle SystemMetadata subnet fields into OwnSubnetInfo struct

rs/canonical_state/src/lazy_tree_conversion.rs

@@ -480,7 +480,7 @@ pub fn replicated_state_as_lazy_tree(state: &ReplicatedState, height: Height) ->
                 subnets_as_tree(
                     state.metadata.network_topology.subnets_for_certification(),
                     own_subnet_id,
-                    &state.metadata.node_public_keys,
+                    &state.metadata.own_subnet_info.node_public_keys,
                     inverted_routing_table.clone(),
                     &state.metadata.subnet_metrics,
                     certification_version,

rs/canonical_state/src/traversal.rs

@@ -820,7 +820,7 @@ mod tests {
                 .unwrap(),
             );
         });
-        state.metadata.node_public_keys = btreemap! {
+        std::sync::Arc::make_mut(&mut state.metadata.own_subnet_info).node_public_keys = btreemap! {
             node_test_id(2) => vec![9, 10, 11, 12],
         };
 

rs/execution_environment/src/execution_environment.rs

@@ -1268,7 +1268,7 @@ impl ExecutionEnvironment {
                 },
             },
 
-            Ok(Ic00Method::HttpRequest) => match state.metadata.own_subnet_features.http_requests {
+            Ok(Ic00Method::HttpRequest) => match state.subnet_features().http_requests {
                 true => match &msg {
                     CanisterCall::Request(request) => {
                         match CanisterHttpRequestArgs::decode(payload) {

rs/execution_environment/src/execution_environment/tests.rs

@@ -2296,7 +2296,9 @@ fn management_canister_xnet_to_nns_called_from_non_nns() {
         .with_nns_subnet_id(own_subnet)
         .with_caller(other_subnet, other_canister)
         .build();
-    test.state_mut().metadata.own_subnet_features.http_requests = true;
+    std::sync::Arc::make_mut(&mut test.state_mut().metadata.own_subnet_info)
+        .subnet_features
+        .http_requests = true;
 
     test.inject_call_to_ic00(
         Method::CreateCanister,
@@ -2330,7 +2332,9 @@ fn http_request_bound_holds() {
         // set number of max in-flight calls to 10
         .with_max_canister_http_requests_in_flight(10)
         .build();
-    test.state_mut().metadata.own_subnet_features.http_requests = true;
+    std::sync::Arc::make_mut(&mut test.state_mut().metadata.own_subnet_info)
+        .subnet_features
+        .http_requests = true;
 
     // Create payload of the request.
     let url = "https://".to_string();
@@ -2395,7 +2399,9 @@ fn management_canister_xnet_called_from_non_nns() {
         .with_nns_subnet_id(nns_subnet)
         .with_caller(other_subnet, other_canister)
         .build();
-    test.state_mut().metadata.own_subnet_features.http_requests = true;
+    std::sync::Arc::make_mut(&mut test.state_mut().metadata.own_subnet_info)
+        .subnet_features
+        .http_requests = true;
 
     test.inject_call_to_ic00(
         Method::CreateCanister,
@@ -3345,7 +3351,9 @@ fn execute_canister_http_request_disabled() {
         .with_own_subnet_id(own_subnet)
         .with_caller(own_subnet, caller_canister)
         .build();
-    test.state_mut().metadata.own_subnet_features.http_requests = false;
+    std::sync::Arc::make_mut(&mut test.state_mut().metadata.own_subnet_info)
+        .subnet_features
+        .http_requests = false;
 
     // Create payload of the request.
     let url = "https://".to_string();

rs/execution_environment/src/scheduler/tests/metrics.rs

@@ -935,7 +935,9 @@ fn consumed_cycles_http_outcalls_are_added_to_consumed_cycles_total() {
             .build();
         let caller_canister = test.create_canister();
 
-        test.state_mut().metadata.own_subnet_features.http_requests = true;
+        std::sync::Arc::make_mut(&mut test.state_mut().metadata.own_subnet_info)
+            .subnet_features
+            .http_requests = true;
 
         test.state_metrics().observe(
             test.state().metadata.own_subnet_id,
@@ -1047,7 +1049,9 @@ fn http_outcalls_free() {
         .build();
     let caller_canister = test.create_canister();
 
-    test.state_mut().metadata.own_subnet_features.http_requests = true;
+    std::sync::Arc::make_mut(&mut test.state_mut().metadata.own_subnet_info)
+        .subnet_features
+        .http_requests = true;
 
     let cycles_before = test.canister_state(caller_canister).system_state.balance();
 

rs/messaging/src/message_routing.rs

@@ -30,12 +30,12 @@ use ic_registry_client_helpers::subnet::{
     SubnetListRegistry, SubnetRegistry, get_node_ids_from_subnet_record,
 };
 use ic_registry_provisional_whitelist::ProvisionalWhitelist;
-use ic_registry_resource_limits::ResourceLimits;
 use ic_registry_subnet_features::{ChainKeyConfig, SubnetFeatures};
 use ic_registry_subnet_type::SubnetType;
 use ic_replicated_state::metadata_state::ApiBoundaryNodeEntry;
 use ic_replicated_state::{
-    DroppedMessageMetrics, FullTopology, NetworkTopology, ReplicatedState, SubnetTopology,
+    DroppedMessageMetrics, FullTopology, NetworkTopology, OwnSubnetInfo, ReplicatedState,
+    SubnetTopology,
 };
 use ic_types::batch::{Batch, BatchContent, BatchSummary};
 use ic_types::crypto::{KeyPurpose, threshold_sig::ThresholdSigPublicKey};
@@ -724,13 +724,7 @@ impl<RegistryClient_: RegistryClient> BatchProcessorImpl<RegistryClient_> {
         &self,
         registry_version: RegistryVersion,
         own_subnet_id: SubnetId,
-    ) -> (
-        NetworkTopology,
-        SubnetFeatures,
-        ResourceLimits,
-        RegistryExecutionSettings,
-        NodePublicKeys,
-    ) {
+    ) -> (NetworkTopology, OwnSubnetInfo, RegistryExecutionSettings) {
         loop {
             match self.try_to_read_registry(registry_version, own_subnet_id) {
                 Ok(result) => return result,
@@ -769,16 +763,8 @@ impl<RegistryClient_: RegistryClient> BatchProcessorImpl<RegistryClient_> {
         &self,
         registry_version: RegistryVersion,
         own_subnet_id: SubnetId,
-    ) -> Result<
-        (
-            NetworkTopology,
-            SubnetFeatures,
-            ResourceLimits,
-            RegistryExecutionSettings,
-            NodePublicKeys,
-        ),
-        ReadRegistryError,
-    > {
+    ) -> Result<(NetworkTopology, OwnSubnetInfo, RegistryExecutionSettings), ReadRegistryError>
+    {
         let subnet_record = self
             .registry
             .get_subnet_record(own_subnet_id, registry_version)
@@ -900,8 +886,11 @@ impl<RegistryClient_: RegistryClient> BatchProcessorImpl<RegistryClient_> {
 
         Ok((
             network_topology,
-            subnet_features,
-            resource_limits,
+            OwnSubnetInfo {
+                subnet_features,
+                resource_limits,
+                node_public_keys,
+            },
             RegistryExecutionSettings {
                 max_number_of_canisters,
                 provisional_whitelist,
@@ -910,7 +899,6 @@ impl<RegistryClient_: RegistryClient> BatchProcessorImpl<RegistryClient_> {
                 node_ids: nodes,
                 registry_version,
             },
-            node_public_keys,
         ))
     }
 
@@ -1388,13 +1376,8 @@ impl<RegistryClient_: RegistryClient> BatchProcessor for BatchProcessorImpl<Regi
         // TODO (MR-29) Cache network topology and subnet_features; and populate only
         // if version referenced in batch changes.
         let registry_version = batch.registry_version;
-        let (
-            network_topology,
-            subnet_features,
-            resource_limits,
-            registry_execution_settings,
-            node_public_keys,
-        ) = self.read_registry(registry_version, state.metadata.own_subnet_id);
+        let (network_topology, own_subnet_info, registry_execution_settings) =
+            self.read_registry(registry_version, state.metadata.own_subnet_id);
 
         self.metrics.blocks_proposed_total.inc();
         self.metrics
@@ -1416,12 +1399,10 @@ impl<RegistryClient_: RegistryClient> BatchProcessor for BatchProcessorImpl<Regi
         let batch_number = batch.batch_number;
         let mut state_after_round = self.state_machine.execute_round(
             state,
-            network_topology,
             batch,
-            subnet_features,
-            resource_limits,
+            network_topology,
+            own_subnet_info,
             &registry_execution_settings,
-            node_public_keys,
         );
 
         let garbage_collect_timer = self.metrics.start_phase_timer(PHASE_GARBAGE_COLLECT);

rs/messaging/src/message_routing/tests.rs

@@ -619,17 +619,13 @@ impl StateMachine for FakeStateMachine {
     fn execute_round(
         &self,
         mut state: ReplicatedState,
-        network_topology: NetworkTopology,
         _batch: Batch,
-        subnet_features: SubnetFeatures,
-        resource_limits: ResourceLimits,
+        network_topology: NetworkTopology,
+        own_subnet_info: OwnSubnetInfo,
         registry_settings: &RegistryExecutionSettings,
-        node_public_keys: NodePublicKeys,
     ) -> ReplicatedState {
         state.metadata.network_topology = Arc::new(network_topology);
-        state.metadata.own_subnet_features = subnet_features;
-        state.metadata.own_resource_limits = resource_limits;
-        state.metadata.node_public_keys = node_public_keys;
+        state.metadata.own_subnet_info = Arc::new(own_subnet_info);
         state.put_canister_state(
             CanisterStateBuilder::new()
                 .with_canister_id(canister_test_id(1))
@@ -687,16 +683,7 @@ fn try_to_read_registry(
     registry: Arc<FakeRegistryClient>,
     log: ReplicaLogger,
     own_subnet_id: SubnetId,
-) -> Result<
-    (
-        NetworkTopology,
-        SubnetFeatures,
-        ResourceLimits,
-        RegistryExecutionSettings,
-        NodePublicKeys,
-    ),
-    ReadRegistryError,
-> {
+) -> Result<(NetworkTopology, OwnSubnetInfo, RegistryExecutionSettings), ReadRegistryError> {
     let (batch_processor, _, _, _) = make_batch_processor(registry.clone(), log);
     batch_processor.try_to_read_registry(registry.get_latest_version(), own_subnet_id)
 }
@@ -885,15 +872,14 @@ fn try_read_registry_succeeds_with_fully_specified_registry_records() {
         // Reading from the registry must succeed for fully specified records.
         let (batch_processor, metrics, state_manager, registry_settings) =
             make_batch_processor(fixture.registry.clone(), log);
-        let (
-            network_topology,
-            own_subnet_features,
-            own_resource_limits,
-            registry_execution_settings,
-            node_public_keys,
-        ) = batch_processor
+        let (network_topology, own_subnet_info, registry_execution_settings) = batch_processor
             .try_to_read_registry(fixture.registry.get_latest_version(), own_subnet_id)
             .unwrap();
+        let OwnSubnetInfo {
+            subnet_features: own_subnet_features,
+            resource_limits: own_resource_limits,
+            node_public_keys,
+        } = own_subnet_info;
 
         // Full specification includes the subnet size of `own_subnet_id`. Check the corresponding
         // critical error counter is untouched.
@@ -1028,7 +1014,7 @@ fn try_read_registry_succeeds_with_fully_specified_registry_records() {
         );
         assert_ne!(
             own_subnet_features,
-            latest_state.metadata.own_subnet_features
+            latest_state.metadata.own_subnet_info.subnet_features
         );
         assert_ne!(
             *registry_settings.lock().unwrap(),
@@ -1054,23 +1040,14 @@ fn try_read_registry_succeeds_with_fully_specified_registry_records() {
             &network_topology,
             latest_state.metadata.network_topology.as_ref()
         );
+        assert_eq!(own_subnet_features, latest_state.subnet_features());
+        assert_eq!(own_resource_limits, latest_state.resource_limits());
         assert_eq!(
-            own_subnet_features,
-            latest_state.metadata.own_subnet_features
-        );
-        assert_eq!(
-            own_resource_limits,
-            latest_state.metadata.own_resource_limits
-        );
-        assert_eq!(
-            latest_state.metadata.own_resource_limits.maximum_state_size,
+            latest_state.resource_limits().maximum_state_size,
             Some(own_maximum_state_size)
         );
         assert_eq!(
-            latest_state
-                .metadata
-                .own_resource_limits
-                .maximum_state_delta,
+            latest_state.resource_limits().maximum_state_delta,
             Some(own_maximum_state_delta)
         );
         assert_eq!(
@@ -1125,7 +1102,7 @@ fn try_read_registry_succeeds_with_minimal_registry_records() {
         // critical error for `subnet_size` has incremented.
         assert_eq!(metrics.critical_error_missing_subnet_size.get(), 1);
         // Check the subnet size was set to the maximum for a small app subnet.
-        let (_, _, _, registry_execution_settings, _) = result.unwrap();
+        let (_, _, registry_execution_settings) = result.unwrap();
         assert_eq!(
             registry_execution_settings.subnet_size,
             SMALL_APP_SUBNET_MAX_SIZE
@@ -1450,7 +1427,8 @@ fn try_read_registry_can_skip_missing_or_invalid_node_public_keys() {
             2
         );
 
-        let (_, _, _, _, node_public_keys) = res.unwrap();
+        let (_, own_subnet_info, _) = res.unwrap();
+        let node_public_keys = &own_subnet_info.node_public_keys;
         assert_eq!(node_public_keys.len(), 1);
         assert!(!node_public_keys.contains_key(&node_test_id(1)));
         assert!(!node_public_keys.contains_key(&node_test_id(2)));
@@ -1589,7 +1567,7 @@ fn try_read_registry_can_skip_missing_or_invalid_fields_of_api_boundary_nodes()
 
         // There are six API BNs in the registry. However, five nodes have missing or invalid fields of NodeRecord.
         // Hence, only one nodes are retrieved.
-        let (network_topology, _, _, _, _) = res.unwrap();
+        let (network_topology, _, _) = res.unwrap();
         let api_boundary_nodes = &network_topology.api_boundary_nodes;
         assert_eq!(api_boundary_nodes.len(), 1);
         assert!(api_boundary_nodes.contains_key(&node_test_id(11)));

rs/messaging/src/state_machine.rs

@@ -1,6 +1,4 @@
-use crate::message_routing::{
-    CRITICAL_ERROR_INDUCT_RESPONSE_FAILED, MessageRoutingMetrics, NodePublicKeys,
-};
+use crate::message_routing::{CRITICAL_ERROR_INDUCT_RESPONSE_FAILED, MessageRoutingMetrics};
 use crate::routing::demux::Demux;
 use crate::routing::stream_builder::{
     StreamBuilder, generate_reject_responses_for_deleted_subnets,
@@ -12,9 +10,7 @@ use ic_interfaces::execution_environment::{
 use ic_interfaces::time_source::system_time_now;
 use ic_logger::{ReplicaLogger, error, fatal};
 use ic_query_stats::deliver_query_stats;
-use ic_registry_resource_limits::ResourceLimits;
-use ic_registry_subnet_features::SubnetFeatures;
-use ic_replicated_state::{NetworkTopology, ReplicatedState};
+use ic_replicated_state::{NetworkTopology, OwnSubnetInfo, ReplicatedState};
 use ic_types::batch::{Batch, BatchContent};
 use ic_types::{ExecutionRound, NumBytes, SubnetId};
 use std::sync::Arc;
@@ -33,12 +29,10 @@ pub(crate) trait StateMachine: Send {
     fn execute_round(
         &self,
         state: ReplicatedState,
-        network_topology: NetworkTopology,
         batch: Batch,
-        subnet_features: SubnetFeatures,
-        resource_limits: ResourceLimits,
+        network_topology: NetworkTopology,
+        own_subnet_info: OwnSubnetInfo,
         registry_settings: &RegistryExecutionSettings,
-        node_public_keys: NodePublicKeys,
     ) -> ReplicatedState;
 }
 pub(crate) struct StateMachineImpl {
@@ -106,12 +100,10 @@ impl StateMachine for StateMachineImpl {
     fn execute_round(
         &self,
         mut state: ReplicatedState,
-        network_topology: NetworkTopology,
         batch: Batch,
-        subnet_features: SubnetFeatures,
-        resource_limits: ResourceLimits,
+        network_topology: NetworkTopology,
+        own_subnet_info: OwnSubnetInfo,
         registry_settings: &RegistryExecutionSettings,
-        node_public_keys: NodePublicKeys,
     ) -> ReplicatedState {
         let time_out_messages_timer = self.metrics.start_phase_timer(PHASE_TIME_OUT_MESSAGES);
 
@@ -128,9 +120,7 @@ impl StateMachine for StateMachineImpl {
         }
 
         state.metadata.network_topology = Arc::new(network_topology);
-        state.metadata.own_subnet_features = subnet_features;
-        state.metadata.own_resource_limits = resource_limits;
-        state.metadata.node_public_keys = node_public_keys;
+        state.metadata.own_subnet_info = Arc::new(own_subnet_info);
         if let Err(message) = state.metadata.init_allocation_ranges_if_empty() {
             self.metrics
                 .observe_no_canister_allocation_range(&self.log, message);