use omicron_test_utils::dev::poll

Author: iliana

Cargo.lock

@@ -9,6 +9,7 @@ anyhow = { version = "1.0.58", features = ["backtrace"] }
 base64 = "0.13.0"
 futures = "0.3.21"
 omicron-sled-agent = { path = "../sled-agent" }
+omicron-test-utils = { path = "../test-utils" }
 oxide-client = { path = "../oxide-client" }
 rand = "0.8.5"
 reqwest = { version = "0.11.11", default-features = false }

end-to-end-tests/Cargo.toml

@@ -1,26 +1,30 @@
 use anyhow::{bail, Result};
 use end_to_end_tests::helpers::ctx::{build_client, nexus_addr, Context};
-use end_to_end_tests::helpers::{generate_name, try_loop};
+use end_to_end_tests::helpers::generate_name;
+use omicron_test_utils::dev::poll::{wait_for_condition, CondCheckError};
 use oxide_client::types::{
     ByteCount, DiskCreate, DiskSource, IpPoolCreate, IpRange, Ipv4Range,
 };
 use oxide_client::{ClientDisksExt, ClientIpPoolsExt, ClientOrganizationsExt};
 use std::net::IpAddr;
 use std::time::Duration;
-use tokio::time::sleep;
 
 #[tokio::main]
 async fn main() -> Result<()> {
     let client = build_client()?;
 
     // ===== ENSURE NEXUS IS UP ===== //
     eprintln!("waiting for nexus to come up...");
-    try_loop(
+    wait_for_condition(
         || async {
-            sleep(Duration::from_secs(1)).await;
-            client.organization_list().send().await
+            client
+                .organization_list()
+                .send()
+                .await
+                .map_err(|_| CondCheckError::<oxide_client::Error>::NotYet)
         },
-        Duration::from_secs(300),
+        &Duration::from_secs(1),
+        &Duration::from_secs(300),
     )
     .await?;
 
@@ -60,9 +64,8 @@ async fn main() -> Result<()> {
     eprintln!("ensuring datasets are ready...");
     let ctx = Context::from_client(client).await?;
     let disk_name = generate_name("disk")?;
-    try_loop(
+    wait_for_condition(
         || async {
-            sleep(Duration::from_secs(1)).await;
             ctx.client
                 .disk_create()
                 .organization_name(ctx.org_name.clone())
@@ -71,17 +74,16 @@ async fn main() -> Result<()> {
                     name: disk_name.clone(),
                     description: String::new(),
                     disk_source: DiskSource::Blank {
-                        block_size: 512
-                            .try_into()
-                            .map_err(anyhow::Error::msg)?,
+                        block_size: 512.try_into().unwrap(),
                     },
                     size: ByteCount(1024 * 1024 * 1024),
                 })
                 .send()
                 .await
-                .map_err(anyhow::Error::from)
+                .map_err(|_| CondCheckError::<oxide_client::Error>::NotYet)
         },
-        Duration::from_secs(120),
+        &Duration::from_secs(1),
+        &Duration::from_secs(120),
     )
     .await?;
     ctx.client

end-to-end-tests/src/bin/bootstrap.rs

@@ -1,37 +1,11 @@
 pub mod ctx;
 
-use anyhow::{Context, Result};
+use anyhow::Result;
 use oxide_client::types::Name;
 use rand::{thread_rng, Rng};
-use std::future::Future;
-use std::time::{Duration, Instant};
 
 pub fn generate_name(prefix: &str) -> Result<Name> {
     format!("{}-{:x}", prefix, thread_rng().gen_range(0..0xfff_ffff_ffffu64))
         .try_into()
         .map_err(anyhow::Error::msg)
 }
-
-pub async fn try_loop<F, Fut, T, E>(mut f: F, timeout: Duration) -> Result<T>
-where
-    F: FnMut() -> Fut,
-    Fut: Future<Output = Result<T, E>>,
-    Result<T, E>: Context<T, E>,
-{
-    let start = Instant::now();
-    loop {
-        match f().await {
-            Ok(t) => return Ok(t),
-            Err(err) => {
-                if Instant::now() - start > timeout {
-                    return Err(err).with_context(|| {
-                        format!(
-                            "try_loop timed out after {} seconds",
-                            timeout.as_secs_f64()
-                        )
-                    });
-                }
-            }
-        }
-    }
-}

end-to-end-tests/src/helpers/mod.rs

@@ -1,8 +1,9 @@
 #![cfg(test)]
 
-use crate::helpers::{ctx::Context, generate_name, try_loop};
+use crate::helpers::{ctx::Context, generate_name};
 use anyhow::{ensure, Context as _, Result};
 use futures::future::Ready;
+use omicron_test_utils::dev::poll::{wait_for_condition, CondCheckError};
 use oxide_client::types::{
     ByteCount, DiskCreate, DiskSource, Distribution, ExternalIpCreate,
     GlobalImageCreate, ImageSource, InstanceCpuCount, InstanceCreate,
@@ -113,9 +114,11 @@ async fn instance_launch() -> Result<()> {
     // poll serial for login prompt, waiting 5 min max
     // (pulling disk blocks over HTTP is slow)
     eprintln!("waiting for serial console");
-    let serial = try_loop(
+    let serial = wait_for_condition(
         || async {
-            sleep(Duration::from_secs(5)).await;
+            type Error =
+                CondCheckError<oxide_client::Error<oxide_client::types::Error>>;
+
             let data = String::from_utf8_lossy(
                 &ctx.client
                     .instance_serial_console()
@@ -129,14 +132,14 @@ async fn instance_launch() -> Result<()> {
                     .data,
             )
             .into_owned();
-            ensure!(
-                data.contains("localshark login:"),
-                "not yet booted\n{}",
-                data
-            );
-            Ok(data)
+            if data.contains("localshark login:") {
+                Ok(data)
+            } else {
+                Err(Error::NotYet)
+            }
         },
-        Duration::from_secs(300),
+        &Duration::from_secs(5),
+        &Duration::from_secs(300),
     )
     .await?;