Merge pull request #23 from lucab/ups/finalize

update_agent: add update finalization

Author: lucab

src/cincinnati/mod.rs

@@ -28,7 +28,7 @@ impl Cincinnati {
             bail!("empty Cincinnati base URL");
         }
 
-        /// Substitute templated key with agent runtime values.
+        // Substitute templated key with agent runtime values.
         let base_url = if envsubst::is_templated(&cfg.base_url) {
             let context = id.url_variables();
             envsubst::validate_vars(&context)?;

src/rpm_ostree/actor.rs

@@ -36,6 +36,26 @@ impl Handler<StageDeployment> for RpmOstreeClient {
 
     fn handle(&mut self, msg: StageDeployment, _ctx: &mut Self::Context) -> Self::Result {
         trace!("request to stage release: {:?}", msg.release);
-        super::cli_upgrade::locked_upgrade(msg.release)
+        super::cli_deploy::deploy_locked(msg.release)
+    }
+}
+
+/// Request: finalize a staged deployment (by unlocking it and rebooting).
+#[derive(Debug, Clone)]
+pub struct FinalizeDeployment {
+    /// Finalized release to finalize.
+    pub release: Release,
+}
+
+impl Message for FinalizeDeployment {
+    type Result = Fallible<Release>;
+}
+
+impl Handler<FinalizeDeployment> for RpmOstreeClient {
+    type Result = Fallible<Release>;
+
+    fn handle(&mut self, msg: FinalizeDeployment, _ctx: &mut Self::Context) -> Self::Result {
+        trace!("request to finalize release: {:?}", msg.release);
+        super::cli_finalize::finalize_deployment(msg.release)
     }
 }

src/rpm_ostree/cli_upgrade.rs src/rpm_ostree/cli_deploy.rs

@@ -1,14 +1,14 @@
-//! Interface to `rpm-ostree upgrade --lock-finalization`.
+//! Interface to `rpm-ostree deploy --lock-finalization`.
 
 use super::Release;
 use failure::{bail, format_err, Fallible, ResultExt};
 
-/// Upgrade and leave the new deployment locked.
-pub fn locked_upgrade(release: Release) -> Fallible<Release> {
+/// Deploy an upgrade (by checksum) and leave the new deployment locked.
+pub fn deploy_locked(release: Release) -> Fallible<Release> {
     let cmd = std::process::Command::new("rpm-ostree")
         .arg("deploy")
         .arg("--lock-finalization")
-        .arg(release.reference_id())
+        .arg(format!("revision={}", release.checksum))
         .output()
         .with_context(|e| format_err!("failed to run rpm-ostree: {}", e))?;
 

src/rpm_ostree/cli_finalize.rs

@@ -0,0 +1,22 @@
+//! Interface to `rpm-ostree finalize-deployment`.
+
+use super::Release;
+use failure::{bail, format_err, Fallible, ResultExt};
+
+/// Unlock and finalize the new deployment.
+pub fn finalize_deployment(release: Release) -> Fallible<Release> {
+    let cmd = std::process::Command::new("rpm-ostree")
+        .arg("finalize-deployment")
+        .arg(&release.checksum)
+        .output()
+        .with_context(|e| format_err!("failed to run rpm-ostree: {}", e))?;
+
+    if !cmd.status.success() {
+        bail!(
+            "rpm-ostree finalize-deployment failed:\n{}",
+            String::from_utf8_lossy(&cmd.stderr)
+        );
+    }
+
+    Ok(release)
+}

src/rpm_ostree/mod.rs

@@ -1,8 +1,9 @@
+mod cli_deploy;
+mod cli_finalize;
 mod cli_status;
-mod cli_upgrade;
 
 mod actor;
-pub use actor::{RpmOstreeClient, StageDeployment};
+pub use actor::{FinalizeDeployment, RpmOstreeClient, StageDeployment};
 
 use crate::cincinnati::Node;
 
@@ -23,9 +24,4 @@ impl Release {
             checksum: node.payload,
         }
     }
-
-    /// Returns the reference ID for this release.
-    pub fn reference_id(&self) -> String {
-        format!("revision={}", self.checksum)
-    }
 }

src/update_agent/actor.rs

@@ -38,8 +38,15 @@ impl Handler<RefreshTick> for UpdateAgent {
                 let update = release.clone();
                 self.try_stage_update(update)
             }
-            UpdateAgentState::UpdateStaged(_release) => self.todo(),
-            UpdateAgentState::_EndState => self.nop(),
+            UpdateAgentState::UpdateStaged(release) => {
+                let update = release.clone();
+                self.try_finalize_update(update)
+            }
+            UpdateAgentState::UpdateFinalized(release) => {
+                let update = release.clone();
+                self.end(update)
+            }
+            UpdateAgentState::EndState => self.nop(),
         };
 
         let update_machine = state_action.then(move |_r, actor, ctx| {
@@ -127,6 +134,26 @@ impl UpdateAgent {
         Box::new(state_change)
     }
 
+    /// Try to finalize an update.
+    fn try_finalize_update(&mut self, release: Release) -> ResponseActFuture<Self, (), ()> {
+        trace!("trying to finalize an update");
+
+        let can_finalize = self.strategy.can_finalize(&self.identity);
+        let state_change = actix::fut::wrap_future::<_, Self>(can_finalize)
+            .and_then(|can_finalize, actor, _ctx| actor.finalize_deployment(can_finalize, release))
+            .map(|release, actor, _ctx| actor.state.update_finalized(release));
+
+        Box::new(state_change)
+    }
+
+    /// Actor job is done.
+    fn end(&mut self, release: Release) -> ResponseActFuture<Self, (), ()> {
+        log::info!("update applied, waiting for reboot: {}", release.version);
+        let state_change = self.nop().map(|_r, actor, _ctx| actor.state.end());
+
+        Box::new(state_change)
+    }
+
     /// Fetch and stage an update, in finalization-locked mode.
     fn locked_upgrade(
         &mut self,
@@ -148,15 +175,30 @@ impl UpdateAgent {
         Box::new(upgrade)
     }
 
+    /// Finalize a deployment (unlock and reboot).
+    fn finalize_deployment(
+        &mut self,
+        can_finalize: bool,
+        release: Release,
+    ) -> ResponseActFuture<Self, Release, ()> {
+        if !can_finalize {
+            return Box::new(actix::fut::err(()));
+        }
+
+        let msg = rpm_ostree::FinalizeDeployment { release };
+        let upgrade = self
+            .rpm_ostree_actor
+            .send(msg)
+            .flatten()
+            .map_err(|e| log::error!("failed to finalize update: {}", e))
+            .into_actor(self);
+
+        Box::new(upgrade)
+    }
+
     /// Do nothing, without errors.
     fn nop(&mut self) -> ResponseActFuture<Self, (), ()> {
         let nop = actix::fut::ok(());
         Box::new(nop)
     }
-
-    /// Pending implementation.
-    fn todo(&mut self) -> ResponseActFuture<Self, (), ()> {
-        log::error!("pending implementation");
-        self.nop()
-    }
 }

src/update_agent/mod.rs

@@ -27,9 +27,10 @@ enum UpdateAgentState {
     UpdateAvailable(Release),
     /// Update staged by rpm-ostree.
     UpdateStaged(Release),
-    // TODO(lucab): add all the "update in progress" states.
+    /// Update finalized by rpm-ostree.
+    UpdateFinalized(Release),
     /// Final state upon actor end.
-    _EndState,
+    EndState,
 }
 
 impl Default for UpdateAgentState {
@@ -71,6 +72,16 @@ impl UpdateAgentState {
     fn update_staged(&mut self, update: Release) {
         *self = UpdateAgentState::UpdateStaged(update);
     }
+
+    /// Transition to the UpdateFinalized state.
+    fn update_finalized(&mut self, update: Release) {
+        *self = UpdateAgentState::UpdateFinalized(update);
+    }
+
+    /// Transition to the End state.
+    fn end(&mut self) {
+        *self = UpdateAgentState::EndState;
+    }
 }
 
 /// Update agent.
@@ -143,9 +154,15 @@ mod tests {
             checksum: "ostree-checksum".to_string(),
         };
         machine.update_available(Some(update.clone()));
+        assert_eq!(machine, UpdateAgentState::UpdateAvailable(update.clone()));
+
+        machine.update_staged(update.clone());
+        assert_eq!(machine, UpdateAgentState::UpdateStaged(update.clone()));
+
+        machine.update_finalized(update.clone());
+        assert_eq!(machine, UpdateAgentState::UpdateFinalized(update.clone()));
 
-        machine.update_staged(update);
-        // TODO(lucab): complete the full path till reaching EndState.
-        // assert_eq!(machine, UpdateAgentState::_EndState);
+        machine.end();
+        assert_eq!(machine, UpdateAgentState::EndState);
     }
 }