add bgp_config_update endpoint

Author: nicolaskagami

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

@@ -25,7 +25,7 @@ use omicron_common::api::external;
 use omicron_common::api::external::http_pagination::PaginatedBy;
 use omicron_common::api::external::{
     CreateResult, DeleteResult, Error, ListResultVec, LookupResult, NameOrId,
-    ResourceType,
+    ResourceType, UpdateResult,
 };
 use ref_cast::RefCast;
 use sled_agent_types::early_networking::RouterPeerType;
@@ -225,6 +225,181 @@ impl DataStore {
             })
     }
 
+    pub async fn bgp_config_update(
+        &self,
+        opctx: &OpContext,
+        sel: &networking::BgpConfigSelector,
+        update: &networking::BgpConfigUpdate,
+    ) -> UpdateResult<BgpConfig> {
+        use nexus_db_schema::schema::bgp_config;
+        use nexus_db_schema::schema::bgp_config::dsl as bgp_config_dsl;
+        use nexus_db_schema::schema::{
+            bgp_announce_set, bgp_announce_set::dsl as announce_set_dsl,
+        };
+
+        let err = OptionalError::new();
+        let conn = self.pool_connection_authorized(opctx).await?;
+        self.transaction_retry_wrapper("bgp_config_update")
+            .transaction(&conn, |conn| {
+                let err = err.clone();
+                async move {
+                    let name_or_id = sel.name_or_id.clone();
+
+                    // Look up the existing config
+                    let existing: BgpConfig = match name_or_id {
+                        NameOrId::Id(id) => bgp_config_dsl::bgp_config
+                            .filter(bgp_config::id.eq(id))
+                            .filter(bgp_config::time_deleted.is_null())
+                            .select(BgpConfig::as_select())
+                            .limit(1)
+                            .first_async::<BgpConfig>(&conn)
+                            .await
+                            .map_err(|e| {
+                                let msg = "failed to lookup bgp config by id";
+                                error!(opctx.log, "{msg}"; "error" => ?e);
+                                match e {
+                                    diesel::result::Error::NotFound => err
+                                        .bail(Error::not_found_by_id(
+                                            ResourceType::BgpConfig,
+                                            &id,
+                                        )),
+                                    _ => err.bail(Error::internal_error(msg)),
+                                }
+                            })?,
+                        NameOrId::Name(name) => bgp_config_dsl::bgp_config
+                            .filter(bgp_config::name.eq(name.to_string()))
+                            .filter(bgp_config::time_deleted.is_null())
+                            .select(BgpConfig::as_select())
+                            .limit(1)
+                            .first_async::<BgpConfig>(&conn)
+                            .await
+                            .map_err(|e| {
+                                let msg = "failed to lookup bgp config by name";
+                                error!(opctx.log, "{msg}"; "error" => ?e);
+                                match e {
+                                    diesel::result::Error::NotFound => err
+                                        .bail(Error::not_found_by_name(
+                                            ResourceType::BgpConfig,
+                                            &name,
+                                        )),
+                                    _ => err.bail(Error::internal_error(msg)),
+                                }
+                            })?,
+                    };
+
+                    // Resolve bgp_announce_set_id if an update was requested
+                    let new_bgp_announce_set_id = match update
+                        .bgp_announce_set_id
+                        .clone()
+                    {
+                        None => existing.bgp_announce_set_id,
+                        Some(NameOrId::Name(name)) => {
+                            announce_set_dsl::bgp_announce_set
+                                .filter(
+                                    bgp_announce_set::time_deleted.is_null(),
+                                )
+                                .filter(
+                                    bgp_announce_set::name.eq(name.to_string()),
+                                )
+                                .select(bgp_announce_set::id)
+                                .limit(1)
+                                .first_async::<Uuid>(&conn)
+                                .await
+                                .map_err(|e| {
+                                    let msg =
+                                        "failed to lookup announce set by name";
+                                    error!(opctx.log, "{msg}"; "error" => ?e);
+                                    match e {
+                                        diesel::result::Error::NotFound => err
+                                            .bail(Error::not_found_by_name(
+                                                ResourceType::BgpAnnounceSet,
+                                                &name,
+                                            )),
+                                        _ => {
+                                            err.bail(Error::internal_error(msg))
+                                        }
+                                    }
+                                })?
+                        }
+                        Some(NameOrId::Id(id)) => {
+                            announce_set_dsl::bgp_announce_set
+                                .filter(
+                                    bgp_announce_set::time_deleted.is_null(),
+                                )
+                                .filter(bgp_announce_set::id.eq(id))
+                                .select(bgp_announce_set::id)
+                                .limit(1)
+                                .first_async::<Uuid>(&conn)
+                                .await
+                                .map_err(|e| {
+                                    let msg =
+                                        "failed to lookup announce set by id";
+                                    error!(opctx.log, "{msg}"; "error" => ?e);
+                                    match e {
+                                        diesel::result::Error::NotFound => err
+                                            .bail(Error::not_found_by_id(
+                                                ResourceType::BgpAnnounceSet,
+                                                &id,
+                                            )),
+                                        _ => {
+                                            err.bail(Error::internal_error(msg))
+                                        }
+                                    }
+                                })?
+                        }
+                    };
+
+                    let new_name = update
+                        .name
+                        .as_ref()
+                        .map(|n| n.to_string())
+                        .unwrap_or_else(|| existing.name().to_string());
+                    let new_description = update
+                        .description
+                        .clone()
+                        .unwrap_or_else(|| existing.description().to_string());
+                    let new_max_paths = update
+                        .max_paths
+                        .map(|m| m.as_u8())
+                        .unwrap_or(*existing.max_paths);
+
+                    diesel::update(bgp_config_dsl::bgp_config)
+                        .filter(bgp_config_dsl::id.eq(existing.id()))
+                        .set((
+                            bgp_config_dsl::time_modified.eq(Utc::now()),
+                            bgp_config_dsl::name.eq(new_name),
+                            bgp_config_dsl::description.eq(new_description),
+                            bgp_config_dsl::bgp_announce_set_id
+                                .eq(new_bgp_announce_set_id),
+                            bgp_config_dsl::max_paths
+                                .eq(i16::from(new_max_paths)),
+                        ))
+                        .returning(BgpConfig::as_returning())
+                        .get_result_async(&conn)
+                        .await
+                        .map_err(|e| {
+                            let msg = "bgp_config_update failed";
+                            error!(opctx.log, "{msg}"; "error" => ?e);
+                            err.bail(public_error_from_diesel(
+                                e,
+                                ErrorHandler::Server,
+                            ))
+                        })
+                }
+            })
+            .await
+            .map_err(|e| {
+                let msg = "bgp_config_update failed";
+                if let Some(err) = err.take() {
+                    error!(opctx.log, "{msg}"; "error" => ?err);
+                    err
+                } else {
+                    error!(opctx.log, "{msg}"; "error" => ?e);
+                    public_error_from_diesel(e, ErrorHandler::Server)
+                }
+            })
+    }
+
     pub async fn bgp_config_delete(
         &self,
         opctx: &OpContext,

nexus/external-api/output/nexus_tags.txt

@@ -279,6 +279,7 @@ networking_bgp_announcement_list         GET      /v1/system/networking/bgp-anno
 networking_bgp_config_create             POST     /v1/system/networking/bgp
 networking_bgp_config_delete             DELETE   /v1/system/networking/bgp
 networking_bgp_config_list               GET      /v1/system/networking/bgp
+networking_bgp_config_update             PUT      /v1/system/networking/bgp
 networking_bgp_exported                  GET      /v1/system/networking/bgp-exported
 networking_bgp_imported                  GET      /v1/system/networking/bgp-imported
 networking_bgp_message_history           GET      /v1/system/networking/bgp-message-history

nexus/external-api/src/lib.rs

@@ -84,6 +84,7 @@ api_versions!([
     // |  date-based version should be at the top of the list.
     // v
     // (next_yyyy_mm_dd_nn, IDENT),
+    (2026_06_08_00, BGP_CONFIGURATION_UPDATE),
     (2026_06_03_00, DISK_BLOCK_SIZE_TYPE),
     (2026_05_20_00, ADD_CONTACT_SUPPORT_TO_UPDATE_STATUS),
     (2026_05_08_00, MANUAL_DISK_ADOPTION),
@@ -5421,6 +5422,24 @@ pub trait NexusExternalApi {
         sel: Query<latest::networking::BgpConfigSelector>,
     ) -> Result<HttpResponseUpdatedNoContent, HttpError>;
 
+    /// Update BGP configuration
+    ///
+    /// Update the mutable fields of an existing BGP configuration. The `asn`
+    /// field is intentionally not updatable; changing the autonomous system
+    /// number requires creating a new BGP configuration object, since many
+    /// things are keyed off the ASN.
+    #[endpoint {
+        method = PUT,
+        path = "/v1/system/networking/bgp",
+        tags = ["system/networking"],
+        versions = VERSION_BGP_CONFIGURATION_UPDATE..,
+    }]
+    async fn networking_bgp_config_update(
+        rqctx: RequestContext<Self::Context>,
+        sel: Query<latest::networking::BgpConfigSelector>,
+        update: TypedBody<latest::networking::BgpConfigUpdate>,
+    ) -> Result<HttpResponseOk<latest::networking::BgpConfig>, HttpError>;
+
     /// Update BGP announce set
     ///
     /// If the announce set exists, this endpoint replaces the existing announce

nexus/src/app/bgp.rs

@@ -10,6 +10,7 @@ use nexus_types::external_api::networking;
 use omicron_common::api::external::http_pagination::PaginatedBy;
 use omicron_common::api::external::{
     self, CreateResult, DeleteResult, ListResultVec, LookupResult, NameOrId,
+    UpdateResult,
 };
 use slog_error_chain::InlineErrorChain;
 
@@ -42,6 +43,21 @@ impl super::Nexus {
         self.db_datastore.bgp_config_list(opctx, pagparams).await
     }
 
+    pub async fn bgp_config_update(
+        &self,
+        opctx: &OpContext,
+        sel: &networking::BgpConfigSelector,
+        update: &networking::BgpConfigUpdate,
+    ) -> UpdateResult<BgpConfig> {
+        opctx.authorize(authz::Action::Modify, &authz::FLEET).await?;
+        let result =
+            self.db_datastore.bgp_config_update(opctx, sel, update).await?;
+        // Eagerly propagate changes via background task
+        self.background_tasks
+            .activate(&self.background_tasks.task_switch_port_settings_manager);
+        Ok(result)
+    }
+
     pub async fn bgp_config_delete(
         &self,
         opctx: &OpContext,

nexus/src/external_api/http_entrypoints.rs

@@ -4491,6 +4491,20 @@ impl NexusExternalApi for NexusExternalApiImpl {
         .await
     }
 
+    async fn networking_bgp_config_update(
+        rqctx: RequestContext<ApiContext>,
+        sel: Query<networking::BgpConfigSelector>,
+        update: TypedBody<networking::BgpConfigUpdate>,
+    ) -> Result<HttpResponseOk<networking::BgpConfig>, HttpError> {
+        audit_and_time(&rqctx, |opctx, nexus| async move {
+            let sel = sel.into_inner();
+            let update = update.into_inner();
+            let result = nexus.bgp_config_update(&opctx, &sel, &update).await?;
+            Ok(HttpResponseOk::<networking::BgpConfig>(result.try_into()?))
+        })
+        .await
+    }
+
     async fn networking_bgp_announce_set_update(
         rqctx: RequestContext<ApiContext>,
         config: TypedBody<networking::BgpAnnounceSetCreate>,

nexus/tests/integration_tests/endpoints.rs

@@ -69,6 +69,7 @@ use omicron_common::api::external::VpcFirewallRuleUpdateParams;
 use omicron_test_utils::certificates::CertificateChain;
 use semver::Version;
 use sled_agent_types::early_networking::BfdMode;
+use sled_agent_types::early_networking::MaxPathConfig;
 use sled_agent_types::early_networking::SwitchSlot;
 use std::collections::BTreeSet;
 use std::net::IpAddr;
@@ -1008,6 +1009,20 @@ pub static DEMO_BGP_CONFIG: LazyLock<networking::BgpConfigCreate> =
         shaper: None,
         max_paths: Default::default(),
     });
+pub static DEMO_BGP_CONFIG_UPDATE: LazyLock<networking::BgpConfigCreate> =
+    LazyLock::new(|| networking::BgpConfigCreate {
+        identity: IdentityMetadataCreateParams {
+            name: "as47".parse().unwrap(),
+            description: "BGP config for AS47".into(),
+        },
+        bgp_announce_set_id: NameOrId::Name("instances".parse().unwrap()),
+        asn: 47,
+        vrf: None,
+        checker: None,
+        shaper: None,
+        max_paths: MaxPathConfig::new(2).unwrap(),
+    });
+
 pub const DEMO_BGP_ANNOUNCE_SET_URL: &'static str =
     "/v1/system/networking/bgp-announce-set";
 pub static DEMO_BGP_ANNOUNCE: LazyLock<networking::BgpAnnounceSetCreate> =
@@ -3416,6 +3431,9 @@ pub static VERIFY_ENDPOINTS: LazyLock<Vec<VerifyEndpoint>> = LazyLock::new(
                         serde_json::to_value(&*DEMO_BGP_CONFIG).unwrap(),
                     ),
                     AllowedMethod::Get,
+                    AllowedMethod::Put(
+                        serde_json::to_value(&*DEMO_BGP_CONFIG_UPDATE).unwrap(),
+                    ),
                     AllowedMethod::Delete,
                 ],
             },

nexus/types/versions/src/bgp_configuration_update/mod.rs

@@ -0,0 +1,5 @@
+// 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/.
+
+pub mod networking;

nexus/types/versions/src/bgp_configuration_update/networking.rs

@@ -0,0 +1,37 @@
+// 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/.
+
+//! Networking types for the `BGP_CONFIGURATION_UPDATE` version.
+//!
+//! Changes in this version:
+//!
+//! * New [`BgpConfigUpdate`] type to allow updating a BGP configuration's
+//!   `name`, `description`, `max_paths` and `bgp_announce_set_id` fields
+//!   without deleting and recreating the object.
+
+use omicron_common::api::external::Name;
+use omicron_common::api::external::NameOrId;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use sled_agent_types_versions::v20::early_networking::MaxPathConfig;
+
+/// Parameters for updating a BGP configuration.
+///
+/// The `asn` field is intentionally not updatable; changing the autonomous
+/// system number requires creating a new BGP configuration object, since many
+/// things are keyed off the ASN.
+#[derive(Clone, Debug, Deserialize, Serialize, JsonSchema)]
+pub struct BgpConfigUpdate {
+    /// Update the name of this BGP configuration.
+    pub name: Option<Name>,
+
+    /// Update the description of this BGP configuration.
+    pub description: Option<String>,
+
+    /// Update the BGP announce set associated with this configuration.
+    pub bgp_announce_set_id: Option<NameOrId>,
+
+    /// Update the maximum number of equal-cost paths.
+    pub max_paths: Option<MaxPathConfig>,
+}

nexus/types/versions/src/latest.rs

@@ -307,6 +307,8 @@ pub mod networking {
 
     pub use crate::v2026_05_07_00::networking::SwitchInterfaceConfig;
     pub use crate::v2026_05_07_00::networking::SwitchPortSettings;
+
+    pub use crate::v2026_06_08_00::networking::BgpConfigUpdate;
 }
 
 pub mod oxql {

nexus/types/versions/src/lib.rs

@@ -87,3 +87,5 @@ pub mod v2026_05_07_00;
 pub mod v2026_05_08_00;
 #[path = "add_contact_support_to_update_status/mod.rs"]
 pub mod v2026_05_20_00;
+#[path = "bgp_configuration_update/mod.rs"]
+pub mod v2026_06_08_00;