[3/n] [installinator] make DiscoverPeersError::Abort test-only (#8037)

The production installinator must keep retrying until it succeeds. We use `DiscoverPeersError::Abort` for some of our tests, so gate it on `cfg(test)`.

Author: sunshowers

installinator/src/errors.rs

@@ -33,8 +33,13 @@ pub(crate) enum DiscoverPeersError {
     #[allow(unused)]
     Retry(#[source] anyhow::Error),
 
-    #[error("failed to discover peers (no more retries left, will abort)")]
-    #[allow(unused)]
+    /// Abort further discovery.
+    ///
+    /// The installinator must keep retrying until it has completed, which is why
+    /// there's no abort case here in the not cfg(test) case. However, we test
+    /// some abort-related functionality in tests.
+    #[cfg(test)]
+    #[error("failed to discover peers (will abort)")]
     Abort(#[source] anyhow::Error),
 }
 

installinator/src/peers.rs

@@ -53,8 +53,9 @@ impl DiscoveryMechanism {
     ) -> Result<Vec<PeerAddress>, DiscoverPeersError> {
         let peers = match self {
             Self::Bootstrap => {
-                // XXX: consider adding aborts to this after a certain number of tries.
-
+                // Note: we do not abort this process and instead keep retrying
+                // forever. This attempts to ensure that we'll eventually find
+                // peers.
                 let ddm_admin_client =
                     DdmAdminClient::localhost(log).map_err(|err| {
                         DiscoverPeersError::Retry(anyhow::anyhow!(err))
@@ -164,6 +165,7 @@ impl FetchedArtifact {
                     tokio::time::sleep(RETRY_DELAY).await;
                     continue;
                 }
+                #[cfg(test)]
                 Err(DiscoverPeersError::Abort(error)) => {
                     return Err(error);
                 }

installinator/src/reporter.rs

@@ -10,6 +10,7 @@ use display_error_chain::DisplayErrorChain;
 use futures::{Future, StreamExt};
 use installinator_common::{Event, EventBuffer};
 use tokio::{sync::mpsc, task::JoinHandle, time};
+use update_engine::AsError;
 use uuid::Uuid;
 
 use crate::{errors::DiscoverPeersError, peers::Peers};
@@ -97,16 +98,24 @@ where
         tokio::spawn(async move {
             let peers = match (discover_fn)().await {
                 Ok(peers) => peers,
-                Err(error) => {
-                    // Ignore DiscoverPeersError::Abort here because the
-                    // installinator must keep retrying.
+                Err(DiscoverPeersError::Retry(error)) => {
                     slog::warn!(
                         log,
                         "failed to discover peers: {}",
-                        DisplayErrorChain::new(&error),
+                        DisplayErrorChain::new(error.as_error()),
                     );
                     return None;
                 }
+                #[cfg(test)]
+                Err(DiscoverPeersError::Abort(_)) => {
+                    // This is not possible, since test implementations don't
+                    // currently generate Abort errors during reporter
+                    // discovery.
+                    unreachable!(
+                        "DiscoverPeersError::Abort is not generated for the \
+                         reporter by test implementations"
+                    )
+                }
             };
 
             // We could use StreamExt::any() here, but we're choosing to avoid