Merge branch 'main' into dap/sp-planning-real

Author: davepacheco

Cargo.lock

@@ -424,7 +424,7 @@ ereport-types = { path = "ereport/types" }
 expectorate = "1.2.0"
 fatfs = "0.3.6"
 filetime = "0.2.25"
-flate2 = "1.1.1"
+flate2 = "1.1.2"
 float-ord = "0.3.2"
 flume = "0.11.1"
 foreign-types = "0.3.2"
@@ -473,7 +473,7 @@ hyper = "1.6.0"
 hyper-util = "0.1.11"
 hyper-rustls = "0.26.0"
 hyper-staticfile = "0.10.1"
-iddqd = { version = "0.3.6", features = ["daft", "serde"] }
+iddqd = { version = "0.3.6", features = ["daft", "serde", "schemars08"] }
 id-map = { path = "id-map" }
 illumos-utils = { path = "illumos-utils" }
 iana-time-zone = "0.1.63"

Cargo.toml

@@ -59,8 +59,10 @@ tufaceous-artifact.workspace = true
 camino-tempfile.workspace = true
 expectorate.workspace = true
 libc.workspace = true
+proptest.workspace = true
 regress.workspace = true
 serde_urlencoded.workspace = true
+test-strategy.workspace = true
 tokio = { workspace = true, features = ["test-util"] }
 toml.workspace = true
 

common/Cargo.toml

@@ -920,7 +920,7 @@ pub struct ExternalIpGatewayMap {
 #[derive(
     Debug, Clone, PartialEq, Eq, Ord, PartialOrd, Hash, EnumCount, Diffable,
 )]
-#[cfg_attr(feature = "testing", derive(test_strategy::Arbitrary))]
+#[cfg_attr(any(test, feature = "testing"), derive(test_strategy::Arbitrary))]
 pub enum DatasetKind {
     // Durable datasets for zones
     Cockroach,
@@ -942,8 +942,6 @@ pub enum DatasetKind {
 
     // Other datasets
     Debug,
-    // Stores update artifacts (the "TUF Repo Depot")
-    Update,
 }
 
 impl Serialize for DatasetKind {
@@ -1004,7 +1002,7 @@ impl DatasetKind {
         match self {
             Cockroach | Crucible | Clickhouse | ClickhouseKeeper
             | ClickhouseServer | ExternalDns | InternalDns => true,
-            TransientZoneRoot | TransientZone { .. } | Debug | Update => false,
+            TransientZoneRoot | TransientZone { .. } | Debug => false,
         }
     }
 
@@ -1042,7 +1040,6 @@ impl fmt::Display for DatasetKind {
                 return Ok(());
             }
             Debug => "debug",
-            Update => "update",
         };
         write!(f, "{}", s)
     }
@@ -1069,7 +1066,6 @@ impl FromStr for DatasetKind {
             "internal_dns" => InternalDns,
             "zone" => TransientZoneRoot,
             "debug" => Debug,
-            "update" => Update,
             other => {
                 if let Some(name) = other.strip_prefix("zone/") {
                     TransientZone { name: name.to_string() }
@@ -1165,7 +1161,6 @@ mod tests {
             DatasetKind::TransientZoneRoot,
             DatasetKind::TransientZone { name: String::from("myzone") },
             DatasetKind::Debug,
-            DatasetKind::Update,
         ];
 
         assert_eq!(kinds.len(), DatasetKind::COUNT);

common/src/api/internal/shared.rs

@@ -17,6 +17,7 @@ use std::collections::BTreeMap;
 use std::fmt;
 use std::str::FromStr;
 
+use crate::api::internal::shared::DatasetKindParseError;
 use crate::{
     api::external::{ByteCount, Generation},
     ledger::Ledgerable,
@@ -172,6 +173,69 @@ impl DatasetName {
     }
 }
 
+#[derive(Debug, thiserror::Error)]
+pub enum DatasetNameParseError {
+    #[error("missing '/' separator in dataset name {0}")]
+    MissingSlash(String),
+    #[error("could not parse zpool name {zpool}: {err}")]
+    ParseZpoolName { zpool: String, err: String },
+    #[error("could not parse dataset kind {kind}")]
+    ParseDatasetKind {
+        kind: String,
+        #[source]
+        err: DatasetKindParseError,
+    },
+    #[error("expected `crypt/` for kind {kind:?} in dataset name {name}")]
+    MissingCryptInName { kind: DatasetKind, name: String },
+    #[error("unexpected `crypt/` for kind {kind:?} in dataset name {name}")]
+    UnexpectedCryptInName { kind: DatasetKind, name: String },
+}
+
+impl FromStr for DatasetName {
+    type Err = DatasetNameParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let (pool_name, remainder) = s.split_once('/').ok_or_else(|| {
+            DatasetNameParseError::MissingSlash(s.to_string())
+        })?;
+
+        let pool_name = ZpoolName::from_str(pool_name).map_err(|err| {
+            DatasetNameParseError::ParseZpoolName {
+                zpool: pool_name.to_string(),
+                err,
+            }
+        })?;
+
+        let (kind_str, name_has_crypt) =
+            if let Some(remainder) = remainder.strip_prefix("crypt/") {
+                (remainder, true)
+            } else {
+                (remainder, false)
+            };
+
+        let kind = DatasetKind::from_str(kind_str).map_err(|err| {
+            DatasetNameParseError::ParseDatasetKind {
+                kind: kind_str.to_string(),
+                err,
+            }
+        })?;
+
+        match (kind.dataset_should_be_encrypted(), name_has_crypt) {
+            (true, true) | (false, false) => Ok(Self { pool_name, kind }),
+            (true, false) => Err(DatasetNameParseError::MissingCryptInName {
+                kind,
+                name: s.to_string(),
+            }),
+            (false, true) => {
+                Err(DatasetNameParseError::UnexpectedCryptInName {
+                    kind,
+                    name: s.to_string(),
+                })
+            }
+        }
+    }
+}
+
 #[derive(
     Copy,
     Clone,
@@ -583,3 +647,24 @@ impl TryFrom<i64> for M2Slot {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use test_strategy::proptest;
+
+    #[proptest]
+    fn parse_dataset_name(pool_id: [u8; 16], kind: DatasetKind) {
+        let pool_id = ZpoolUuid::from_bytes(pool_id);
+        for pool in
+            [ZpoolName::new_internal(pool_id), ZpoolName::new_external(pool_id)]
+        {
+            let dataset_name = DatasetName::new(pool, kind.clone());
+            let s = dataset_name.full_name();
+            match DatasetName::from_str(&s) {
+                Ok(d) => assert_eq!(d, dataset_name),
+                Err(err) => panic!("failed to parse dataset name {s}: {err}"),
+            }
+        }
+    }
+}

common/src/disk.rs

@@ -95,7 +95,7 @@ Crucible Pantry
 The `servers` and `deployment-units` commands accept a `--dot` argument to print output in a format that `dot(1)` can process:
 
 ```
-$ cargo xtask ls-apis deployment-units --dot > deployment-units.dot
+$ cargo xtask ls-apis deployment-units --output-format dot > deployment-units.dot
 ```
 
 You can generate a PNG image of the graph like this:

dev-tools/ls-apis/README.adoc

@@ -149,6 +149,13 @@ packages = [ "oximeter-collector" ]
 #              tooling supports this value so that during development you can
 #              relax these constraints.
 #
+# "server" and "client" versioning is elaborated on more in RFD 532.  Note that
+# "lockstep" collapses into "server" here, as it's trivially the case that if
+# the server and client(s) are updated atomically the server does not have to
+# support older clients.  Additionally, the "updated before" relationship is
+# discussed some in RFD 565, [Update
+# sequence](https://rfd.shared.oxide.computer/rfd/0565#_update_sequence).
+#
 # [`versioned_how_reason`]: free text string explaining why `versioned_how` must
 # be "client" for this API.  This is printed in documentation and command output
 # and serves as documentation for developers to understand why we made this

dev-tools/ls-apis/api-manifest.toml

@@ -31,6 +31,7 @@ gateway-test-utils.workspace = true
 gateway-types.workspace = true
 http.workspace = true
 humantime.workspace = true
+iddqd.workspace = true
 internal-dns-resolver.workspace = true
 internal-dns-types.workspace = true
 itertools.workspace = true