Add subnet handler

Author: pietrodimarco-dfinity

Cargo.lock

@@ -38,7 +38,6 @@ ic-registry-nns-data-provider = { workspace = true }
 ic-registry-common-proto = { workspace = true }
 ic-registry-keys = { workspace = true }
 ic-protobuf = { workspace = true }
-prost = { workspace = true }
 
 # GCP
 gcp_auth = { workspace = true }

rs/cloud-engine-controller-backend/Cargo.toml

@@ -1,17 +1,14 @@
 //! Subnet management handlers
 
+use axum::Json;
 use axum::extract::State;
 use axum::http::StatusCode;
-use axum::Json;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use slog::info;
 use utoipa::ToSchema;
 use uuid::Uuid;
 
-use crate::models::subnet::{
-    ProposalStatus, SubnetListResponse, SubnetProposal,
-    SubnetProposalResponse,
-};
+use crate::models::subnet::{ProposalStatus, SubnetListResponse, SubnetProposal, SubnetProposalResponse, SubnetUpgradeRequest};
 use crate::state::AppState;
 
 /// Request to create a subnet proposal
@@ -54,16 +51,15 @@ pub struct DeleteSubnetRequest {
         (status = 500, description = "Internal server error")
     )
 )]
-pub async fn list_subnets(
-    State(state): State<AppState>,
-) -> Result<Json<SubnetListResponse>, (StatusCode, String)> {
-    let node_operator = state.config.node_operator.as_ref()
+pub async fn list_subnets(State(state): State<AppState>) -> Result<Json<SubnetListResponse>, (StatusCode, String)> {
+    let node_operator = state
+        .config
+        .node_operator
+        .as_ref()
         .ok_or((StatusCode::BAD_REQUEST, "Node operator not configured in config file".to_string()))?;
 
     // Get subnets containing operator's nodes
-    let subnets = state
-        .registry_manager
-        .get_subnets_by_operator(&node_operator.principal_id);
+    let subnets = state.registry_manager.get_subnets_by_operator(&node_operator.principal_id);
 
     let total = subnets.len();
     Ok(Json(SubnetListResponse { subnets, total }))
@@ -85,7 +81,10 @@ pub async fn create_subnet_proposal(
     State(state): State<AppState>,
     Json(request): Json<CreateSubnetProposalRequest>,
 ) -> Result<Json<SubnetProposalResponse>, (StatusCode, String)> {
-    let node_operator = state.config.node_operator.as_ref()
+    let node_operator = state
+        .config
+        .node_operator
+        .as_ref()
         .ok_or((StatusCode::BAD_REQUEST, "Node operator not configured in config file".to_string()))?;
 
     // Validate that all nodes exist and belong to the configured operator
@@ -96,18 +95,15 @@ pub async fn create_subnet_proposal(
             .ok_or((StatusCode::NOT_FOUND, format!("Node {} not found", node_id)))?;
 
         if node.operator_id.to_string() != node_operator.principal_id {
-            return Err((StatusCode::BAD_REQUEST, format!(
-                "Node {} does not belong to the configured node operator",
-                node_id
-            )));
+            return Err((
+                StatusCode::BAD_REQUEST,
+                format!("Node {} does not belong to the configured node operator", node_id),
+            ));
         }
 
         // Check if node is already assigned to a subnet
         if node.subnet_id.is_some() {
-            return Err((StatusCode::BAD_REQUEST, format!(
-                "Node {} is already assigned to a subnet",
-                node_id
-            )));
+            return Err((StatusCode::BAD_REQUEST, format!("Node {} is already assigned to a subnet", node_id)));
         }
     }
 
@@ -129,9 +125,7 @@ pub async fn create_subnet_proposal(
     };
 
     // Store the proposal
-    state
-        .subnet_proposals
-        .insert(proposal.id.clone(), proposal.clone());
+    state.subnet_proposals.insert(proposal.id.clone(), proposal.clone());
 
     info!(state.log, "Subnet creation proposal created";
         "proposal_id" => &proposal.id,
@@ -162,21 +156,22 @@ pub async fn delete_subnet_proposal(
     State(state): State<AppState>,
     Json(request): Json<DeleteSubnetRequest>,
 ) -> Result<Json<SubnetProposalResponse>, (StatusCode, String)> {
-    let node_operator = state.config.node_operator.as_ref()
+    let node_operator = state
+        .config
+        .node_operator
+        .as_ref()
         .ok_or((StatusCode::BAD_REQUEST, "Node operator not configured in config file".to_string()))?;
 
     // Verify the subnet exists and has nodes from the configured operator
-    let subnets = state
-        .registry_manager
-        .get_subnets_by_operator(&node_operator.principal_id);
+    let subnets = state.registry_manager.get_subnets_by_operator(&node_operator.principal_id);
 
-    let subnet = subnets
-        .iter()
-        .find(|s| s.subnet_id == request.subnet_id)
-        .ok_or((StatusCode::NOT_FOUND, format!(
+    let subnet = subnets.iter().find(|s| s.subnet_id == request.subnet_id).ok_or((
+        StatusCode::NOT_FOUND,
+        format!(
             "Subnet {} not found or doesn't contain nodes from the configured operator",
             request.subnet_id
-        )))?;
+        ),
+    ))?;
 
     // Create deletion proposal
     let proposal = SubnetProposal {
@@ -190,9 +185,7 @@ pub async fn delete_subnet_proposal(
         created_at: chrono::Utc::now(),
     };
 
-    state
-        .subnet_proposals
-        .insert(proposal.id.clone(), proposal.clone());
+    state.subnet_proposals.insert(proposal.id.clone(), proposal.clone());
 
     info!(state.log, "Subnet deletion proposal created";
         "proposal_id" => &proposal.id,
@@ -203,9 +196,110 @@ pub async fn delete_subnet_proposal(
         id: proposal.id,
         proposal_id: None,
         status: ProposalStatus::Draft,
+        message: format!("Deletion proposal for subnet {} created in draft state.", request.subnet_id),
+    }))
+}
+
+/// Response for subnet upgrade proposal
+#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
+pub struct SubnetUpgradeResponse {
+    /// Local tracking ID
+    pub id: String,
+    /// Subnet ID
+    pub subnet_id: String,
+    /// Current GuestOS version
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub current_version: Option<String>,
+    /// Target GuestOS version
+    pub target_version: String,
+    /// Status
+    pub status: ProposalStatus,
+    /// Message
+    pub message: String,
+}
+
+/// Create a subnet upgrade proposal to update GuestOS version
+#[utoipa::path(
+    post,
+    path = "/subnets/upgrade",
+    tag = "Subnets",
+    request_body = SubnetUpgradeRequest,
+    responses(
+        (status = 200, description = "Upgrade proposal created", body = SubnetUpgradeResponse),
+        (status = 400, description = "Invalid request"),
+        (status = 404, description = "Subnet not found")
+    )
+)]
+pub async fn upgrade_subnet(
+    State(state): State<AppState>,
+    Json(request): Json<SubnetUpgradeRequest>,
+) -> Result<Json<SubnetUpgradeResponse>, (StatusCode, String)> {
+    // Get subnet info to validate it exists and get current version
+    let subnet = state
+        .registry_manager
+        .get_subnet(&request.subnet_id)
+        .ok_or((StatusCode::NOT_FOUND, format!("Subnet {} not found", request.subnet_id)))?;
+
+    let current_version = subnet.replica_version.clone();
+
+    // Check if already on target version
+    if current_version.as_ref() == Some(&request.guestos_version_id) {
+        return Err((
+            StatusCode::BAD_REQUEST,
+            format!(
+                "Subnet {} is already running GuestOS version {}",
+                request.subnet_id, request.guestos_version_id
+            ),
+        ));
+    }
+
+    // Generate default title and summary if not provided
+    let title = request
+        .title
+        .unwrap_or_else(|| format!("Update subnet {} to GuestOS version {}", request.subnet_id, request.guestos_version_id));
+
+    let summary = request.summary.unwrap_or_else(|| {
+        format!(
+            "Proposal to update subnet {} from GuestOS version {} to {}",
+            request.subnet_id,
+            current_version.as_deref().unwrap_or("unknown"),
+            request.guestos_version_id
+        )
+    });
+
+    // Create upgrade proposal (in draft state)
+    let proposal_id = Uuid::new_v4().to_string();
+
+    // Store as a subnet proposal with upgrade type
+    let proposal = SubnetProposal {
+        id: proposal_id.clone(),
+        proposal_id: None,
+        status: ProposalStatus::Draft,
+        node_ids: subnet.node_ids.clone(),
+        subnet_type: format!("upgrade:{}", request.guestos_version_id),
+        title: title.clone(),
+        summary: summary.clone(),
+        created_at: chrono::Utc::now(),
+    };
+
+    state.subnet_proposals.insert(proposal_id.clone(), proposal);
+
+    info!(state.log, "Subnet upgrade proposal created";
+        "proposal_id" => &proposal_id,
+        "subnet_id" => &request.subnet_id,
+        "current_version" => current_version.as_deref().unwrap_or("unknown"),
+        "target_version" => &request.guestos_version_id
+    );
+
+    Ok(Json(SubnetUpgradeResponse {
+        id: proposal_id,
+        subnet_id: request.subnet_id,
+        current_version,
+        target_version: request.guestos_version_id,
+        status: ProposalStatus::Draft,
         message: format!(
-            "Deletion proposal for subnet {} created in draft state.",
-            request.subnet_id
+            "Upgrade proposal created in draft state. To submit to NNS, use: ic-admin propose-to-deploy-guestos-to-all-subnet-nodes --title \"{}\" --summary \"{}\"",
+            title, summary
         ),
     }))
 }

rs/cloud-engine-controller-backend/src/handlers/subnet_handlers.rs

@@ -106,6 +106,7 @@ fn main() {
         .route("/subnets/list", get(subnet_handlers::list_subnets))
         .route("/subnets/create", post(subnet_handlers::create_subnet_proposal))
         .route("/subnets/delete", post(subnet_handlers::delete_subnet_proposal))
+        .route("/subnets/upgrade", post(subnet_handlers::upgrade_subnet))
         // Swagger UI
         .merge(SwaggerUi::new("/swagger-ui").url("/api-docs/openapi.json", ApiDoc::openapi()))
         // Layers

rs/cloud-engine-controller-backend/src/main.rs

@@ -11,6 +11,9 @@ pub struct SubnetInfo {
     /// Subnet type (application, system, etc.)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub subnet_type: Option<String>,
+    /// Current GuestOS replica version
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub replica_version: Option<String>,
     /// Node IDs in this subnet
     pub node_ids: Vec<String>,
     /// Number of nodes in the subnet
@@ -108,3 +111,18 @@ pub struct SubnetDeleteRequest {
     /// Proposal summary/motivation
     pub summary: String,
 }
+
+/// Request to upgrade a subnet to a new GuestOS version
+#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]
+pub struct SubnetUpgradeRequest {
+    /// Subnet ID to upgrade
+    pub subnet_id: String,
+    /// Target GuestOS version ID
+    pub guestos_version_id: String,
+    /// Proposal title (optional, will be auto-generated if not provided)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+    /// Proposal summary (optional, will be auto-generated if not provided)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub summary: Option<String>,
+}

rs/cloud-engine-controller-backend/src/models/subnet.rs

@@ -4,15 +4,10 @@ use utoipa::OpenApi;
 
 use crate::config::{AppConfig, GcpConfig, NodeOperatorConfig};
 use crate::handlers::node_handlers::{GetNodeRequest, NodeInfo, NodeListResponse};
-use crate::handlers::subnet_handlers::{CreateSubnetProposalRequest, DeleteSubnetRequest};
+use crate::handlers::subnet_handlers::{CreateSubnetProposalRequest, DeleteSubnetRequest, SubnetUpgradeResponse};
 use crate::handlers::vm_handlers::{DeleteVmRequest, ProvisionVmRequestBody};
-use crate::models::subnet::{
-    ProposalStatus, SubnetInfo, SubnetListResponse, SubnetProposal,
-    SubnetProposalResponse,
-};
-use crate::models::vm::{
-    IcpNodeMapping, Vm, VmListResponse, VmProvisionRequest, VmProvisionResponse, VmStatus,
-};
+use crate::models::subnet::{ProposalStatus, SubnetInfo, SubnetListResponse, SubnetProposal, SubnetProposalResponse, SubnetUpgradeRequest};
+use crate::models::vm::{IcpNodeMapping, Vm, VmListResponse, VmProvisionRequest, VmProvisionResponse, VmStatus};
 
 /// OpenAPI documentation
 #[derive(OpenApi)]
@@ -31,6 +26,7 @@ use crate::models::vm::{
         crate::handlers::subnet_handlers::list_subnets,
         crate::handlers::subnet_handlers::create_subnet_proposal,
         crate::handlers::subnet_handlers::delete_subnet_proposal,
+        crate::handlers::subnet_handlers::upgrade_subnet,
     ),
     info(
         title = "Cloud Engine Controller Backend",
@@ -72,6 +68,8 @@ use crate::models::vm::{
             SubnetListResponse,
             CreateSubnetProposalRequest,
             DeleteSubnetRequest,
+            SubnetUpgradeRequest,
+            SubnetUpgradeResponse,
         )
     ),
     tags(