no reference to "external" types in external API call tree

Author: david-crespo

common/src/api/external/mod.rs

@@ -3499,19 +3499,6 @@ pub struct TufArtifactMeta {
     pub sign: Option<Vec<u8>>,
 }
 
-/// Status of a TUF repo import.
-#[derive(
-    Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize, JsonSchema,
-)]
-#[serde(rename_all = "snake_case")]
-pub enum TufRepoInsertStatus {
-    /// The repository already existed in the database.
-    AlreadyExists,
-
-    /// The repository did not exist, and was inserted into the database.
-    Inserted,
-}
-
 #[derive(
     Clone, Debug, Deserialize, JsonSchema, Serialize, PartialEq, ObjectIdentity,
 )]

nexus/db-model/src/tuf_repo.rs

@@ -30,8 +30,6 @@ use uuid::Uuid;
 
 /// A description of a TUF update: a repo, along with the artifacts it
 /// contains.
-///
-/// This is the internal variant of [`external::TufRepoDescription`].
 #[derive(Debug, Clone)]
 pub struct TufRepoDescription {
     /// The repository.
@@ -64,7 +62,6 @@ impl TufRepoDescription {
         }
     }
 
-    /// Converts self into [`external::TufRepoDescription`].
     pub fn into_external(self) -> external::TufRepoDescription {
         external::TufRepoDescription {
             repo: self.repo.into_external(),
@@ -78,8 +75,6 @@ impl TufRepoDescription {
 }
 
 /// A record representing an uploaded TUF repository.
-///
-/// This is the internal variant of [`external::TufRepoMeta`].
 #[derive(
     Queryable, Identifiable, Insertable, Clone, Debug, Selectable, AsChangeset,
 )]
@@ -132,7 +127,6 @@ impl TufRepo {
         )
     }
 
-    /// Converts self into [`external::TufRepoMeta`].
     pub fn into_external(self) -> external::TufRepoMeta {
         external::TufRepoMeta {
             hash: self.sha256.into(),
@@ -154,6 +148,18 @@ impl TufRepo {
     }
 }
 
+impl Into<views::TufRepo> for TufRepo {
+    fn into(self) -> views::TufRepo {
+        views::TufRepo {
+            hash: self.sha256.into(),
+            targets_role_version: self.targets_role_version as u64,
+            valid_until: self.valid_until,
+            system_version: self.system_version.into(),
+            file_name: self.file_name,
+        }
+    }
+}
+
 #[derive(Queryable, Insertable, Clone, Debug, Selectable, AsChangeset)]
 #[diesel(table_name = tuf_artifact)]
 pub struct TufArtifact {
@@ -411,3 +417,44 @@ impl FromSql<Jsonb, diesel::pg::Pg> for DbTufSignedRootRole {
             .map_err(|e| e.into())
     }
 }
+
+// The following aren't real models in the sense that they represent DB data,
+// but they are the return types of datastore functions
+
+/// Status of a TUF repo import
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TufRepoUploadStatus {
+    /// The repository already existed in the database
+    AlreadyExists,
+
+    /// The repository did not exist, and was inserted into the database
+    Inserted,
+}
+
+impl From<TufRepoUploadStatus> for views::TufRepoUploadStatus {
+    fn from(status: TufRepoUploadStatus) -> Self {
+        match status {
+            TufRepoUploadStatus::AlreadyExists => {
+                views::TufRepoUploadStatus::AlreadyExists
+            }
+            TufRepoUploadStatus::Inserted => {
+                views::TufRepoUploadStatus::Inserted
+            }
+        }
+    }
+}
+
+/// The return value of the tuf repo insert function
+pub struct TufRepoUpload {
+    pub recorded: TufRepoDescription,
+    pub status: TufRepoUploadStatus,
+}
+
+impl From<TufRepoUpload> for views::TufRepoUpload {
+    fn from(upload: TufRepoUpload) -> Self {
+        views::TufRepoUpload {
+            repo: upload.recorded.repo.into(),
+            status: upload.status.into(),
+        }
+    }
+}

nexus/db-queries/src/db/datastore/update.rs

@@ -18,13 +18,12 @@ use nexus_db_errors::OptionalError;
 use nexus_db_errors::{ErrorHandler, public_error_from_diesel};
 use nexus_db_lookup::DbConnection;
 use nexus_db_model::{
-    ArtifactHash, TufArtifact, TufRepo, TufRepoDescription, TufTrustRoot,
-    to_db_typed_uuid,
+    ArtifactHash, TufArtifact, TufRepo, TufRepoDescription, TufRepoUpload,
+    TufRepoUploadStatus, TufTrustRoot, to_db_typed_uuid,
 };
-use nexus_types::external_api::views;
 use omicron_common::api::external::{
     self, CreateResult, DataPageParams, DeleteResult, Generation,
-    ListResultVec, LookupResult, LookupType, ResourceType, TufRepoInsertStatus,
+    ListResultVec, LookupResult, LookupType, ResourceType,
 };
 use omicron_uuid_kinds::GenericUuid;
 use omicron_uuid_kinds::TufRepoKind;
@@ -34,24 +33,6 @@ use swrite::{SWrite, swrite};
 use tufaceous_artifact::ArtifactVersion;
 use uuid::Uuid;
 
-/// The return value of [`DataStore::tuf_repo_insert`].
-///
-/// This is similar to [`views::TufRepoUpload`], but uses
-/// nexus-db-model's types instead of external types.
-pub struct TufRepoInsertResponse {
-    pub recorded: TufRepoDescription,
-    pub status: TufRepoInsertStatus,
-}
-
-impl TufRepoInsertResponse {
-    pub fn into_external(self) -> views::TufRepoUpload {
-        views::TufRepoUpload {
-            repo: self.recorded.repo.into_external().into(),
-            status: self.status.into(),
-        }
-    }
-}
-
 async fn artifacts_for_repo(
     repo_id: TypedUuid<TufRepoKind>,
     conn: &async_bb8_diesel::Connection<DbConnection>,
@@ -85,7 +66,7 @@ impl DataStore {
         &self,
         opctx: &OpContext,
         description: &external::TufRepoDescription,
-    ) -> CreateResult<TufRepoInsertResponse> {
+    ) -> CreateResult<TufRepoUpload> {
         opctx.authorize(authz::Action::Modify, &authz::FLEET).await?;
         let log = opctx.log.new(
             slog::o!(
@@ -327,7 +308,7 @@ async fn insert_impl(
     conn: async_bb8_diesel::Connection<DbConnection>,
     desc: &external::TufRepoDescription,
     err: OptionalError<InsertError>,
-) -> Result<TufRepoInsertResponse, DieselError> {
+) -> Result<TufRepoUpload, DieselError> {
     // Load the current generation from the database and increment it, then
     // use that when creating the `TufRepoDescription`. If we determine there
     // are any artifacts to be inserted, we update the generation to this value
@@ -364,9 +345,9 @@ async fn insert_impl(
 
             let recorded =
                 TufRepoDescription { repo: existing_repo, artifacts };
-            return Ok(TufRepoInsertResponse {
+            return Ok(TufRepoUpload {
                 recorded,
-                status: TufRepoInsertStatus::AlreadyExists,
+                status: TufRepoUploadStatus::AlreadyExists,
             });
         }
 
@@ -570,10 +551,7 @@ async fn insert_impl(
     }
 
     let recorded = TufRepoDescription { repo, artifacts: all_artifacts };
-    Ok(TufRepoInsertResponse {
-        recorded,
-        status: TufRepoInsertStatus::Inserted,
-    })
+    Ok(TufRepoUpload { recorded, status: TufRepoUploadStatus::Inserted })
 }
 
 async fn get_generation(

nexus/src/app/update.rs

@@ -9,14 +9,13 @@ use dropshot::HttpError;
 use futures::Stream;
 use nexus_auth::authz;
 use nexus_db_lookup::LookupPath;
+use nexus_db_model::TufRepoUpload;
+use nexus_db_model::TufRepoUploadStatus;
 use nexus_db_model::TufTrustRoot;
 use nexus_db_queries::context::OpContext;
-use nexus_db_queries::db::datastore::update::TufRepoInsertResponse;
 use nexus_db_queries::db::{datastore::SQL_BATCH_SIZE, pagination::Paginator};
 use nexus_types::external_api::shared::TufSignedRootRole;
-use omicron_common::api::external::{
-    DataPageParams, Error, TufRepoInsertStatus,
-};
+use omicron_common::api::external::{DataPageParams, Error};
 use omicron_uuid_kinds::{GenericUuid, TufTrustRootUuid};
 use semver::Version;
 use update_common::artifacts::{
@@ -30,7 +29,7 @@ impl super::Nexus {
         opctx: &OpContext,
         body: impl Stream<Item = Result<Bytes, HttpError>> + Send + Sync + 'static,
         file_name: String,
-    ) -> Result<TufRepoInsertResponse, HttpError> {
+    ) -> Result<TufRepoUpload, HttpError> {
         let mut trusted_roots = Vec::new();
         let mut paginator = Paginator::new(
             SQL_BATCH_SIZE,
@@ -68,7 +67,7 @@ impl super::Nexus {
         // carries with it the `Utf8TempDir`s storing the artifacts) into the
         // artifact replication background task, then immediately activate the
         // task.
-        if response.status == TufRepoInsertStatus::Inserted {
+        if response.status == TufRepoUploadStatus::Inserted {
             self.tuf_artifact_replication_tx
                 .send(artifacts_with_plan)
                 .await

nexus/src/external_api/http_entrypoints.rs

@@ -6654,8 +6654,7 @@ impl NexusExternalApi for NexusExternalApiImpl {
             let update = nexus
                 .updates_put_repository(&opctx, body, query.file_name)
                 .await?;
-            let repo_upload = update.into_external();
-            Ok(HttpResponseOk(repo_upload))
+            Ok(HttpResponseOk(update.into()))
         };
         apictx
             .context
@@ -6677,7 +6676,7 @@ impl NexusExternalApi for NexusExternalApiImpl {
             let repo = nexus
                 .updates_get_repository(&opctx, params.system_version)
                 .await?;
-            Ok(HttpResponseOk(repo.into_external().into()))
+            Ok(HttpResponseOk(repo.into()))
         };
         apictx
             .context
@@ -6700,10 +6699,8 @@ impl NexusExternalApi for NexusExternalApiImpl {
             let repos =
                 nexus.updates_list_repositories(&opctx, &pagparams).await?;
 
-            let responses: Vec<views::TufRepo> = repos
-                .into_iter()
-                .map(|repo| repo.into_external().into())
-                .collect();
+            let responses: Vec<views::TufRepo> =
+                repos.into_iter().map(Into::into).collect();
 
             Ok(HttpResponseOk(ScanByVersion::results_page(
                 &query,

nexus/types/src/external_api/views.rs

@@ -15,9 +15,9 @@ use chrono::Utc;
 use daft::Diffable;
 pub use omicron_common::api::external::IpVersion;
 use omicron_common::api::external::{
-    self, AffinityPolicy, AllowedSourceIps as ExternalAllowedSourceIps,
-    ByteCount, Digest, Error, FailureDomain, IdentityMetadata, InstanceState,
-    Name, ObjectIdentity, SimpleIdentity, SimpleIdentityOrName,
+    AffinityPolicy, AllowedSourceIps as ExternalAllowedSourceIps, ByteCount,
+    Digest, Error, FailureDomain, IdentityMetadata, InstanceState, Name,
+    ObjectIdentity, SimpleIdentity, SimpleIdentityOrName,
 };
 use omicron_uuid_kinds::*;
 use oxnet::{Ipv4Net, Ipv6Net};
@@ -1599,18 +1599,6 @@ pub struct TufRepo {
     pub file_name: String,
 }
 
-impl From<external::TufRepoMeta> for TufRepo {
-    fn from(meta: external::TufRepoMeta) -> Self {
-        Self {
-            hash: meta.hash,
-            targets_role_version: meta.targets_role_version,
-            valid_until: meta.valid_until,
-            system_version: meta.system_version,
-            file_name: meta.file_name,
-        }
-    }
-}
-
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize, JsonSchema)]
 pub struct TufRepoUpload {
     pub repo: TufRepo,
@@ -1631,15 +1619,6 @@ pub enum TufRepoUploadStatus {
     Inserted,
 }
 
-impl From<external::TufRepoInsertStatus> for TufRepoUploadStatus {
-    fn from(status: external::TufRepoInsertStatus) -> Self {
-        match status {
-            external::TufRepoInsertStatus::AlreadyExists => Self::AlreadyExists,
-            external::TufRepoInsertStatus::Inserted => Self::Inserted,
-        }
-    }
-}
-
 fn expected_one_of<T: strum::VariantArray + fmt::Display>() -> String {
     use std::fmt::Write;
     let mut msg = "expected one of:".to_string();