Strata: the cloud stores send through ureq, so every release target links 2cd40ea1c04c

//! The HTTP client the cloud stores send their requests through: `ureq`

//! on rustls with the web roots, the client oxy-core itself uses, so the

//! stores cross-compile for every target oxy is released for. Each

//! request runs on the runtime's blocking pool; bodies are held whole,

//! which is how the stores use them (a bundle, a record, a listing).

use async_trait::async_trait;

use bytes::Bytes;

use http_body_util::{BodyExt, Full};

use object_store::client::{

    ClientOptions, HttpClient, HttpConnector, HttpError, HttpErrorKind, HttpRequest, HttpResponse,

    HttpResponseBody, HttpService,

};

use std::io::Read;

use std::time::Duration;

/// How long a request may take in all, and to connect.

const TIMEOUT: Duration = Duration::from_secs(600);

const CONNECT_TIMEOUT: Duration = Duration::from_secs(30);

/// A rustls configuration trusting the web roots.

fn tls() -> Result<std::sync::Arc<rustls::ClientConfig>, String> {

    oxy_core::protocol::tls_client_config(None).map_err(|e| e.to_string())

}

/// Make the agent every request of a store goes through.

pub fn agent() -> Result<ureq::Agent, String> {

    Ok(ureq::AgentBuilder::new()

        .tls_config(tls()?)

        .timeout_connect(CONNECT_TIMEOUT)

        .timeout(TIMEOUT)

        .build())

}

#[derive(Debug, Clone, Copy, Default)]

pub struct UreqConnector;

impl HttpConnector for UreqConnector {

    fn connect(&self, _options: &ClientOptions) -> object_store::Result<HttpClient> {

        let agent = agent().map_err(|e| object_store::Error::Generic {

            store: "ureq",

            source: e.into(),

        })?;

        Ok(HttpClient::new(UreqService { agent }))

    }

}

#[derive(Debug, Clone)]

struct UreqService {

    agent: ureq::Agent,

}

#[async_trait]

impl HttpService for UreqService {

    async fn call(&self, req: HttpRequest) -> Result<HttpResponse, HttpError> {

        let (parts, body) = req.into_parts();

        let bytes = body.collect().await?.to_bytes();

        let agent = self.agent.clone();

        tokio::task::spawn_blocking(move || send(&agent, parts, &bytes))

            .await

            .map_err(|e| HttpError::new(HttpErrorKind::Interrupted, e))?

    }

}

fn send(

    agent: &ureq::Agent,

    parts: http::request::Parts,

    bytes: &[u8],

) -> Result<HttpResponse, HttpError> {

    let url = parts.uri.to_string();

    let mut r = agent.request(parts.method.as_str(), &url);

    for (name, value) in &parts.headers {

        if let Ok(v) = value.to_str() {

            r = r.set(name.as_str(), v);

        }

    }

    let sent = if bytes.is_empty()

        && matches!(

            parts.method,

            http::Method::GET | http::Method::HEAD | http::Method::DELETE

        ) {

        r.call()

    } else {

        r.send_bytes(bytes)

    };

    let resp = match sent {

        Ok(resp) => resp,

        // A refusal is a response the store interprets (a 404, a 412).

        Err(ureq::Error::Status(_, resp)) => resp,

        Err(ureq::Error::Transport(t)) => {

            let kind = match t.kind() {

                ureq::ErrorKind::Dns

                | ureq::ErrorKind::ConnectionFailed

                | ureq::ErrorKind::ProxyConnect => HttpErrorKind::Connect,

                ureq::ErrorKind::Io => HttpErrorKind::Timeout,

                _ => HttpErrorKind::Request,

            };

            return Err(HttpError::new(kind, t));

        }

    };

    let status = http::StatusCode::from_u16(resp.status())

        .map_err(|e| HttpError::new(HttpErrorKind::Decode, e))?;

    let mut builder = http::Response::builder().status(status);

    for name in resp.headers_names() {

        for value in resp.all(&name) {

            builder = builder.header(name.as_str(), value);

        }

    }

    let mut body = Vec::new();

    resp.into_reader()

        .read_to_end(&mut body)

        .map_err(|e| HttpError::new(HttpErrorKind::Decode, e))?;

    let body = HttpResponseBody::new(

        Full::new(Bytes::from(body)).map_err(|never: std::convert::Infallible| match never {}),

    );

    builder

        .body(body)

        .map_err(|e| HttpError::new(HttpErrorKind::Decode, e))

}

/// The region that holds an S3 bucket, as S3 itself reports it in

/// `x-amz-bucket-region` on any request, even a refused one.

pub fn bucket_region(bucket: &str) -> Option<String> {

    let agent = ureq::AgentBuilder::new()

        .tls_config(tls().ok()?)

        .timeout(Duration::from_secs(30))

        .redirects(0)

        .build();

    // S3's wildcard certificate covers one label: dotted names go by path.

    let url = if bucket.contains('.') {

        format!("https://s3.amazonaws.com/{bucket}")

    } else {

        format!("https://{bucket}.s3.amazonaws.com")

    };

    let resp = match agent.head(&url).call() {

        Ok(r) | Err(ureq::Error::Status(_, r)) => r,

        Err(_) => return None,

    };

    resp.header("x-amz-bucket-region").map(str::to_string)

}

## The Problem

[ What are you trying to solve? Why are you trying to solve it? ]

## The Solution

[ How are you fixing the problem? High-level explanation. ]

### Changes

[ A more detailed explanation of the solution to guide reviewers. Point out tricky or magic areas. ]

### Planned version bump

- Which: [ `MAJOR`, `MINOR`, `PATCH` ]

- Why: [ non-breaking bug fix, doc change, test coverage, formatting, debugging, profiling, security fix, internal change, experimental change, non-breaking new functionality, breaking change, etc ]

### Links

* [ Any important other PRs, Issues, PRs, etc? ]

## Notes

[ @mentions for anyone who should be alerted to this PR ]

[ **Please assign reviewers if you want someone specific to review this** ]

[ **Please do not forget to add labels specific to this PR** ]

name: Release

on:

  workflow_run:

    workflows: [Tests]

    types:

      - completed

  workflow_dispatch:

permissions:

  contents: write

jobs:

  check-trigger:

    name: Check if triggered by tag

    runs-on: ubuntu-latest

    if: github.event.workflow_run.conclusion == 'success'

    outputs:

      is_tag: ${{ steps.check.outputs.is_tag }}

      tag_name: ${{ steps.check.outputs.tag_name }}

    steps:

      - name: Check if workflow was triggered by a version tag

        id: check

        env:

          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

        run: |

          echo "Workflow run event: ${{ github.event.workflow_run.event }}"

          echo "Head branch: ${{ github.event.workflow_run.head_branch }}"

          echo "Head SHA: ${{ github.event.workflow_run.head_sha }}"

          # Get tags for this commit

          TAGS=$(gh api repos/${{ github.repository }}/git/refs/tags --jq '.[] | select(.object.sha == "${{ github.event.workflow_run.head_sha }}") | .ref' | sed 's|refs/tags/||')

          if [ -z "$TAGS" ]; then

            echo "No tags found for this commit"

            echo "is_tag=false" >> $GITHUB_OUTPUT

          else

            # Check if any tag matches version pattern

            VERSION_TAG=$(echo "$TAGS" | grep -E '^[0-9]+\.[0-9]+\.[0-9]+$' | head -n 1)

            if [ -n "$VERSION_TAG" ]; then

              echo "Found version tag: $VERSION_TAG"

              echo "is_tag=true" >> $GITHUB_OUTPUT

              echo "tag_name=$VERSION_TAG" >> $GITHUB_OUTPUT

            else

              echo "Tags found but none match version pattern"

              echo "is_tag=false" >> $GITHUB_OUTPUT

            fi

          fi

  validate:

    name: Validate

    needs: check-trigger

    if: needs.check-trigger.outputs.is_tag == 'true'

    runs-on: ubuntu-latest

    timeout-minutes: 60

    outputs:

      tag_name: ${{ needs.check-trigger.outputs.tag_name }}

    steps:

      - name: Checkout code

        uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust

        with:

          ref: ${{ github.event.workflow_run.head_sha }}

      - name: Setup Rust toolchain

        uses: actions-rust-lang/setup-rust-toolchain@1780873c7b576612439a134613cc4cc74ce5538c # pinned commit for 1.15.2

        with:

          toolchain: stable

          components: rustfmt, clippy

      - name: Check code formatting

        run: cargo fmt --check

      - name: Run clippy

        run: cargo clippy -- -D warnings

      - name: Run tests

        run: cargo test

  build:

    name: Build ${{ matrix.platform }}-${{ matrix.arch }}

    needs: validate

    runs-on: ${{ matrix.os }}

    env:

      TAG_NAME: ${{ needs.validate.outputs.tag_name }}

    strategy:

      fail-fast: false

      matrix:

        include:

          - target: x86_64-unknown-linux-gnu

            os: ubuntu-22.04

            platform: linux

            arch: x86_64

            ext: tar.gz

          - target: i686-unknown-linux-gnu

            os: ubuntu-22.04

            platform: linux

            arch: x86

            ext: tar.gz

          - target: aarch64-unknown-linux-gnu

            os: ubuntu-22.04-arm

            platform: linux

            arch: aarch64

            ext: tar.gz

          - target: aarch64-apple-darwin

            os: macos-14

            platform: macos

            arch: aarch64

            ext: tar.gz

          - target: x86_64-pc-windows-msvc

            os: windows-2022

            platform: windows

            arch: x86_64

            ext: zip

          - target: i686-pc-windows-msvc

            os: windows-2022

            platform: windows

            arch: x86

            ext: zip

          - target: aarch64-pc-windows-msvc

            os: windows-11-arm

            platform: windows

            arch: aarch64

            ext: zip

    steps:

      - name: Checkout code

        uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust

      - name: Setup Rust toolchain

        uses: actions-rust-lang/setup-rust-toolchain@1780873c7b576612439a134613cc4cc74ce5538c # pinned commit for 1.15.2

        with:

          toolchain: stable

      - name: Install cross

        if: matrix.target == 'i686-unknown-linux-gnu'

        run: cargo install cross --git https://github.com/cross-rs/cross

      - name: Build release binaries (native)

        if: matrix.target != 'i686-unknown-linux-gnu'

        run: cargo build --all-features --release --target ${{ matrix.target }}

      - name: Build release binaries (cross)

        if: matrix.target == 'i686-unknown-linux-gnu'

        run: cross build --all-features --release --target ${{ matrix.target }}

      - name: Verify library files (Unix)

        if: runner.os != 'Windows'

        shell: bash

        run: |

          echo "Verifying library files..."

          if [ "${{ matrix.platform }}" = "linux" ]; then

            test -f target/${{ matrix.target }}/release/libcrc_fast.so || { echo "Missing libcrc_fast.so"; exit 1; }

            test -f target/${{ matrix.target }}/release/libcrc_fast.a || { echo "Missing libcrc_fast.a"; exit 1; }

            echo "✓ Found libcrc_fast.so and libcrc_fast.a"

          elif [ "${{ matrix.platform }}" = "macos" ]; then

            test -f target/${{ matrix.target }}/release/libcrc_fast.dylib || { echo "Missing libcrc_fast.dylib"; exit 1; }

            test -f target/${{ matrix.target }}/release/libcrc_fast.a || { echo "Missing libcrc_fast.a"; exit 1; }

            echo "✓ Found libcrc_fast.dylib and libcrc_fast.a"

          fi

      - name: Verify library files (Windows)

        if: runner.os == 'Windows'

        shell: pwsh

        run: |

          Write-Host "Verifying library files..."

          if (-not (Test-Path "target/${{ matrix.target }}/release/crc_fast.dll")) {

            Write-Error "Missing crc_fast.dll"

            exit 1

          }

          if (-not (Test-Path "target/${{ matrix.target }}/release/crc_fast.dll.lib")) {

            Write-Error "Missing crc_fast.dll.lib"

            exit 1

          }

          if (-not (Test-Path "target/${{ matrix.target }}/release/crc_fast.lib")) {

            Write-Error "Missing crc_fast.lib"

            exit 1

          }

          Write-Host "✓ Found crc_fast.dll, crc_fast.dll.lib, and crc_fast.lib"

      - name: Verify CLI binaries (Unix)

        if: runner.os != 'Windows'

        shell: bash

        run: |

          echo "Verifying CLI binaries..."

          test -f target/${{ matrix.target }}/release/checksum || { echo "Missing checksum"; exit 1; }

          test -f target/${{ matrix.target }}/release/arch-check || { echo "Missing arch-check"; exit 1; }

          test -f target/${{ matrix.target }}/release/get-custom-params || { echo "Missing get-custom-params"; exit 1; }

          echo "✓ Found checksum, arch-check, and get-custom-params"

      - name: Verify CLI binaries (Windows)

        if: runner.os == 'Windows'

        shell: pwsh

        run: |

          Write-Host "Verifying CLI binaries..."

          if (-not (Test-Path "target/${{ matrix.target }}/release/checksum.exe")) {

            Write-Error "Missing checksum.exe"

            exit 1

          }

          if (-not (Test-Path "target/${{ matrix.target }}/release/arch-check.exe")) {

            Write-Error "Missing arch-check.exe"

            exit 1

          }

          if (-not (Test-Path "target/${{ matrix.target }}/release/get-custom-params.exe")) {

            Write-Error "Missing get-custom-params.exe"

            exit 1

          }

          Write-Host "✓ Found checksum.exe, arch-check.exe, and get-custom-params.exe"

      - name: Stage Linux package

        if: matrix.platform == 'linux'

        shell: bash

        run: |

          PKG_NAME="crc-fast-$TAG_NAME-${{ matrix.platform }}-${{ matrix.arch }}"

          echo "Creating package directory structure for $PKG_NAME..."

          mkdir -p "$PKG_NAME/lib"

          mkdir -p "$PKG_NAME/include"

          mkdir -p "$PKG_NAME/bin"

          echo "Copying library files..."

          cp target/${{ matrix.target }}/release/libcrc_fast.so "$PKG_NAME/lib/"

          cp target/${{ matrix.target }}/release/libcrc_fast.a "$PKG_NAME/lib/"

          echo "Copying header file..."

          cp libcrc_fast.h "$PKG_NAME/include/"

          echo "Copying CLI binaries..."

          cp target/${{ matrix.target }}/release/checksum "$PKG_NAME/bin/"

          cp target/${{ matrix.target }}/release/arch-check "$PKG_NAME/bin/"

          cp target/${{ matrix.target }}/release/get-custom-params "$PKG_NAME/bin/"

          echo "Setting executable permissions on binaries..."

          chmod +x "$PKG_NAME/bin/checksum"

          chmod +x "$PKG_NAME/bin/arch-check"

          chmod +x "$PKG_NAME/bin/get-custom-params"

          echo "Creating VERSION file..."

          echo "$TAG_NAME" > "$PKG_NAME/VERSION"

          echo "Creating README.txt..."

          cat > "$PKG_NAME/README.txt" <<EOF

          crc-fast Binary Distribution

          Version: $TAG_NAME

          Platform: Linux ${{ matrix.arch }}

          CONTENTS

          ========

          This package contains:

          - Dynamic library (libcrc_fast.so) and static library (libcrc_fast.a)

          - C/C++ header file (libcrc_fast.h)

          - Command-line utilities (checksum, arch-check, get-custom-params)

          INSTALLATION

          ============

          1. Extract this archive to your desired location

          2. Add the lib/ directory to your library path:

             export LD_LIBRARY_PATH=/path/to/crc-fast/lib:$LD_LIBRARY_PATH

          3. Add the bin/ directory to your PATH:

             export PATH=/path/to/crc-fast/bin:$PATH

          For system-wide installation (requires root):

            sudo cp lib/* /usr/local/lib/

            sudo cp include/* /usr/local/include/

            sudo cp bin/* /usr/local/bin/

            sudo ldconfig

          LINKING

          =======

          Dynamic linking:

            gcc your_program.c -lcrc_fast -L/path/to/crc-fast/lib -I/path/to/crc-fast/include

          Static linking:

            gcc your_program.c /path/to/crc-fast/lib/libcrc_fast.a -I/path/to/crc-fast/include

          USAGE

          =====

          Command-line tools:

            checksum --help           # Calculate CRC checksums

            arch-check                # Display CPU architecture features

            get-custom-params --help  # Generate CRC parameters

          DOCUMENTATION

          =============

          Full documentation: https://github.com/awesomized/crc-fast-rust

          LICENSE

          =======

          This software is dual-licensed under MIT OR Apache-2.0.

          See LICENSE-MIT and LICENSE-Apache files for details.

          EOF

          echo "Copying license files..."

          cp LICENSE-MIT "$PKG_NAME/"

          cp LICENSE-Apache "$PKG_NAME/"

          echo "✓ Linux package staged successfully"

          ls -lR "$PKG_NAME"

      - name: Create tar.gz package (Linux)

        if: matrix.platform == 'linux'

        shell: bash

        run: |

          PKG_NAME="crc-fast-$TAG_NAME-${{ matrix.platform }}-${{ matrix.arch }}"

          ARCHIVE_NAME="${PKG_NAME}.tar.gz"

          echo "Creating compressed archive: $ARCHIVE_NAME"

          tar -czf "$ARCHIVE_NAME" "$PKG_NAME"

          echo "Verifying archive was created..."

          test -f "$ARCHIVE_NAME" || { echo "Failed to create $ARCHIVE_NAME"; exit 1; }

          echo "Archive details:"

          ls -lh "$ARCHIVE_NAME"

          echo "✓ tar.gz package created successfully"

      - name: Generate SHA256 checksum (Linux)

        if: matrix.platform == 'linux'

        shell: bash

        run: |

          ARCHIVE_NAME="crc-fast-$TAG_NAME-${{ matrix.platform }}-${{ matrix.arch }}.tar.gz"

          CHECKSUM_FILE="${ARCHIVE_NAME}.sha256"

          echo "Generating SHA256 checksum for $ARCHIVE_NAME..."

          sha256sum "$ARCHIVE_NAME" > "$CHECKSUM_FILE"

          echo "Verifying checksum file was created..."

          test -f "$CHECKSUM_FILE" || { echo "Failed to create $CHECKSUM_FILE"; exit 1; }

          echo "Checksum file contents:"

          cat "$CHECKSUM_FILE"

          echo "✓ SHA256 checksum generated successfully"

      - name: Stage macOS package

        if: matrix.platform == 'macos'

        shell: bash

        run: |

          PKG_NAME="crc-fast-$TAG_NAME-${{ matrix.platform }}-${{ matrix.arch }}"

          echo "Creating package directory structure for $PKG_NAME..."

          mkdir -p "$PKG_NAME/lib"

          mkdir -p "$PKG_NAME/include"

          mkdir -p "$PKG_NAME/bin"

          echo "Copying library files..."

          cp target/${{ matrix.target }}/release/libcrc_fast.dylib "$PKG_NAME/lib/"

          cp target/${{ matrix.target }}/release/libcrc_fast.a "$PKG_NAME/lib/"

          echo "Copying header file..."

          cp libcrc_fast.h "$PKG_NAME/include/"

          echo "Copying CLI binaries..."

          cp target/${{ matrix.target }}/release/checksum "$PKG_NAME/bin/"

          cp target/${{ matrix.target }}/release/arch-check "$PKG_NAME/bin/"

          cp target/${{ matrix.target }}/release/get-custom-params "$PKG_NAME/bin/"

          echo "Setting executable permissions on binaries..."

          chmod +x "$PKG_NAME/bin/checksum"

          chmod +x "$PKG_NAME/bin/arch-check"

          chmod +x "$PKG_NAME/bin/get-custom-params"

          echo "Creating VERSION file..."

          echo "$TAG_NAME" > "$PKG_NAME/VERSION"

          echo "Creating README.txt..."

          cat > "$PKG_NAME/README.txt" <<EOF

          crc-fast Binary Distribution

          Version: $TAG_NAME

          Platform: macOS ${{ matrix.arch }}

          CONTENTS

          ========

          This package contains:

          - Dynamic library (libcrc_fast.dylib) and static library (libcrc_fast.a)

          - C/C++ header file (libcrc_fast.h)

          - Command-line utilities (checksum, arch-check, get-custom-params)

          INSTALLATION

          ============

          1. Extract this archive to your desired location

          2. Add the lib/ directory to your library path:

             export DYLD_LIBRARY_PATH=/path/to/crc-fast/lib:$DYLD_LIBRARY_PATH

          3. Add the bin/ directory to your PATH:

             export PATH=/path/to/crc-fast/bin:$PATH

          For system-wide installation:

            sudo cp lib/* /usr/local/lib/

            sudo cp include/* /usr/local/include/

            sudo cp bin/* /usr/local/bin/

          LINKING

          =======

          Dynamic linking:

            clang your_program.c -lcrc_fast -L/path/to/crc-fast/lib -I/path/to/crc-fast/include

          Static linking:

            clang your_program.c /path/to/crc-fast/lib/libcrc_fast.a -I/path/to/crc-fast/include

          USAGE

          =====

          Command-line tools:

            checksum --help           # Calculate CRC checksums

            arch-check                # Display CPU architecture features

            get-custom-params --help  # Generate CRC parameters

          DOCUMENTATION

          =============

          Full documentation: https://github.com/awesomized/crc-fast-rust

          LICENSE

          =======

          This software is dual-licensed under MIT OR Apache-2.0.

          See LICENSE-MIT and LICENSE-Apache files for details.

          EOF

          echo "Copying license files..."

          cp LICENSE-MIT "$PKG_NAME/"

          cp LICENSE-Apache "$PKG_NAME/"

          echo "✓ macOS package staged successfully"

          ls -lR "$PKG_NAME"

      - name: Create tar.gz package (macOS)

        if: matrix.platform == 'macos'

        shell: bash

        run: |

          PKG_NAME="crc-fast-$TAG_NAME-${{ matrix.platform }}-${{ matrix.arch }}"

          ARCHIVE_NAME="${PKG_NAME}.tar.gz"

          echo "Creating compressed archive: $ARCHIVE_NAME"

          tar -czf "$ARCHIVE_NAME" "$PKG_NAME"

          echo "Verifying archive was created..."

          test -f "$ARCHIVE_NAME" || { echo "Failed to create $ARCHIVE_NAME"; exit 1; }

          echo "Archive details:"

          ls -lh "$ARCHIVE_NAME"

          echo "✓ tar.gz package created successfully"

      - name: Generate SHA256 checksum (macOS)

        if: matrix.platform == 'macos'

        shell: bash

        run: |

          ARCHIVE_NAME="crc-fast-$TAG_NAME-${{ matrix.platform }}-${{ matrix.arch }}.tar.gz"

          CHECKSUM_FILE="${ARCHIVE_NAME}.sha256"

          echo "Generating SHA256 checksum for $ARCHIVE_NAME..."

          shasum -a 256 "$ARCHIVE_NAME" > "$CHECKSUM_FILE"

          echo "Verifying checksum file was created..."

          test -f "$CHECKSUM_FILE" || { echo "Failed to create $CHECKSUM_FILE"; exit 1; }

          echo "Checksum file contents:"

          cat "$CHECKSUM_FILE"

          echo "✓ SHA256 checksum generated successfully"

      - name: Stage Windows package

        if: matrix.platform == 'windows'

        shell: pwsh

        run: |

          $PKG_NAME = "crc-fast-$env:TAG_NAME-${{ matrix.platform }}-${{ matrix.arch }}"

          Write-Host "Creating package directory structure for $PKG_NAME..."

          New-Item -ItemType Directory -Path "$PKG_NAME/bin" -Force | Out-Null

          New-Item -ItemType Directory -Path "$PKG_NAME/lib" -Force | Out-Null

          New-Item -ItemType Directory -Path "$PKG_NAME/include" -Force | Out-Null

          Write-Host "Copying library files..."

          Copy-Item "target/${{ matrix.target }}/release/crc_fast.dll" "$PKG_NAME/bin/"

          Copy-Item "target/${{ matrix.target }}/release/crc_fast.dll.lib" "$PKG_NAME/lib/"

          Copy-Item "target/${{ matrix.target }}/release/crc_fast.lib" "$PKG_NAME/lib/"

          Write-Host "Copying header file..."

          Copy-Item "libcrc_fast.h" "$PKG_NAME/include/"

          Write-Host "Copying CLI binaries..."

          Copy-Item "target/${{ matrix.target }}/release/checksum.exe" "$PKG_NAME/bin/"

          Copy-Item "target/${{ matrix.target }}/release/arch-check.exe" "$PKG_NAME/bin/"

          Copy-Item "target/${{ matrix.target }}/release/get-custom-params.exe" "$PKG_NAME/bin/"

          Write-Host "Creating VERSION file..."

          "$env:TAG_NAME" | Out-File -FilePath "$PKG_NAME/VERSION" -Encoding utf8 -NoNewline

          Write-Host "Creating README.txt..."

          @"

          crc-fast Binary Distribution

          Version: $env:TAG_NAME

          Platform: Windows ${{ matrix.arch }}

          CONTENTS

          ========

          This package contains:

          - Dynamic library (crc_fast.dll) with import library (crc_fast.dll.lib)

          - Static library (crc_fast.lib)

          - C/C++ header file (libcrc_fast.h)

          - Command-line utilities (checksum.exe, arch-check.exe, get-custom-params.exe)

          INSTALLATION

          ============

          1. Extract this archive to your desired location

          2. Add the bin\ directory to your PATH environment variable:

             - Open System Properties > Environment Variables

             - Edit the PATH variable and add: C:\path\to\crc-fast\bin

          For development:

            - Add lib\ directory to your linker library path

            - Add include\ directory to your compiler include path

          LINKING

          =======

          Dynamic linking (MSVC):

            cl your_program.c /I"C:\path\to\crc-fast\include" /link crc_fast.dll.lib /LIBPATH:"C:\path\to\crc-fast\lib"

            Note: crc_fast.dll must be in PATH or same directory as your executable

          Static linking (MSVC):

            cl your_program.c /I"C:\path\to\crc-fast\include" /link crc_fast.lib /LIBPATH:"C:\path\to\crc-fast\lib"

          Dynamic linking (MinGW):

            gcc your_program.c -I"C:\path\to\crc-fast\include" -L"C:\path\to\crc-fast\lib" -lcrc_fast

          USAGE

          =====

          Command-line tools:

            checksum.exe --help           # Calculate CRC checksums

            arch-check.exe                # Display CPU architecture features

            get-custom-params.exe --help  # Generate CRC parameters

          DOCUMENTATION

          =============

          Full documentation: https://github.com/awesomized/crc-fast-rust

          LICENSE

          =======

          This software is dual-licensed under MIT OR Apache-2.0.

          See LICENSE-MIT and LICENSE-Apache files for details.

          "@ | Out-File -FilePath "$PKG_NAME/README.txt" -Encoding utf8

          Write-Host "Copying license files..."

          Copy-Item "LICENSE-MIT" "$PKG_NAME/"

          Copy-Item "LICENSE-Apache" "$PKG_NAME/"

          Write-Host "✓ Windows package staged successfully"

          Get-ChildItem -Recurse "$PKG_NAME"

      - name: Create zip package (Windows)

        if: matrix.platform == 'windows'

        shell: pwsh

        run: |

          $PKG_NAME = "crc-fast-$env:TAG_NAME-${{ matrix.platform }}-${{ matrix.arch }}"

          $ARCHIVE_NAME = "${PKG_NAME}.zip"

          Write-Host "Creating compressed archive: $ARCHIVE_NAME"

          Compress-Archive -Path "$PKG_NAME" -DestinationPath "$ARCHIVE_NAME" -CompressionLevel Optimal

          Write-Host "Verifying archive was created..."

          if (-not (Test-Path "$ARCHIVE_NAME")) {

            Write-Error "Failed to create $ARCHIVE_NAME"

            exit 1

          }

          Write-Host "Archive details:"

          Get-Item "$ARCHIVE_NAME" | Format-List Name, Length, LastWriteTime

          Write-Host "✓ zip package created successfully"

      - name: Generate SHA256 checksum (Windows)

        if: matrix.platform == 'windows'

        shell: pwsh

        run: |

          $ARCHIVE_NAME = "crc-fast-$env:TAG_NAME-${{ matrix.platform }}-${{ matrix.arch }}.zip"

          $CHECKSUM_FILE = "${ARCHIVE_NAME}.sha256"

          Write-Host "Generating SHA256 checksum for $ARCHIVE_NAME..."

          $hash = (Get-FileHash -Path "$ARCHIVE_NAME" -Algorithm SHA256).Hash.ToLower()

          "$hash  $ARCHIVE_NAME" | Out-File -FilePath "$CHECKSUM_FILE" -Encoding utf8 -NoNewline

          Write-Host "Verifying checksum file was created..."

          if (-not (Test-Path "$CHECKSUM_FILE")) {

            Write-Error "Failed to create $CHECKSUM_FILE"

            exit 1

          }

          Write-Host "Checksum file contents:"

          Get-Content "$CHECKSUM_FILE"

          Write-Host "✓ SHA256 checksum generated successfully"

      - name: Upload package artifact

        uses: actions/upload-artifact@v4 # not pinning to commit hash since this is a GitHub action, which we trust

        with:

          name: crc-fast-${{ needs.validate.outputs.tag_name }}-${{ matrix.platform }}-${{ matrix.arch }}.${{ matrix.ext }}

          path: crc-fast-${{ needs.validate.outputs.tag_name }}-${{ matrix.platform }}-${{ matrix.arch }}.${{ matrix.ext }}

          if-no-files-found: error

          retention-days: 90

      - name: Upload checksum artifact

        uses: actions/upload-artifact@v4 # not pinning to commit hash since this is a GitHub action, which we trust

        with:

          name: crc-fast-${{ needs.validate.outputs.tag_name }}-${{ matrix.platform }}-${{ matrix.arch }}.${{ matrix.ext }}.sha256

          path: crc-fast-${{ needs.validate.outputs.tag_name }}-${{ matrix.platform }}-${{ matrix.arch }}.${{ matrix.ext }}.sha256

          if-no-files-found: error

          retention-days: 90

  publish:

    name: Publish

    needs: [validate, build]

    runs-on: ubuntu-latest

    env:

      TAG_NAME: ${{ needs.validate.outputs.tag_name }}

    steps:

      - name: Download all artifacts

        uses: actions/download-artifact@v4 # not pinning to commit hash since this is a GitHub action, which we trust

        with:

          path: artifacts

          merge-multiple: false

      - name: Check for existing release

        id: check_release

        shell: bash

        env:

          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

        run: |

          echo "Checking if release exists for tag: $TAG_NAME"

          RELEASE_DATA=$(curl -s -H "Authorization: Bearer $GITHUB_TOKEN" \

            -H "Accept: application/vnd.github+json" \

            "https://api.github.com/repos/${{ github.repository }}/releases/tags/$TAG_NAME")

          if echo "$RELEASE_DATA" | jq -e '.id' > /dev/null 2>&1; then

            RELEASE_ID=$(echo "$RELEASE_DATA" | jq -r '.id')

            echo "release_exists=true" >> $GITHUB_OUTPUT

            echo "release_id=$RELEASE_ID" >> $GITHUB_OUTPUT

            echo "✓ Release already exists with ID: $RELEASE_ID"

          else

            echo "release_exists=false" >> $GITHUB_OUTPUT

            echo "release_id=" >> $GITHUB_OUTPUT

            echo "✓ No existing release found for this tag"

          fi

      - name: Organize files for upload

        shell: bash

        run: |

          echo "Organizing downloaded artifacts..."

          mkdir -p release-assets

          echo "Moving packages and checksums to release-assets directory..."

          find artifacts -type f \( -name "*.tar.gz" -o -name "*.zip" -o -name "*.sha256" \) -exec mv {} release-assets/ \;

          echo "Release assets ready for upload:"

          ls -lh release-assets/

          echo "Verifying all expected files are present..."

          EXPECTED_FILES=(

            "crc-fast-$TAG_NAME-linux-x86_64.tar.gz"

            "crc-fast-$TAG_NAME-linux-x86_64.tar.gz.sha256"

            "crc-fast-$TAG_NAME-linux-x86.tar.gz"

            "crc-fast-$TAG_NAME-linux-x86.tar.gz.sha256"

            "crc-fast-$TAG_NAME-linux-aarch64.tar.gz"

            "crc-fast-$TAG_NAME-linux-aarch64.tar.gz.sha256"

            "crc-fast-$TAG_NAME-macos-aarch64.tar.gz"

            "crc-fast-$TAG_NAME-macos-aarch64.tar.gz.sha256"

            "crc-fast-$TAG_NAME-windows-x86_64.zip"

            "crc-fast-$TAG_NAME-windows-x86_64.zip.sha256"

            "crc-fast-$TAG_NAME-windows-x86.zip"

            "crc-fast-$TAG_NAME-windows-x86.zip.sha256"

            "crc-fast-$TAG_NAME-windows-aarch64.zip"

            "crc-fast-$TAG_NAME-windows-aarch64.zip.sha256"

          )

          MISSING_FILES=()

          for file in "${EXPECTED_FILES[@]}"; do

            if [ ! -f "release-assets/$file" ]; then

              MISSING_FILES+=("$file")

            fi

          done

          if [ ${#MISSING_FILES[@]} -gt 0 ]; then

            echo "ERROR: Missing expected files:"

            printf '%s\n' "${MISSING_FILES[@]}"

            exit 1

          fi

          echo "✓ All expected files are present"

          echo "Total number of files: $(ls -1 release-assets/ | wc -l)"

          echo "Total size: $(du -sh release-assets/ | cut -f1)"

      - name: Create or update GitHub release

        uses: softprops/action-gh-release@6da8fa9354ddfdc4aeace5fc48d7f679b5214090 # pinned commit for 2.4.1

        with:

          files: release-assets/*

          draft: true

          prerelease: false

          fail_on_unmatched_files: true

          generate_release_notes: true

        env:

          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

name: Tests

on:

  push:

  pull_request:

  workflow_dispatch:

jobs:

  check-previous-run:

    name: Check for previous successful run

    runs-on: ubuntu-latest

    outputs:

      should_skip: ${{ steps.check.outputs.should_skip }}

    steps:

      - name: Check if commit was already tested

        id: check

        env:

          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

        run: |

          echo "Current commit: ${{ github.sha }}"

          echo "Current ref: ${{ github.ref }}"

          # Check if there's a previous successful workflow run for this exact commit

          PREVIOUS_RUN=$(gh api \

            -H "Accept: application/vnd.github+json" \

            "/repos/${{ github.repository }}/actions/workflows/tests.yml/runs?status=success&per_page=5" \

            --jq '.workflow_runs[] | select(.head_sha == "${{ github.sha }}") | .id' \

            | head -n 1)

          if [ -n "$PREVIOUS_RUN" ] && [ "$PREVIOUS_RUN" != "${{ github.run_id }}" ]; then

            echo "Found previous successful run: $PREVIOUS_RUN"

            echo "should_skip=true" >> $GITHUB_OUTPUT

          else

            echo "No previous successful run found for this commit"

            echo "should_skip=false" >> $GITHUB_OUTPUT

          fi

  test-aarch64:

    name: Test aarch64

    needs: check-previous-run

    if: needs.check-previous-run.outputs.should_skip != 'true'

    strategy:

      matrix:

        os: [ubuntu-22.04-arm, ubuntu-24.04-arm, macos-14, macos-15, macos-26, macos-latest, windows-11-arm]

        rust-toolchain:

          - "1.89" # minimum for this crate, when AVX-512 VPCLMULQDQ was stabilized

          - "stable"

          - "nightly"

    runs-on: ${{ matrix.os }}

    steps:

      - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust

      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0

        with:

          toolchain: ${{ matrix.rust-toolchain }}

          components: rustfmt, clippy

          cache-key: ${{ matrix.os }}-${{ matrix.rust-toolchain }}-v2

      - name: Check

        run: cargo check --all-features

      - name: Architecture check

        run: cargo run --features cli --bin arch-check

      - if: ${{ matrix.rust-toolchain != 'nightly' }}

        name: Format

        run: cargo fmt -- --check

      - if: ${{ matrix.rust-toolchain != 'nightly' }}

        name: Clippy

        run: cargo clippy --all-features -- -D warnings

      - name: Test

        run: cargo test --all-features

  test-x86_64:

    name: Test x86_64

    needs: check-previous-run

    if: needs.check-previous-run.outputs.should_skip != 'true'

    strategy:

      matrix:

        os: [ ubuntu-latest, ubuntu-22.04, ubuntu-24.04, macos-15-intel, windows-2022, windows-2025, windows-latest ]

        rust-toolchain:

          - "1.89" # minimum for this crate, when AVX-512 VPCLMULQDQ was stabilized

          - "stable"

          - "nightly"

    runs-on: ${{ matrix.os }}

    steps:

      - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust

      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0

        with:

          toolchain: ${{ matrix.rust-toolchain }}

          components: rustfmt, clippy

          cache-key: ${{ matrix.os }}-${{ matrix.rust-toolchain }}-v2

      - name: Check

        run: cargo check --all-features

      - name: Architecture check

        run: cargo run --features cli --bin arch-check

      - if: ${{ matrix.rust-toolchain != 'nightly' }}

        name: Format

        run: cargo fmt -- --check

      - if: ${{ matrix.rust-toolchain != 'nightly' }}

        name: Clippy

        run: cargo clippy --all-features -- -D warnings

      - name: Test

        run: cargo test --all-features

  test-x86-linux:

    name:  Test x86 Linux

    needs: check-previous-run

    if: needs.check-previous-run.outputs.should_skip != 'true'

    runs-on: ubuntu-latest

    strategy:

      matrix:

        target: [i586-unknown-linux-gnu, i686-unknown-linux-gnu]

        rust-toolchain:

          - "1.89" # minimum for this crate, when AVX-512 VPCLMULQDQ was stabilized

          - "stable"

          - "nightly"

    steps:

      - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust

      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0

        with:

          toolchain: ${{ matrix.rust-toolchain }}

          components: rustfmt, clippy

      - name: Set up cross

        run: cargo install cross --locked --version 0.2.5

      - name: Check

        run: cross check --all-features --target ${{ matrix.target }}

      - name: Architecture check

        run: cross run --features cli --bin arch-check --target ${{ matrix.target }}

      - name: Test

        run: cross test --all-features --target ${{ matrix.target }}

  test-x86-windows:

    name: Test x86 Windows

    needs: check-previous-run

    if: needs.check-previous-run.outputs.should_skip != 'true'

    runs-on: windows-2022

    strategy:

      matrix:

        rust-toolchain:

          - "1.89" # minimum for this crate, when AVX-512 VPCLMULQDQ was stabilized

          - "stable"

          - "nightly"

    steps:

      - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust

      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0

        with:

          toolchain: ${{ matrix.rust-toolchain }}

          target: i686-pc-windows-msvc

          components: rustfmt, clippy

          cache-key: windows-x86-${{ matrix.rust-toolchain }}

      - name: Check

        run: cargo check --all-features --target i686-pc-windows-msvc

      - name: Architecture check

        run: cargo run --features cli --bin arch-check --target i686-pc-windows-msvc

      - if: ${{ matrix.rust-toolchain != 'nightly' }}

        name: Format

        run: cargo fmt -- --check

      - if: ${{ matrix.rust-toolchain != 'nightly' }}

        name: Clippy

        run: cargo clippy --all-features --target i686-pc-windows-msvc -- -D warnings

      - name: Test

        run: cargo test --all-features --target i686-pc-windows-msvc

  test-software:

    name: Test software fallback

    needs: check-previous-run

    if: needs.check-previous-run.outputs.should_skip != 'true'

    runs-on: ubuntu-latest

    strategy:

      matrix:

        target: [powerpc-unknown-linux-gnu, powerpc64-unknown-linux-gnu]

        rust-toolchain:

          - "1.89" # minimum for this crate, when AVX-512 VPCLMULQDQ was stabilized

          - "stable"

          - "nightly"

    steps:

      - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust

      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0

        with:

          toolchain: ${{ matrix.rust-toolchain }}

          components: rustfmt, clippy

      - name: Set up cross

        run: cargo install cross --locked --version 0.2.5

      - name: Check

        run: cross check --all-features --target ${{ matrix.target }}

      - name: Architecture check

        run: cross run --features cli --bin arch-check --target ${{ matrix.target }}

      - name: Test

        run: cross test --all-features --target ${{ matrix.target }}

  miri-test-x86_64:

    name: Miri Test x86_64

    needs: [check-previous-run, test-x86_64]

    if: needs.check-previous-run.outputs.should_skip != 'true'

    runs-on: ubuntu-24.04

    steps:

      - uses: actions/checkout@v4

      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9

        with:

          toolchain: nightly

          components: miri

      - name: Detect CPU cores

        id: cores

        run: |

          CORES=$(nproc)

          echo "count=$CORES" >> $GITHUB_OUTPUT

          echo "use_nextest=$([[ $CORES -ge 2 ]] && echo 'true' || echo 'false')" >> $GITHUB_OUTPUT

      - name: Install nextest

        if: steps.cores.outputs.use_nextest == 'true'

        run: cargo install cargo-nextest --locked

      - name: Setup Miri

        run: cargo miri setup

      - name: Run Miri tests (parallel)

        if: steps.cores.outputs.use_nextest == 'true'

        run: cargo miri nextest run --all-features -j${{ steps.cores.outputs.count }}

      - name: Run Miri tests (serial)

        if: steps.cores.outputs.use_nextest == 'false'

        run: cargo miri test --all-features

  test-no-std:

    name: Test no_std

    needs: check-previous-run

    if: needs.check-previous-run.outputs.should_skip != 'true'

    runs-on: ubuntu-latest

    strategy:

      matrix:

        target:

          - thumbv7em-none-eabihf  # ARM Cortex-M4F/M7F

          - thumbv8m.main-none-eabihf  # ARM Cortex-M33/M35P

          - riscv32imac-unknown-none-elf  # RISC-V 32-bit

        rust-toolchain:

          - "1.89" # minimum for this crate, when AVX-512 VPCLMULQDQ was stabilized

          - "stable"

          - "nightly"

    steps:

      - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust

      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0

        with:

          toolchain: ${{ matrix.rust-toolchain }}

          target: ${{ matrix.target }}

          components: rustfmt, clippy

          cache-key: ${{ matrix.target }}-${{ matrix.rust-toolchain }}-v2

      - name: Check no_std (no features)

        run: cargo check --target ${{ matrix.target }} --no-default-features --features panic-handler --lib

      - name: Check no_std with alloc

        run: cargo check --target ${{ matrix.target }} --no-default-features --features alloc,panic-handler --lib

      - name: Check no_std with cache

        run: cargo check --target ${{ matrix.target }} --no-default-features --features cache,panic-handler --lib

      - name: Run no_std tests (on host with std test harness)

        run: cargo test --test no_std_tests

  test-wasm:

    name: Test WASM

    needs: check-previous-run

    if: needs.check-previous-run.outputs.should_skip != 'true'

    runs-on: ubuntu-latest

    strategy:

      matrix:

        include:

          # WASM 1.0/2.0 (32-bit) - all toolchains

          - target: wasm32-unknown-unknown

            rust-toolchain: "1.89" # minimum for this crate, when AVX-512 VPCLMULQDQ was stabilized

          - target: wasm32-unknown-unknown

            rust-toolchain: "stable"

          - target: wasm32-unknown-unknown

            rust-toolchain: "nightly"

          # WASI preview 1 (32-bit) - all toolchains

          - target: wasm32-wasip1

            rust-toolchain: "1.89" # minimum for this crate, when AVX-512 VPCLMULQDQ was stabilized

          - target: wasm32-wasip1

            rust-toolchain: "stable"

          - target: wasm32-wasip1

            rust-toolchain: "nightly"

          # WASI preview 2 (32-bit) - nightly only (experimental)

          - target: wasm32-wasip2

            rust-toolchain: "nightly"

          # Note: wasm64-unknown-unknown removed - not consistently available in nightly

    steps:

      - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust

      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0

        with:

          toolchain: ${{ matrix.rust-toolchain }}

          target: ${{ matrix.target }}

          components: rustfmt, clippy

          cache-key: ${{ matrix.target }}-${{ matrix.rust-toolchain }}-v2

      - name: Check WASM (no features)

        run: cargo check --target ${{ matrix.target }} --no-default-features --features panic-handler --lib

      - name: Check WASM with alloc

        run: cargo check --target ${{ matrix.target }} --no-default-features --features alloc,panic-handler --lib

      - name: Check WASM with cache

        run: cargo check --target ${{ matrix.target }} --no-default-features --features cache,panic-handler --lib

      - name: Build WASM release

        run: cargo build --target ${{ matrix.target }} --no-default-features --features alloc,panic-handler --lib --release

      - name: Run WASM tests (on host with std test harness)

        run: cargo test --test wasm_tests

      - if: ${{ matrix.target == 'wasm32-unknown-unknown' && matrix.rust-toolchain == 'stable' }}

        name: Install wasm-pack

        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh

      - if: ${{ matrix.target == 'wasm32-unknown-unknown' && matrix.rust-toolchain == 'stable' }}

        name: Build WASM package with wasm-pack

        run: wasm-pack build --target web --no-default-features --features alloc,panic-handler

  fuzz-test:

    name: Fuzz Testing

    needs: check-previous-run

    if: needs.check-previous-run.outputs.should_skip != 'true'

    runs-on: ${{ matrix.os }}

    strategy:

      fail-fast: false

      matrix:

        os: [ubuntu-24.04, ubuntu-24.04-arm]

        fuzz-target:

          - digest_crc32_autosar

          - digest_crc32_bzip2

          - digest_crc32_iscsi

          - digest_crc32_iso_hdlc

          - digest_crc64_ecma_182

          - digest_crc64_nvme

          - checksum_crc32_autosar

          - checksum_crc32_bzip2

          - checksum_crc32_iscsi

          - checksum_crc32_iso_hdlc

          - checksum_crc64_ecma_182

          - checksum_crc64_nvme

    steps:

      - uses: actions/checkout@v4 # not pinning to commit hash since this is a GitHub action, which we trust

      - uses: actions-rust-lang/setup-rust-toolchain@9d7e65c320fdb52dcd45ffaa68deb6c02c8754d9 # v1.12.0

        with:

          toolchain: nightly

          cache-key: ${{ matrix.os }}-nightly-fuzz

      - name: Install cargo-fuzz

        run: cargo install cargo-fuzz

      - name: Run fuzzer

        run: |

          cargo fuzz run ${{ matrix.fuzz-target }} -- \

            -max_total_time=60 \

            -rss_limit_mb=2048 \

            -timeout=10 \

            -print_final_stats=1

        continue-on-error: true

      - name: Upload artifacts on crash

        if: failure()

        uses: actions/upload-artifact@v4

        with:

          name: fuzz-artifacts-${{ matrix.os }}-${{ matrix.fuzz-target }}

          path: fuzz/artifacts/${{ matrix.fuzz-target }}/

  tests-complete:

    name: All tests complete

    needs: [check-previous-run, test-aarch64, test-x86_64, test-x86-linux, test-x86-windows, test-software, miri-test-x86_64, test-no-std, test-wasm, fuzz-test]

    if: always()

    runs-on: ubuntu-latest

    steps:

      - name: Check test results

        run: |

          echo "Checking test results..."

          echo "Previous run check: ${{ needs.check-previous-run.result }}"

          echo "Should skip: ${{ needs.check-previous-run.outputs.should_skip }}"

          if [ "${{ needs.check-previous-run.outputs.should_skip }}" == "true" ]; then

            echo "✓ Tests were skipped because this commit was already tested successfully"

            exit 0

          fi

          # Check if any test job failed

          if [ "${{ needs.test-aarch64.result }}" == "failure" ] || \

             [ "${{ needs.test-x86_64.result }}" == "failure" ] || \

             [ "${{ needs.test-x86-linux.result }}" == "failure" ] || \

             [ "${{ needs.test-x86-windows.result }}" == "failure" ] || \

             [ "${{ needs.test-software.result }}" == "failure" ] || \

             [ "${{ needs.miri-test-x86_64.result }}" == "failure" ] || \

             [ "${{ needs.test-no-std.result }}" == "failure" ] || \

             [ "${{ needs.test-wasm.result }}" == "failure" ] || \

             [ "${{ needs.fuzz-test.result }}" == "failure" ]; then

            echo "✗ One or more test jobs failed"

            exit 1

          fi

          echo "✓ All test jobs passed"

/target

/scratch

/test/test_*.bin

.idea

.DS_Store

.git

.vscode

/scripts

# Design Document

## Overview

This design extends the existing `bin/checksum.rs` tool with benchmark functionality through a new `-b` flag. The benchmark mode will measure CRC performance using either user-provided data (files/strings) or randomly generated data, reporting throughput in GiB/s along with the acceleration target used.

The design maintains backward compatibility while adding a clean benchmark interface that leverages existing patterns from the `benches/benchmark.rs` implementation.

## Architecture

### Command Line Interface

The tool will extend the existing argument parsing to support:

- `-b`: Enable benchmark mode

- `--size <bytes>`: Specify data size for random generation (when no file/string provided)

- `--duration <seconds>`: Benchmark duration as floating-point seconds (default: 10.0)

- Existing `-a <algorithm>`: CRC algorithm (required in benchmark mode)

- Existing `-f <file>` or `-s <string>`: Optional data source for benchmarking

### Data Flow

```

User Input → Argument Parsing → Mode Detection → Benchmark Execution → Results Display

                                      ↓

                              [Normal Checksum Mode]

                                      ↓

                              [Existing Functionality]

```

In benchmark mode:

1. Parse and validate benchmark parameters

2. Determine data source (file, string, or generated)

3. For string/generated data: Load/generate test data once; For file data: use file path directly

4. Run benchmark loop for specified duration using appropriate checksum function

5. Calculate and display results

## Components and Interfaces

### Enhanced Config Structure

```rust

#[derive(Debug)]

struct Config {

    algorithm: String,

    file: Option<String>,

    string: Option<String>,

    format: OutputFormat,

    benchmark: Option<BenchmarkConfig>,

}

#[derive(Debug)]

struct BenchmarkConfig {