sled-agent: begin incorporating Cosmo support

Extend the existing `Baseboard` type to incorporate Cosmo, and introduce
a new `OxideSled` enum to represent different Oxide sled types so that
a) we can differentiate between different kinds of sled, and b)
parameterize omicron code with constant data specific to a sled type.

Also, identify places where we call the `is_gimlet` method, and instead
call that, `is_oxide_sled` (none of these are actually specific to
Gimlets in particular).

Find places where we use symbolic constants named `Gimlet` that should
be `Sled`; if these bleed into config files, set up Serde aliases to
accommodate a change.

Make it is that, if we set `skip_timesync` in a config file, we
propagate that to RSS config as well.

With these changes, we have successfully used the `gimlet-standalone`
to boot the control plane on a Cosmo.  (Yes, the config name is
somewhat ironic, and should be addressed at some point.)

Author: dancrossnyc

clients/bootstrap-agent-client/src/lib.rs

@@ -44,6 +44,11 @@ impl From<types::Baseboard> for sled_hardware_types::Baseboard {
                     identifier, model, revision,
                 )
             }
+            types::Baseboard::Cosmo { identifier, model, revision } => {
+                sled_hardware_types::Baseboard::new_cosmo(
+                    identifier, model, revision,
+                )
+            }
             types::Baseboard::Unknown => {
                 sled_hardware_types::Baseboard::unknown()
             }
@@ -62,6 +67,11 @@ impl From<sled_hardware_types::Baseboard> for types::Baseboard {
                 model,
                 revision,
             } => types::Baseboard::Gimlet { identifier, model, revision },
+            sled_hardware_types::Baseboard::Cosmo {
+                identifier,
+                model,
+                revision,
+            } => types::Baseboard::Cosmo { identifier, model, revision },
             sled_hardware_types::Baseboard::Unknown => {
                 types::Baseboard::Unknown
             }

installinator/src/hardware.rs

@@ -21,9 +21,9 @@ pub struct Hardware {
 
 impl Hardware {
     pub async fn scan(log: &Logger) -> Result<Self> {
-        let is_gimlet = sled_hardware::is_gimlet()
-            .context("failed to detect whether host is a gimlet")?;
-        ensure!(is_gimlet, "hardware scan only supported on gimlets");
+        let is_oxide_sled = sled_hardware::is_oxide_sled()
+            .context("failed to detect whether host is an oxide sled")?;
+        ensure!(is_oxide_sled, "hardware scan only supported on oxide sleds");
 
         let hardware = HardwareManager::new(log, SledMode::Auto, vec![])
             .map_err(|err| {
@@ -34,7 +34,7 @@ impl Hardware {
             hardware.disks().into_values().map(|disk| disk.into()).collect();
 
         info!(
-            log, "found gimlet hardware";
+            log, "found oxide sled hardware";
             "baseboard" => ?hardware.baseboard(),
             "is_scrimlet" => hardware.is_scrimlet(),
             "num_disks" => disks.len(),

nexus/inventory/src/builder.rs

@@ -627,7 +627,8 @@ impl CollectionBuilder {
 
         let baseboard_id = match inventory.baseboard {
             Baseboard::Pc { .. } => None,
-            Baseboard::Gimlet { identifier, model, revision: _ } => {
+            Baseboard::Gimlet { identifier, model, .. }
+            | Baseboard::Cosmo { identifier, model, .. } => {
                 Some(Self::normalize_item(
                     &mut self.baseboards,
                     BaseboardId {

openapi/bootstrap-agent.json

@@ -209,7 +209,7 @@
         "pattern": "^[a-zA-Z0-9._+-]{1,63}$"
       },
       "Baseboard": {
-        "description": "Describes properties that should uniquely identify a Gimlet.",
+        "description": "Describes properties that should uniquely identify a Sled.",
         "oneOf": [
           {
             "type": "object",
@@ -239,6 +239,34 @@
               "type"
             ]
           },
+          {
+            "type": "object",
+            "properties": {
+              "identifier": {
+                "type": "string"
+              },
+              "model": {
+                "type": "string"
+              },
+              "revision": {
+                "type": "integer",
+                "format": "uint32",
+                "minimum": 0
+              },
+              "type": {
+                "type": "string",
+                "enum": [
+                  "cosmo"
+                ]
+              }
+            },
+            "required": [
+              "identifier",
+              "model",
+              "revision",
+              "type"
+            ]
+          },
           {
             "type": "object",
             "properties": {

sled-agent/src/bin/sled-agent.rs

@@ -61,10 +61,13 @@ async fn do_run() -> Result<(), CmdError> {
                 rss_config_path
             };
             let rss_config = if rss_config_path.exists() {
-                Some(
+                let mut rss_config =
                     RackInitializeRequest::from_file(rss_config_path)
-                        .map_err(|e| CmdError::Failure(anyhow!(e)))?,
-                )
+                        .map_err(|e| CmdError::Failure(anyhow!(e)))?;
+                if rss_config.skip_timesync.is_none() {
+                    rss_config.skip_timesync = config.skip_timesync;
+                }
+                Some(rss_config)
             } else {
                 None
             };

sled-agent/src/bootstrap/pre_server.rs

@@ -303,7 +303,7 @@ fn sled_mode_from_config(config: &Config) -> Result<SledMode, StartError> {
             }
             SledMode::Auto
         }
-        SledModeConfig::Gimlet => SledMode::Gimlet,
+        SledModeConfig::Sled => SledMode::Sled,
         SledModeConfig::Scrimlet => {
             let asic = if cfg!(feature = "switch-asic") {
                 DendriteAsic::TofinoAsic

sled-agent/src/config.rs

@@ -15,14 +15,15 @@ use illumos_utils::dladm::PhysicalLink;
 use omicron_common::vlan::VlanID;
 use serde::Deserialize;
 use sled_hardware::UnparsedDisk;
-use sled_hardware::is_gimlet;
+use sled_hardware::is_oxide_sled;
 use sprockets_tls::keys::SprocketsConfig;
 
 #[derive(Clone, Debug, Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum SledMode {
     Auto,
-    Gimlet,
+    #[serde(alias = "gimlet")]
+    Sled,
     Scrimlet,
 }
 
@@ -137,7 +138,7 @@ pub enum ConfigError {
     },
     #[error("Loading certificate: {0}")]
     Certificate(#[source] anyhow::Error),
-    #[error("Could not determine if host is a Gimlet: {0}")]
+    #[error("Could not determine if host is an Oxide sled: {0}")]
     SystemDetection(#[source] anyhow::Error),
     #[error("Could not enumerate physical links")]
     FindLinks(#[from] FindPhysicalLinkError),
@@ -158,7 +159,7 @@ impl Config {
         if let Some(link) = self.data_link.as_ref() {
             Ok(link.clone())
         } else {
-            if is_gimlet().map_err(ConfigError::SystemDetection)? {
+            if is_oxide_sled().map_err(ConfigError::SystemDetection)? {
                 Dladm::list_physical()
                     .await
                     .map_err(ConfigError::FindLinks)?

sled-agent/src/rack_setup/plan/service.rs

@@ -1259,6 +1259,7 @@ mod tests {
                 bfd: Vec::new(),
             },
             allowed_source_ips: AllowedSourceIps::Any,
+            skip_timesync: Some(false),
         }
     }
 

sled-agent/src/rack_setup/service.rs

@@ -1384,24 +1384,28 @@ impl ServiceInner {
             })
             .collect();
 
-        let ntp_clients = ntp_addresses
-            .into_iter()
-            .map(|address| {
-                let dur = std::time::Duration::from_secs(60);
-                let client = reqwest::ClientBuilder::new()
-                    .connect_timeout(dur)
-                    .timeout(dur)
-                    .build()
-                    .map_err(SetupServiceError::HttpClient)?;
-                let client = NtpAdminClient::new_with_client(
-                    &format!("http://{}", address),
-                    client,
-                    self.log.new(o!("NtpAdminClient" => address.to_string())),
-                );
-                Ok(client)
-            })
-            .collect::<Result<Vec<_>, SetupServiceError>>()?;
-        self.wait_for_timesync(&ntp_clients).await?;
+        let skip_timesync = config.skip_timesync.unwrap_or(false);
+        if !skip_timesync {
+            let ntp_clients = ntp_addresses
+                .into_iter()
+                .map(|address| {
+                    let dur = std::time::Duration::from_secs(60);
+                    let client = reqwest::ClientBuilder::new()
+                        .connect_timeout(dur)
+                        .timeout(dur)
+                        .build()
+                        .map_err(SetupServiceError::HttpClient)?;
+                    let client = NtpAdminClient::new_with_client(
+                        &format!("http://{}", address),
+                        client,
+                        self.log
+                            .new(o!("NtpAdminClient" => address.to_string())),
+                    );
+                    Ok(client)
+                })
+                .collect::<Result<Vec<_>, SetupServiceError>>()?;
+            self.wait_for_timesync(&ntp_clients).await?;
+        }
 
         info!(self.log, "Finished setting up Internal DNS and NTP");
 

sled-agent/src/services.rs

@@ -99,7 +99,7 @@ use sled_agent_types::zone_images::{
 use sled_agent_zone_images::{ZoneImageSourceResolver, ramdisk_file_source};
 use sled_hardware::DendriteAsic;
 use sled_hardware::SledMode;
-use sled_hardware::is_gimlet;
+use sled_hardware::is_oxide_sled;
 use sled_hardware::underlay;
 use sled_hardware_types::Baseboard;
 use slog::Logger;
@@ -942,7 +942,7 @@ impl ServiceManager {
     ) -> Result<Vec<(Link, bool)>, Error> {
         let mut links: Vec<(Link, bool)> = Vec::new();
 
-        let is_gimlet = is_gimlet().map_err(|e| {
+        let is_oxide_sled = is_oxide_sled().map_err(|e| {
             Error::Underlay(underlay::Error::SystemDetection(e))
         })?;
 
@@ -965,7 +965,7 @@ impl ServiceManager {
                             links.push((link, false));
                         }
                         Err(_) => {
-                            if is_gimlet {
+                            if is_oxide_sled {
                                 return Err(Error::MissingDevice {
                                     device: pkt_source.to_string(),
                                 });
@@ -2773,11 +2773,11 @@ impl ServiceManager {
                         );
                     }
 
-                    let is_gimlet = is_gimlet().map_err(|e| {
+                    let is_oxide_sled = is_oxide_sled().map_err(|e| {
                         Error::Underlay(underlay::Error::SystemDetection(e))
                     })?;
 
-                    if is_gimlet {
+                    if is_oxide_sled {
                         // Collect the prefixes for each techport.
                         let nameaddr = bootstrap_name_and_address.as_ref();
                         let techport_prefixes = match nameaddr {
@@ -2806,7 +2806,7 @@ impl ServiceManager {
                         }
                     };
 
-                    if is_gimlet
+                    if is_oxide_sled
                         || asic == &DendriteAsic::SoftNpuPropolisDevice
                         || asic == &DendriteAsic::TofinoAsic
                     {
@@ -2842,6 +2842,7 @@ impl ServiceManager {
 
                     match baseboard {
                         Baseboard::Gimlet { identifier, model, .. }
+                        | Baseboard::Cosmo { identifier, model, .. }
                         | Baseboard::Pc { identifier, model, .. } => {
                             lldpd_config = lldpd_config
                                 .add_property(
@@ -2974,11 +2975,12 @@ impl ServiceManager {
                         }
                     }
 
-                    let is_gimlet = is_gimlet().map_err(|e| {
+                    let is_oxide_sled = is_oxide_sled().map_err(|e| {
                         Error::Underlay(underlay::Error::SystemDetection(e))
                     })?;
 
-                    let maghemite_interfaces: Vec<AddrObject> = if is_gimlet {
+                    let maghemite_interfaces: Vec<AddrObject> = if is_oxide_sled
+                    {
                         (0..32)
                             .map(|i| {
                                 // See the `tfport_name` function
@@ -3022,7 +3024,7 @@ impl ServiceManager {
                         );
                     }
 
-                    if is_gimlet {
+                    if is_oxide_sled {
                         mg_ddm_config = mg_ddm_config
                             .add_property("dpd_host", "astring", "[::1]")
                             .add_property(
@@ -3161,7 +3163,7 @@ impl ServiceManager {
         let services = match self.inner.sled_mode {
             // A pure gimlet sled should not be trying to activate a switch
             // zone.
-            SledMode::Gimlet => {
+            SledMode::Sled => {
                 return Err(Error::SwitchZone(anyhow::anyhow!(
                     "attempted to activate switch zone on non-scrimlet sled"
                 )));