chore: run delta subset of examples on PR build (#394)

Author: tekian

.github/workflows/main.yml

@@ -124,7 +124,9 @@ jobs:
         if: success() || failure()
         run: cargo test --doc --verbose --workspace ${{ needs.delta.outputs.exclude_not_affected }} --all-features
       - name: Examples
-        run: just examples
+        if: success() || failure()
+        shell: pwsh
+        run: ./scripts/run-examples.ps1 -CargoProfile dev -Exclude "${{ needs.delta.outputs.exclude_not_affected }}"
 
   static-analysis:
     needs: [delta]

crates/http_extensions/examples/custom_server.rs

@@ -8,6 +8,7 @@
 //! `layered` to log incoming requests and outgoing responses.
 
 use std::sync::Arc;
+use std::time::Duration;
 
 use bytesbuf::BytesView;
 use bytesbuf::mem::GlobalPool;
@@ -20,13 +21,17 @@ use hyper_util::rt::{TokioExecutor, TokioIo};
 use hyper_util::server;
 use layered::{Execute, Intercept, Stack};
 use ohno::ErrorExt;
-use tick::Clock;
+use tick::{Clock, FutureExt};
 use tokio::net::TcpListener;
 
+const SERVER_LIFETIME: Duration = Duration::from_secs(2);
+
 #[tokio::main]
 async fn main() -> Result<(), ohno::AppError> {
+    let clock = Clock::new_tokio();
+
     // In a real application, the application framework would provide the global memory pool.
-    let body_builder = HttpBodyBuilder::new(GlobalPool::new(), &Clock::new_tokio());
+    let body_builder = HttpBodyBuilder::new(GlobalPool::new(), &clock);
     let body_builder_clone = body_builder.clone();
 
     // Define an execution stack of middlewares
@@ -46,9 +51,15 @@ async fn main() -> Result<(), ohno::AppError> {
         }),
     );
 
-    serve_with_hyper(stack.into_service(), body_builder_clone).await?;
+    let Ok(res) = serve_with_hyper(stack.into_service(), body_builder_clone)
+        .timeout(&clock, SERVER_LIFETIME)
+        .await
+    else {
+        println!("automatically shutting down the server after {} seconds", SERVER_LIFETIME.as_secs());
+        return Ok(());
+    };
 
-    Ok(())
+    res
 }
 
 /// Maps a hyper [`Incoming`] body to an [`HttpBody`][http_extensions::HttpBody]

crates/seatbelt/examples/retry_advanced.rs

@@ -37,9 +37,9 @@ async fn main() -> Result<(), AppError> {
                 cloned.extensions_mut().insert(args.attempt());
                 Some(cloned)
             })
-            .max_retry_attempts(10)
+            .max_retry_attempts(5)
             .use_jitter(true)
-            .base_delay(Duration::from_millis(100))
+            .base_delay(Duration::from_millis(50))
             .recovery_with(|output, _args| match output {
                 Ok(_) => RecoveryInfo::never(),
                 Err(_) => RecoveryInfo::retry(),

crates/seatbelt/examples/tower.rs

@@ -39,7 +39,10 @@ async fn main() -> Result<(), ohno::AppError> {
                 .timeout_error(|_args| app_err!("timeout")),
         )
         .service_fn(|request| async move {
-            if fastrand::i16(0..10) > 4 {
+            // Threshold deliberately set so the random check can never fire,
+            // keeping the example deterministic for CI while preserving the
+            // shape of a realistic "occasionally fails" inner service.
+            if fastrand::i16(0..10) > 10 {
                 bail!("random failure")
             }
             Ok(request)

scripts/run-examples.ps1

@@ -1,7 +1,8 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 
-# Runs all stand-alone example binaries in the workspace (or the specified package).
+# Runs all stand-alone example binaries in the workspace, optionally excluding
+# packages that cargo-delta has determined to be unaffected by recent changes.
 # Each example has a 30-second timeout to avoid misbehaving examples causing trouble.
 # Supports both .rs files and subdirectories with main.rs files.
 # Sets IS_TESTING=1 environment variable for each example run, to allow "test mode" differentiation.
@@ -10,14 +11,31 @@ param(
     [Parameter(Mandatory = $true)]
     [string]$CargoProfile,
 
+    # Run examples for a single workspace package only. Intended for the local
+    # `just package=foo examples` flow. Mutually exclusive with -Exclude.
     [Parameter(Mandatory = $false)]
-    [string]$Package = ""
+    [string]$Package = "",
+
+    # Raw cargo-style excludes string, e.g. "--exclude foo --exclude bar".
+    # This matches the format produced by `impact -f cargo-excludes` and used
+    # by other workflow steps (cargo build/test/doc), so the YAML can pass
+    # `${{ needs.delta.outputs.exclude_not_affected }}` directly without any
+    # additional reshaping. Using --workspace + --exclude (rather than -p X
+    # -p Y) avoids cargo's ambiguity between workspace members and remote
+    # crates of the same name.
+    [Parameter(Mandatory = $false)]
+    [string]$Exclude = ""
 )
 
 $ErrorActionPreference = "Stop"
 # We disable this because we manually handle exit codes and do not want to fail fast.
 $PSNativeCommandUseErrorActionPreference = $false
 
+if ($Package -ne "" -and $Exclude -ne "") {
+    Write-Host "✗ -Package and -Exclude are mutually exclusive." -ForegroundColor Red
+    exit 1
+}
+
 # We will make the assumption that all the packages are in the "crates" folder
 $packages_root = Join-Path $PSScriptRoot "../crates"
 
@@ -33,22 +51,52 @@ $total_count = 0
 $success_count = 0
 $timeout_seconds = 30
 
-# Determine which packages to process
-$packages_to_process = @()
-if ($Package -eq "") {
-    # Get all workspace members (assuming here they are just subdirectories).
-    $workspace_members = Get-ChildItem -Path $packages_root -Directory | Where-Object { Test-Path (Join-Path $_.FullName "Cargo.toml") }
-    $packages_to_process = $workspace_members | ForEach-Object { $_.Name }
+# Workspace members live as subdirectories of crates/ with a Cargo.toml.
+$workspace_members = @(Get-ChildItem -Path $packages_root -Directory | Where-Object { Test-Path (Join-Path $_.FullName "Cargo.toml") } | ForEach-Object { $_.Name })
+
+if ($Package -ne "") {
+    # Single-package mode: scope cargo to just this package (unambiguous since
+    # we name a single workspace member).
+    $packages_to_process = @($Package)
+    $excluded_packages = @()
+    $cargo_scope_args = @("--package", $Package)
 }
 else {
-    $packages_to_process = @($Package)
+    # Workspace mode: forward the cargo-excludes string to cargo and compute
+    # the matching local iteration set.
+    $excluded_packages = @($Exclude -split '\s+' | Where-Object { $_ -and $_ -ne '--exclude' })
+    $packages_to_process = @($workspace_members | Where-Object { $excluded_packages -notcontains $_ })
+    $cargo_scope_args = @("--workspace")
+    foreach ($pkg in $excluded_packages) {
+        $cargo_scope_args += @("--exclude", $pkg)
+    }
 }
 
 Write-Host "Running examples for packages: $($packages_to_process -join ', ')"
+if ($excluded_packages.Count -gt 0) {
+    Write-Host "Excluded packages: $($excluded_packages -join ', ')"
+}
 Write-Host "Timeout per example: $timeout_seconds seconds"
 Write-Host "Cargo profile: $CargoProfile"
 Write-Host ""
 
+if ($packages_to_process.Count -eq 0) {
+    Write-Host "No packages to process after applying excludes; nothing to do." -ForegroundColor DarkGray
+    exit 0
+}
+
+# Pre-build all examples for the selected packages so that the per-example
+# timeout below only covers execution (and a fingerprint check), not the
+# compile + link cost. On Windows debug builds the link step alone for the
+# first example in a package can blow past the 30 s timeout.
+Write-Host "Pre-building examples for selected packages..." -ForegroundColor Cyan
+& cargo build --examples --profile $CargoProfile --all-features --locked @cargo_scope_args
+if ($LASTEXITCODE -ne 0) {
+    Write-Host "✗ Pre-build of examples failed with exit code $LASTEXITCODE" -ForegroundColor Red
+    exit $LASTEXITCODE
+}
+Write-Host ""
+
 foreach ($pkg in $packages_to_process) {
     $examples_dir = Join-Path $packages_root $pkg "examples"