Skip to content

sim-sled-agent: internally store a unified OmicronSledConfig (PR 1/4) #10880

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
jgallagher merged 1 commit into from
Jul 22, 2026
Merged

sim-sled-agent: internally store a unified OmicronSledConfig (PR 1/4) #10880

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
51 changes: 5 additions & 46 deletions nexus/reconfigurator/execution/src/omicron_sled_config.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -102,15 +102,12 @@ mod tests {
use omicron_common::api::external::Generation;
use omicron_common::api::internal::shared::DatasetKind;
use omicron_common::disk::CompressionAlgorithm;
use omicron_common::disk::DatasetsConfig;
use omicron_common::disk::DiskIdentity;
use omicron_common::disk::OmicronPhysicalDisksConfig;
use omicron_common::zpool_name::ZpoolName;
use omicron_uuid_kinds::DatasetUuid;
use omicron_uuid_kinds::OmicronZoneUuid;
use omicron_uuid_kinds::PhysicalDiskUuid;
use omicron_uuid_kinds::ZpoolUuid;
use sled_agent_types::inventory::OmicronZonesConfig;
use sled_agent_types::inventory::SledRole;
use std::net::Ipv6Addr;
use std::net::SocketAddr;
Expand All @@ -133,8 +130,9 @@ mod tests {
_ => panic!("Unexpected address type for sled agent (wanted IPv6)"),
};
let sim_sled_agent = &cptestctx.sled_agents[0].sled_agent();
let sim_sled_agent_config_generation =
sim_sled_agent.omicron_zones_list().generation;
let sim_sled_agent_config_generation = sim_sled_agent
.omicron_sled_config()
.map_or(Generation::new(), |config| config.generation);

let sleds_by_id = id_ord_map! {
Sled::new(
Expand Down Expand Up @@ -284,48 +282,9 @@ mod tests {

// Observe the latest configuration stored on the simulated sled agent,
// and verify that this output matches the input.
//
// TODO-cleanup Simulated sled-agent should report a unified
// `OmicronSledConfig`.
let observed_disks =
sim_sled_agent.omicron_physical_disks_list().unwrap();
let observed_datasets = sim_sled_agent.datasets_config_list().unwrap();
let observed_zones = sim_sled_agent.omicron_zones_list();

let observed_config = sim_sled_agent.omicron_sled_config().unwrap();
let in_service_config =
sled_config.clone().into_in_service_sled_config();
assert_eq!(
observed_disks,
OmicronPhysicalDisksConfig {
generation: in_service_config.generation,
disks: in_service_config.disks.into_iter().collect(),
}
);
assert_eq!(
observed_datasets,
DatasetsConfig {
generation: in_service_config.generation,
datasets: in_service_config
.datasets
.into_iter()
.map(|d| (d.id, d))
.collect(),
}
);
assert_eq!(
observed_zones,
OmicronZonesConfig {
generation: in_service_config.generation,
zones: in_service_config.zones.into_iter().collect(),
}
);

// We expect to see each single in-service item we supplied as input.
assert_eq!(observed_disks.disks.len(), 1);
assert_eq!(observed_disks.disks[0].id, disk_id);
assert_eq!(observed_datasets.datasets.len(), 1);
assert!(observed_datasets.datasets.contains_key(&dataset_id));
assert_eq!(observed_zones.zones.len(), 1);
assert_eq!(observed_zones.zones[0].id, zone_id);
assert_eq!(observed_config, in_service_config);
}
}
12 changes: 7 additions & 5 deletions nexus/src/app/background/tasks/support_bundle_collector.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -726,6 +726,7 @@ mod test {
use nexus_types::inventory::SpType;
use nexus_types::support_bundle::BundleDataSelection;
use omicron_common::api::external::ByteCount;
use omicron_common::api::external::Generation;
use omicron_common::api::internal::shared::DatasetKind;
use omicron_common::disk::DatasetConfig;
use omicron_common::disk::DatasetName;
Expand Down Expand Up @@ -1060,11 +1061,12 @@ mod test {
})
.collect();

// Read current sled config generation from zones (this will change
// slightly once the simulator knows how to keep the unified config
// and be a little less weird)
let current_generation =
cptestctx.first_sled_agent().omicron_zones_list().generation;
// Read current config generation (this will change slightly once
// the simulator stops exposing operations on just datasets)
let current_generation = cptestctx
.first_sled_agent()
.omicron_sled_config()
.map_or(Generation::new(), |config| config.generation);

let dataset_config = DatasetsConfig {
generation: current_generation.next(),
Expand Down
100 changes: 26 additions & 74 deletions sled-agent/src/sim/sled_agent.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -35,7 +35,7 @@ use omicron_common::api::internal::shared::{
};
use omicron_common::disk::{
DatasetsConfig, DatasetsManagementResult, DiskIdentity, DiskVariant,
DisksManagementResult, OmicronPhysicalDisksConfig,
OmicronPhysicalDisksConfig,
};
use omicron_uuid_kinds::{
DatasetUuid, GenericUuid, PhysicalDiskUuid, PropolisUuid, SledUuid,
Expand Down Expand Up @@ -63,10 +63,9 @@ use sled_agent_types::instance::{
};
use sled_agent_types::inventory::{
ConfigReconcilerInventory, ConfigReconcilerInventoryResult,
ConfigReconcilerInventoryStatus, FmdInventory, HostPhase2DesiredSlots,
Inventory, InventoryDataset, InventoryDisk, InventoryZpool,
OmicronFileSourceResolverInventory, OmicronSledConfig, OmicronZonesConfig,
SingleMeasurementInventory, SledRole, ZpoolHealth,
ConfigReconcilerInventoryStatus, FmdInventory, Inventory, InventoryDataset,
InventoryDisk, InventoryZpool, OmicronFileSourceResolverInventory,
OmicronSledConfig, SingleMeasurementInventory, SledRole, ZpoolHealth,
};
use sled_agent_types::support_bundle::SupportBundleMetadata;
use sled_agent_types::system_networking::SystemNetworkingConfig;
Expand Down Expand Up @@ -112,7 +111,6 @@ pub struct SledAgent {
Mutex<HashMap<PropolisUuid, HashSet<InstanceMulticastMembership>>>,
pub vpc_routes: Mutex<HashMap<RouterId, RouteSet>>,
config: Config,
fake_zones: Mutex<OmicronZonesConfig>,
instance_ensure_state_error: Mutex<Option<Error>>,
/// Number of remaining local storage operation failures to inject.
/// When > 0, local storage ensure/delete operations decrement this
Expand Down Expand Up @@ -202,10 +200,6 @@ impl SledAgent {
vpc_routes: Mutex::new(HashMap::new()),
mock_propolis: futures::lock::Mutex::new(None),
config: config.clone(),
fake_zones: Mutex::new(OmicronZonesConfig {
generation: Generation::new(),
zones: vec![],
}),
instance_ensure_state_error: Mutex::new(None),
local_storage_error_count: AtomicU32::new(0),
repo_depot,
Expand Down Expand Up @@ -893,24 +887,10 @@ impl SledAgent {

let storage = self.storage.lock();

let disks_config =
storage.omicron_physical_disks_list().unwrap_or_default();
let datasets_config =
storage.datasets_config_list().unwrap_or_default();
let zones_config = self.fake_zones.lock().unwrap().clone();
let maybe_sled_config = storage.omicron_sled_config();
let smf_services_enabled_not_online =
self.health_monitor.to_inventory();

let sled_config = OmicronSledConfig {
generation: zones_config.generation,
disks: disks_config.disks.into_iter().collect(),
datasets: datasets_config.datasets.into_values().collect(),
zones: zones_config.zones.into_iter().collect(),
remove_mupdate_override: None,
host_phase_2: HostPhase2DesiredSlots::current_contents(),
measurements: Default::default(),
};

let reference_measurements = vec![
SingleMeasurementInventory {
path: "this/is/fake1".into(),
Expand Down Expand Up @@ -971,32 +951,31 @@ impl SledAgent {
// to lie here, but this information should be taken with a
// particularly careful grain-of-salt -- it's supposed to
// represent the "real" datasets the sled agent can observe.
datasets: storage
.datasets_config_list()
.map(|config| {
config
datasets: maybe_sled_config.as_ref().map_or(
Vec::new(),
|sled_config| {
sled_config
.datasets
.into_iter()
.map(|(id, config)| InventoryDataset {
id: Some(id),
.iter()
.map(|config| InventoryDataset {
id: Some(config.id),
name: config.name.full_name(),
available: ByteCount::from_kibibytes_u32(0),
used: ByteCount::from_kibibytes_u32(0),
quota: config.inner.quota,
reservation: config.inner.reservation,
compression: config.inner.compression.to_string(),
})
.collect::<Vec<_>>()
})
.unwrap_or_else(|_| vec![]),
ledgered_sled_config: Some(sled_config.clone()),
.collect()
},
),
ledgered_sled_config: maybe_sled_config.clone(),
reconciler_status: ConfigReconcilerInventoryStatus::Idle {
completed_at: Utc::now() - Duration::from_secs(10),
ran_for: Duration::from_secs(3),
},
last_reconciliation: Some(
ConfigReconcilerInventory::debug_assume_success(sled_config),
),
last_reconciliation: maybe_sled_config
.map(ConfigReconcilerInventory::debug_assume_success),
// TODO: simulate the file source resolver with greater fidelity
file_source_resolver: OmicronFileSourceResolverInventory::new_fake(
),
Expand Down Expand Up @@ -1120,47 +1099,20 @@ impl SledAgent {
self.storage.lock().omicron_physical_disks_list()
}

pub fn omicron_physical_disks_ensure(
&self,
config: OmicronPhysicalDisksConfig,
) -> Result<DisksManagementResult, HttpError> {
self.storage.lock().omicron_physical_disks_ensure(config)
}

pub fn set_omicron_config(
&self,
config: OmicronSledConfig,
) -> Result<(), HttpError> {
// TODO Update the simulator to work on `OmicronSledConfig` instead of
// the three separate legacy configs
let disks_config = OmicronPhysicalDisksConfig {
generation: config.generation,
disks: config.disks.into_iter().collect(),
};
let datasets_config = DatasetsConfig {
generation: config.generation,
datasets: config.datasets.into_iter().map(|d| (d.id, d)).collect(),
};
let zones_config = OmicronZonesConfig {
generation: config.generation,
zones: config.zones.into_iter().collect(),
};

let mut storage = self.storage.lock();
let _ = storage.omicron_physical_disks_ensure(disks_config)?;
let _ = storage.datasets_ensure(datasets_config)?;
*self.fake_zones.lock().unwrap() = zones_config;
//*self.sled_config.lock().unwrap() = Some(config);

Ok(())
}

pub fn omicron_zones_list(&self) -> OmicronZonesConfig {
self.fake_zones.lock().unwrap().clone()
// It's a little weird that `self.storage` holds the full
// `OmicronSledConfig` (including zones); this is largely an artifact of
// history (when sim-sled-agent was originally written, we had separate
// zone / storage configs; after unifying them, it was simplest to keep
// the full config inside the sim storage system).
self.storage.lock().set_omicron_config(config)
}

pub fn omicron_zones_ensure(&self, requested_zones: OmicronZonesConfig) {
*self.fake_zones.lock().unwrap() = requested_zones;
pub fn omicron_sled_config(&self) -> Option<OmicronSledConfig> {
self.storage.lock().omicron_sled_config()
}

pub fn drop_dataset(&self, zpool_id: ZpoolUuid, dataset_id: DatasetUuid) {
Expand Down
Loading
Loading