Resource Utilization

common/src/sql/dbinit.sql

@@ -128,6 +128,64 @@ CREATE INDEX ON omicron.public.service (
     sled_id
 );
 
+-- A table describing virtual resource provisioning which may be associated
+-- with a collection of objects, including:
+-- - Projects
+-- - Organizations
+-- - Silos
+-- - Fleet
+CREATE TABLE omicron.public.virtual_provisioning_collection (
+    -- Should match the UUID of the corresponding collection.
+    id UUID PRIMARY KEY,
+    time_modified TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+
+    -- Identifies the type of the collection.
+    collection_type STRING(63) NOT NULL,
+
+    -- The amount of physical disk space which has been provisioned
+    -- on behalf of the collection.
+    virtual_disk_bytes_provisioned INT8 NOT NULL,
+
+    -- The number of CPUs provisioned by VMs.
+    cpus_provisioned INT8 NOT NULL,
+
+    -- The amount of RAM provisioned by VMs.
+    ram_provisioned INT8 NOT NULL
+);
+
+-- A table describing a single virtual resource which has been provisioned.
+-- This may include:
+-- - Disks
+-- - Instances
+-- - Snapshots
+--
+-- NOTE: You might think to yourself: "This table looks an awful lot like
+-- the 'virtual_provisioning_collection' table, could they be condensed into
+-- a single table?"
+-- The answer to this question is unfortunately: "No". We use CTEs to both
+-- UPDATE the collection table while INSERTing rows in the resource table, and
+-- this would not be allowed if they came from the same table due to:
+-- https://www.cockroachlabs.com/docs/v22.2/known-limitations#statements-containing-multiple-modification-subqueries-of-the-same-table-are-disallowed
+-- However, by using separate tables, the CTE is able to function correctly.
+CREATE TABLE omicron.public.virtual_provisioning_resource (
+    -- Should match the UUID of the corresponding collection.
+    id UUID PRIMARY KEY,
+    time_modified TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+
+    -- Identifies the type of the resource.
+    resource_type STRING(63) NOT NULL,
+
+    -- The amount of physical disk space which has been provisioned
+    -- on behalf of the resource.
+    virtual_disk_bytes_provisioned INT8 NOT NULL,
+
+    -- The number of CPUs provisioned.
+    cpus_provisioned INT8 NOT NULL,
+
+    -- The amount of RAM provisioned.
+    ram_provisioned INT8 NOT NULL
+);
+
 /*
  * ZPools of Storage, attached to Sleds.
  * Typically these are backed by a single physical disk.

nexus/db-model/src/instance.rs

@@ -12,11 +12,15 @@ use nexus_types::identity::Resource;
 use omicron_common::address::PROPOLIS_PORT;
 use omicron_common::api::external;
 use omicron_common::api::internal;
+use serde::Deserialize;
+use serde::Serialize;
 use std::net::SocketAddr;
 use uuid::Uuid;
 
 /// An Instance (VM).
-#[derive(Queryable, Insertable, Debug, Selectable, Resource)]
+#[derive(
+    Queryable, Insertable, Debug, Selectable, Resource, Serialize, Deserialize,
+)]
 #[diesel(table_name = instance)]
 pub struct Instance {
     #[diesel(embed)]
@@ -84,7 +88,16 @@ impl DatastoreAttachTargetConfig<Disk> for Instance {
 /// metadata
 ///
 /// This state is owned by the sled agent running that Instance.
-#[derive(Clone, Debug, AsChangeset, Selectable, Insertable, Queryable)]
+#[derive(
+    Clone,
+    Debug,
+    AsChangeset,
+    Selectable,
+    Insertable,
+    Queryable,
+    Serialize,
+    Deserialize,
+)]
 #[diesel(table_name = instance)]
 pub struct InstanceRuntimeState {
     /// runtime state of the Instance

nexus/db-model/src/instance_cpu_count.rs

@@ -8,9 +8,13 @@ use diesel::pg::Pg;
 use diesel::serialize::{self, ToSql};
 use diesel::sql_types;
 use omicron_common::api::external;
+use serde::Deserialize;
+use serde::Serialize;
 use std::convert::TryFrom;
 
-#[derive(Copy, Clone, Debug, AsExpression, FromSqlRow)]
+#[derive(
+    Copy, Clone, Debug, AsExpression, FromSqlRow, Serialize, Deserialize,
+)]
 #[diesel(sql_type = sql_types::BigInt)]
 pub struct InstanceCpuCount(pub external::InstanceCpuCount);
 

nexus/db-model/src/instance_state.rs

@@ -4,14 +4,16 @@
 
 use super::impl_enum_wrapper;
 use omicron_common::api::external;
+use serde::Deserialize;
+use serde::Serialize;
 use std::io::Write;
 
 impl_enum_wrapper!(
     #[derive(SqlType, Debug)]
     #[diesel(postgres_type(name = "instance_state"))]
     pub struct InstanceStateEnum;
 
-    #[derive(Clone, Debug, PartialEq, AsExpression, FromSqlRow)]
+    #[derive(Clone, Debug, PartialEq, AsExpression, FromSqlRow, Serialize, Deserialize)]
     #[diesel(sql_type = InstanceStateEnum)]
     pub struct InstanceState(pub external::InstanceState);
 

nexus/db-model/src/lib.rs

@@ -62,6 +62,8 @@ mod ssh_key;
 mod u16;
 mod update_artifact;
 mod user_builtin;
+mod virtual_provisioning_collection;
+mod virtual_provisioning_resource;
 mod vni;
 mod volume;
 mod vpc;
@@ -126,6 +128,8 @@ pub use snapshot::*;
 pub use ssh_key::*;
 pub use update_artifact::*;
 pub use user_builtin::*;
+pub use virtual_provisioning_collection::*;
+pub use virtual_provisioning_resource::*;
 pub use vni::*;
 pub use volume::*;
 pub use vpc::*;

nexus/db-model/src/queries/mod.rs

@@ -5,3 +5,4 @@
 //! Subqueries used in CTEs.
 
 pub mod region_allocation;
+pub mod virtual_provisioning_collection_update;

nexus/db-model/src/queries/virtual_provisioning_collection_update.rs

@@ -0,0 +1,47 @@
+// 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/.
+
+//! Describes the resource provisioning update CTE
+//!
+//! Refer to <nexus/src/db/queries/virtual_provisioning_collection_update.rs>
+//! for the construction of this query.
+
+use crate::schema::organization;
+use crate::schema::silo;
+use crate::schema::virtual_provisioning_collection;
+
+table! {
+    parent_org {
+        id -> Uuid,
+    }
+}
+
+table! {
+    parent_silo {
+        id -> Uuid,
+    }
+}
+
+table! {
+    all_collections {
+        id -> Uuid,
+    }
+}
+
+table! {
+    do_update (update) {
+        update -> Bool,
+    }
+}
+
+diesel::allow_tables_to_appear_in_same_query!(organization, parent_org,);
+diesel::allow_tables_to_appear_in_same_query!(silo, parent_silo,);
+
+diesel::allow_tables_to_appear_in_same_query!(
+    virtual_provisioning_collection,
+    parent_org,
+    parent_silo,
+    all_collections,
+    do_update,
+);

nexus/db-model/src/rack.rs

@@ -13,7 +13,6 @@ use uuid::Uuid;
 pub struct Rack {
     #[diesel(embed)]
     pub identity: RackIdentity,
-
     pub initialized: bool,
     pub tuf_base_url: Option<String>,
 }

nexus/db-model/src/schema.rs

@@ -404,6 +404,36 @@ table! {
     }
 }
 
+table! {
+    virtual_provisioning_collection {
+        id -> Uuid,
+        // This type isn't actually "Nullable" - it's just handy to use the
+        // same type for insertion and querying, and doing so requires this
+        // field to appear optional so we can let this (default) field appear
+        // optional.
+        time_modified -> Nullable<Timestamptz>,
+        collection_type -> Text,
+        virtual_disk_bytes_provisioned -> Int8,
+        cpus_provisioned -> Int8,
+        ram_provisioned -> Int8,
+    }
+}
+
+table! {
+    virtual_provisioning_resource {
+        id -> Uuid,
+        // This type isn't actually "Nullable" - it's just handy to use the
+        // same type for insertion and querying, and doing so requires this
+        // field to appear optional so we can let this (default) field appear
+        // optional.
+        time_modified -> Nullable<Timestamptz>,
+        resource_type -> Text,
+        virtual_disk_bytes_provisioned -> Int8,
+        cpus_provisioned -> Int8,
+        ram_provisioned -> Int8,
+    }
+}
+
 table! {
     zpool (id) {
         id -> Uuid,

nexus/db-model/src/virtual_provisioning_collection.rs

@@ -0,0 +1,53 @@
+// 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/.
+
+use crate::schema::virtual_provisioning_collection;
+use crate::ByteCount;
+use chrono::{DateTime, Utc};
+use omicron_common::api::external;
+use parse_display::Display;
+use uuid::Uuid;
+
+#[derive(Debug, Display)]
+pub enum CollectionTypeProvisioned {
+    Project,
+    Organization,
+    Silo,
+    Fleet,
+}
+
+/// Describes virtual_provisioning_collection for a collection
+#[derive(Clone, Selectable, Queryable, Insertable, Debug)]
+#[diesel(table_name = virtual_provisioning_collection)]
+#[diesel(treat_none_as_default_value = true)]
+pub struct VirtualProvisioningCollection {
+    pub id: Uuid,
+    pub time_modified: Option<DateTime<Utc>>,
+    pub collection_type: String,
+
+    pub virtual_disk_bytes_provisioned: ByteCount,
+    pub cpus_provisioned: i64,
+    pub ram_provisioned: ByteCount,
+}
+
+impl VirtualProvisioningCollection {
+    pub fn new(id: Uuid, collection_type: CollectionTypeProvisioned) -> Self {
+        Self {
+            id,
+            time_modified: None,
+            collection_type: collection_type.to_string(),
+            virtual_disk_bytes_provisioned: ByteCount(
+                external::ByteCount::from(0),
+            ),
+            cpus_provisioned: 0,
+            ram_provisioned: ByteCount(external::ByteCount::from(0)),
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.virtual_disk_bytes_provisioned.to_bytes() == 0
+            && self.cpus_provisioned == 0
+            && self.ram_provisioned.to_bytes() == 0
+    }
+}

nexus/db-model/src/virtual_provisioning_resource.rs

@@ -0,0 +1,55 @@
+// 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/.
+
+use crate::schema::virtual_provisioning_resource;
+use crate::ByteCount;
+use chrono::{DateTime, Utc};
+use omicron_common::api::external;
+use uuid::Uuid;
+
+#[derive(Debug)]
+pub enum ResourceTypeProvisioned {
+    Instance,
+    Disk,
+    Snapshot,
+}
+
+impl std::fmt::Display for ResourceTypeProvisioned {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ResourceTypeProvisioned::Instance => write!(f, "instance"),
+            ResourceTypeProvisioned::Disk => write!(f, "disk"),
+            ResourceTypeProvisioned::Snapshot => write!(f, "snapshot"),
+        }
+    }
+}
+
+/// Describes virtual_provisioning_resource for a resource.
+#[derive(Clone, Selectable, Queryable, Insertable, Debug)]
+#[diesel(table_name = virtual_provisioning_resource)]
+#[diesel(treat_none_as_default_value = true)]
+pub struct VirtualProvisioningResource {
+    pub id: Uuid,
+    pub time_modified: Option<DateTime<Utc>>,
+    pub resource_type: String,
+
+    pub virtual_disk_bytes_provisioned: ByteCount,
+    pub cpus_provisioned: i64,
+    pub ram_provisioned: ByteCount,
+}
+
+impl VirtualProvisioningResource {
+    pub fn new(id: Uuid, resource_type: ResourceTypeProvisioned) -> Self {
+        Self {
+            id,
+            time_modified: None,
+            resource_type: resource_type.to_string(),
+            virtual_disk_bytes_provisioned: ByteCount(
+                external::ByteCount::from(0),
+            ),
+            cpus_provisioned: 0,
+            ram_provisioned: ByteCount(external::ByteCount::from(0)),
+        }
+    }
+}

nexus/src/app/disk.rs

@@ -386,13 +386,17 @@ impl super::Nexus {
 
     pub async fn project_delete_disk(
         self: &Arc<Self>,
+        opctx: &OpContext,
         disk_lookup: &lookup::Disk<'_>,
     ) -> DeleteResult {
-        let (.., authz_disk) =
+        let (.., project, authz_disk) =
             disk_lookup.lookup_for(authz::Action::Delete).await?;
 
-        let saga_params =
-            sagas::disk_delete::Params { disk_id: authz_disk.id() };
+        let saga_params = sagas::disk_delete::Params {
+            serialized_authn: authn::saga::Serialized::for_opctx(opctx),
+            project_id: project.id(),
+            disk_id: authz_disk.id(),
+        };
         self.execute_saga::<sagas::disk_delete::SagaDiskDelete>(saga_params)
             .await?;
         Ok(())
@@ -542,7 +546,7 @@ impl super::Nexus {
             .fetch()
             .await?;
 
-        self.volume_remove_read_only_parent(db_disk.volume_id).await?;
+        self.volume_remove_read_only_parent(&opctx, db_disk.volume_id).await?;
 
         Ok(())
     }