Fail if there isn't available space for a disk

common/src/sql/dbinit.sql

@@ -183,6 +183,11 @@ CREATE INDEX on omicron.public.Dataset (
     size_used
 ) WHERE size_used IS NOT NULL AND time_deleted IS NULL AND kind = 'crucible';
 
+/* Create an index on the size usage for any dataset */
+CREATE INDEX on omicron.public.Dataset (
+    size_used
+) WHERE size_used IS NOT NULL AND time_deleted IS NULL;
+
 /*
  * A region of space allocated to Crucible Downstairs, within a dataset.
  */
@@ -211,6 +216,13 @@ CREATE INDEX on omicron.public.Region (
     volume_id
 );
 
+/*
+ * Allow all regions belonging to a dataset to be accessed quickly.
+ */
+CREATE INDEX on omicron.public.Region (
+    dataset_id
+);
+
 /*
  * A volume within Crucible
  */

nexus/Cargo.toml

@@ -17,7 +17,7 @@ clap = { version = "3.2", features = ["derive"] }
 cookie = "0.16"
 crucible-agent-client = { git = "https://github.com/oxidecomputer/crucible", rev = "bacffd142fc38a01fe255407b0c8d5d0aacfe778" }
 diesel = { version = "2.0.0-rc.1", features = ["postgres", "r2d2", "chrono", "serde_json", "network-address", "uuid"] }
-diesel-dtrace = { git = "https://github.com/oxidecomputer/diesel-dtrace", rev = "b9262a79db59f0727ca28ca9baed6fc6e3cc31e7" }
+diesel-dtrace = { git = "https://github.com/oxidecomputer/diesel-dtrace", rev = "18748d9f76c94e1f4400fbec0859b3e77a221a8d" }
 fatfs = "0.3.5"
 futures = "0.3.23"
 headers = "0.3.7"

nexus/db-model/Cargo.toml

@@ -4,6 +4,9 @@ version = "0.1.0"
 edition = "2021"
 license = "MPL-2.0"
 
+[build-dependencies.omicron-rpaths]
+path = "../../rpaths"
+
 [dependencies]
 anyhow = "1.0"
 chrono = { version = "0.4", features = ["serde"] }
@@ -13,6 +16,8 @@ ipnetwork = "0.20"
 macaddr = { version = "1.0.1", features = [ "serde_std" ]}
 newtype_derive = "0.1.6"
 parse-display = "0.5.4"
+# See omicron-rpaths for more about the "pq-sys" dependency.
+pq-sys = "*"
 rand = "0.8.5"
 ref-cast = "1.0"
 schemars = { version = "0.8.10", features = ["chrono", "uuid1"] }

nexus/db-model/build.rs

@@ -0,0 +1,10 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+// See omicron-rpaths for documentation.
+// NOTE: This file MUST be kept in sync with the other build.rs files in this
+// repository.
+fn main() {
+    omicron_rpaths::configure_default_omicron_rpaths();
+}

nexus/db-model/src/bytecount.rs

@@ -3,6 +3,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 use super::BlockSize;
+use anyhow::bail;
 use diesel::backend::{Backend, RawValue};
 use diesel::deserialize::{self, FromSql};
 use diesel::pg::Pg;
@@ -63,3 +64,155 @@ impl From<BlockSize> for ByteCount {
         Self(bs.to_bytes().into())
     }
 }
+
+impl From<i64> for ByteCount {
+    fn from(i: i64) -> Self {
+        i.into()
+    }
+}
+
+impl From<ByteCount> for i64 {
+    fn from(b: ByteCount) -> Self {
+        b.0.into()
+    }
+}
+
+impl TryFrom<diesel::pg::data_types::PgNumeric> for ByteCount {
+    type Error = anyhow::Error;
+    fn try_from(
+        num: diesel::pg::data_types::PgNumeric,
+    ) -> Result<Self, Self::Error> {
+        match num {
+            diesel::pg::data_types::PgNumeric::Positive {
+                weight: _,
+                scale,
+                digits,
+            } => {
+                // fail if there are digits to right of decimal place -
+                // ByteCount is a whole number
+                if scale != 0 {
+                    bail!("PgNumeric::Positive scale is {}", scale);
+                }
+
+                let mut result: i64 = 0;
+                let mut multiplier = 1;
+
+                for digit in digits.iter().rev() {
+                    result += *digit as i64 * multiplier;
+                    multiplier *= 10000;
+                }
+
+                let result: external::ByteCount = result.try_into()?;
+
+                Ok(result.into())
+            }
+
+            diesel::pg::data_types::PgNumeric::Negative { .. } => {
+                bail!("negative PgNumeric, cannot convert to ByteCount");
+            }
+
+            diesel::pg::data_types::PgNumeric::NaN => {
+                bail!("NaN PgNumeric, cannot convert to ByteCount");
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_pg_numeric_to_byte_count() {
+        type IntoResult = Result<ByteCount, anyhow::Error>;
+
+        // assert this does not work for negative or NaN
+
+        let result: IntoResult = diesel::pg::data_types::PgNumeric::Negative {
+            weight: 1,
+            scale: 0,
+            digits: vec![1],
+        }
+        .try_into();
+        assert!(result.is_err());
+
+        let result: IntoResult =
+            diesel::pg::data_types::PgNumeric::NaN.try_into();
+        assert!(result.is_err());
+
+        // assert this doesn't work for non-whole numbers
+
+        let result: IntoResult = diesel::pg::data_types::PgNumeric::Positive {
+            weight: 0,
+            scale: 1,
+            digits: vec![1],
+        }
+        .try_into();
+        assert!(result.is_err());
+
+        let result: IntoResult = diesel::pg::data_types::PgNumeric::Positive {
+            weight: 0,
+            scale: 1,
+            digits: vec![999],
+        }
+        .try_into();
+        assert!(result.is_err());
+
+        // From https://docs.diesel.rs/diesel/pg/data_types/enum.PgNumeric.html:
+        //
+        // weight: i16
+        //   How many digits come before the decimal point?
+        // scale: u16
+        //   How many significant digits are there?
+        // digits: Vec<i16>
+        //   The digits in this number, stored in base 10000
+
+        let result: IntoResult = diesel::pg::data_types::PgNumeric::Positive {
+            weight: 1,
+            scale: 0,
+            digits: vec![1],
+        }
+        .try_into();
+        assert_eq!(result.unwrap().to_bytes(), 1);
+
+        let result: IntoResult = diesel::pg::data_types::PgNumeric::Positive {
+            weight: 5,
+            scale: 0,
+            digits: vec![1, 0],
+        }
+        .try_into();
+        assert_eq!(result.unwrap().to_bytes(), 10000);
+
+        let result: IntoResult = diesel::pg::data_types::PgNumeric::Positive {
+            weight: 9,
+            scale: 0,
+            digits: vec![1, 0, 0],
+        }
+        .try_into();
+        assert_eq!(result.unwrap().to_bytes(), 100000000);
+
+        let result: IntoResult = diesel::pg::data_types::PgNumeric::Positive {
+            weight: 9,
+            scale: 0,
+            digits: vec![1, 0, 9999],
+        }
+        .try_into();
+        assert_eq!(result.unwrap().to_bytes(), 100009999);
+
+        let result: IntoResult = diesel::pg::data_types::PgNumeric::Positive {
+            weight: 11,
+            scale: 0,
+            digits: vec![512, 512, 512],
+        }
+        .try_into();
+        assert_eq!(result.unwrap().to_bytes(), 51205120512);
+
+        let result: IntoResult = diesel::pg::data_types::PgNumeric::Positive {
+            weight: 12,
+            scale: 0,
+            digits: vec![9999, 9999, 9999],
+        }
+        .try_into();
+        assert_eq!(result.unwrap().to_bytes(), 999999999999);
+    }
+}

nexus/src/db/datastore/dataset.rs

@@ -76,11 +76,6 @@ impl DataStore {
             .filter(dsl::time_deleted.is_null())
             .filter(dsl::kind.eq(DatasetKind::Crucible))
             .order(dsl::size_used.asc())
-            // TODO: We admittedly don't actually *fail* any request for
-            // running out of space - we try to send the request down to
-            // crucible agents, and expect them to fail on our behalf in
-            // out-of-storage conditions. This should undoubtedly be
-            // handled more explicitly.
             .select(Dataset::as_select())
             .limit(REGION_REDUNDANCY_THRESHOLD.try_into().unwrap())
     }

nexus/src/db/datastore/mod.rs

@@ -674,13 +674,10 @@ mod test {
         logctx.cleanup_successful();
     }
 
-    // TODO: This test should be updated when the correct handling
-    // of this out-of-space case is implemented.
     #[tokio::test]
-    async fn test_region_allocation_out_of_space_does_not_fail_yet() {
-        let logctx = dev::test_setup_log(
-            "test_region_allocation_out_of_space_does_not_fail_yet",
-        );
+    async fn test_region_allocation_out_of_space_fails() {
+        let logctx =
+            dev::test_setup_log("test_region_allocation_out_of_space_fails");
         let mut db = test_setup_database(&logctx.log).await;
         let cfg = db::Config { url: db.pg_config().clone() };
         let pool = db::Pool::new(&cfg);
@@ -714,8 +711,10 @@ mod test {
         let params = create_test_disk_create_params("disk1", disk_size);
         let volume1_id = Uuid::new_v4();
 
-        // NOTE: This *should* be an error, rather than succeeding.
-        datastore.region_allocate(&opctx, volume1_id, &params).await.unwrap();
+        assert!(datastore
+            .region_allocate(&opctx, volume1_id, &params)
+            .await
+            .is_err());
 
         let _ = db.cleanup().await;
         logctx.cleanup_successful();