trident: promote rollback to stable v1; adjust rollback return type to detect no-servicing

crates/trident/src/engine/manual_rollback/mod.rs

@@ -85,11 +85,25 @@ pub fn check_rollback(
 }
 
 /// Handle manual rollback operations.
+///
+/// Mirrors `engine::update::update()`'s `(ExitKind, ServicingType)` return
+/// shape: a no-op ("nothing to roll back") reports
+/// `(ExitKind::Done, ServicingType::NoActiveServicing)` rather than a bare
+/// `ExitKind::Done` that's indistinguishable from a real rollback at the
+/// gRPC layer (see `ServicingResponse.servicing_kind` in servicing.proto).
 pub fn execute_rollback(
     datastore: &mut DataStore,
     requested_rollback_kind: ManualRollbackRequestKind,
     allowed_operations: &Operations,
-) -> Result<ExitKind, TridentError> {
+) -> Result<(ExitKind, ServicingType), TridentError> {
+    // Tracks the rollback kind actually staged this call, so the trailing
+    // "stage completed, finalize not requested this call" return below can
+    // report it instead of a generic NoActiveServicing. Stays None when
+    // has_stage() didn't run this call (finalize-only), or when it exited
+    // early via the no-rollback-available branch below (which returns its
+    // own explicit NoActiveServicing directly).
+    let mut staged_rollback_type = None;
+
     // Perform staging if operation is allowed
     if allowed_operations.has_stage() {
         match datastore.host_status().servicing_state {
@@ -125,14 +139,15 @@ pub fn execute_rollback(
             Some(rollback_item) => rollback_item,
             None => {
                 info!("No available rollbacks to perform");
-                return Ok(ExitKind::Done);
+                return Ok((ExitKind::Done, ServicingType::NoActiveServicing));
             }
         };
 
         let rollback_type = match requested_rollback.kind {
             ManualRollbackKind::Ab => ServicingType::ManualRollbackAb,
             ManualRollbackKind::Runtime => ServicingType::ManualRollbackRuntime,
         };
+        staged_rollback_type = Some(rollback_type);
 
         let engine_context = EngineContext::new(EngineContextParams {
             spec: requested_rollback.spec.clone(),
@@ -203,9 +218,12 @@ pub fn execute_rollback(
             datastore.host_status().servicing_state,
         );
 
-        return finalize_result;
+        return finalize_result.map(|exit_kind| (exit_kind, current_servicing_type));
     }
-    Ok(ExitKind::Done)
+    Ok((
+        ExitKind::Done,
+        staged_rollback_type.unwrap_or(ServicingType::NoActiveServicing),
+    ))
 }
 
 /// Stage manual rollback.

crates/trident/src/lib.rs

@@ -840,7 +840,7 @@ impl Trident {
         invoke_if_next_is_runtime: bool,
         invoke_available_ab: bool,
         allowed_operations: Operations,
-    ) -> Result<ExitKind, TridentError> {
+    ) -> Result<(ExitKind, ServicingType), TridentError> {
         // If host's servicing state is not in Provisioned or ManualRollback*, cannot
         // execute a rollback.
         if !matches!(
@@ -853,7 +853,7 @@ impl Trident {
                 "Cannot trigger rollback from current state ({:?})",
                 datastore.host_status().servicing_state
             );
-            return Ok(ExitKind::Done);
+            return Ok((ExitKind::Done, ServicingType::NoActiveServicing));
         }
 
         let rollback_result = self.execute_and_record_error(datastore, |datastore| {

crates/trident/src/main.rs

@@ -195,12 +195,14 @@ fn run_trident(
                         ab,
                         ref allowed_operations,
                         ..
-                    } => trident.rollback(
-                        &mut datastore,
-                        runtime,
-                        ab,
-                        cli::to_operations(allowed_operations),
-                    ),
+                    } => trident
+                        .rollback(
+                            &mut datastore,
+                            runtime,
+                            ab,
+                            cli::to_operations(allowed_operations),
+                        )
+                        .map(|(exit_kind, _servicing_type)| exit_kind),
                     Commands::RebuildRaid { .. } => trident
                         .rebuild_raid(&mut datastore)
                         .map(|()| ExitKind::Done),

crates/trident/src/server/mod.rs

@@ -18,17 +18,18 @@ use tonic::transport::Server;
 use tonic_middleware::MiddlewareFor;
 
 use trident_proto::v1::{
-    commit_service_server::CommitServiceServer, streaming_service_server::StreamingServiceServer,
-    update_service_server::UpdateServiceServer, version_service_server::VersionServiceServer,
+    commit_service_server::CommitServiceServer, rollback_service_server::RollbackServiceServer,
+    streaming_service_server::StreamingServiceServer, update_service_server::UpdateServiceServer,
+    version_service_server::VersionServiceServer,
 };
 
 #[cfg(feature = "grpc-preview")]
 use trident_proto::v1preview::{
     commit_service_server::CommitServiceServer as CommitServiceServerPreview,
     install_service_server::InstallServiceServer,
     rebuild_raid_service_server::RebuildRaidServiceServer,
-    rollback_service_server::RollbackServiceServer, status_service_server::StatusServiceServer,
-    validation_service_server::ValidationServiceServer,
+    rollback_service_server::RollbackServiceServer as RollbackServiceServerPreview,
+    status_service_server::StatusServiceServer, validation_service_server::ValidationServiceServer,
 };
 
 use crate::{
@@ -223,6 +224,10 @@ async fn server_main_inner(
         .add_service(MiddlewareFor::new(
             CommitServiceServer::from_arc(trident_server.clone()),
             activity_tracker.middleware(),
+        ))
+        .add_service(MiddlewareFor::new(
+            RollbackServiceServer::from_arc(trident_server.clone()),
+            activity_tracker.middleware(),
         ));
 
     #[cfg(feature = "grpc-preview")]
@@ -237,7 +242,7 @@ async fn server_main_inner(
                 activity_tracker.middleware(),
             ))
             .add_service(MiddlewareFor::new(
-                RollbackServiceServer::from_arc(trident_server.clone()),
+                RollbackServiceServerPreview::from_arc(trident_server.clone()),
                 activity_tracker.middleware(),
             ))
             .add_service(MiddlewareFor::new(

crates/trident/src/server/tridentserver/services/mod.rs

@@ -3,6 +3,7 @@ use trident_proto::v1::{RebootHandling, RebootManagement};
 use crate::server::tridentserver::RebootDecision;
 
 mod commit;
+mod rollback;
 mod streaming;
 mod update;
 mod version;
@@ -12,8 +13,6 @@ mod install;
 #[cfg(feature = "grpc-preview")]
 mod rebuild_raid;
 #[cfg(feature = "grpc-preview")]
-mod rollback;
-#[cfg(feature = "grpc-preview")]
 mod status;
 #[cfg(feature = "grpc-preview")]
 mod validation;