rust-release-reusable.yml

name: Reusable Rust Release Workflow

on:
  workflow_call:
    inputs:
      repository:
        description: 'Repository to release (e.g., GoPlasmatic/datalogic-rs)'
        required: true
        type: string
      package-type:
        description: 'Package type: library or application'
        required: false
        type: string
        default: 'library'
      skip-publish:
        description: 'Skip publishing to crates.io (for applications or testing)'
        required: false
        type: boolean
        default: false
      dry-run:
        description: 'Dry run (skip publishing)'
        required: false
        type: boolean
        default: false
      docker-enabled:
        description: 'Enable Docker image build and push'
        required: false
        type: boolean
        default: false
      docker-image-name:
        description: 'Docker image name (defaults to package name)'
        required: false
        type: string
    secrets:
      GH_PAT:
        description: 'GitHub Personal Access Token for pushing tags'
        required: true
      CRATES_IO_TOKEN:
        description: 'Token for publishing to crates.io'
        required: false
      ACR_URL:
        description: 'Azure Container Registry URL (e.g., myregistry.azurecr.io)'
        required: false
      ACR_USERNAME:
        description: 'Azure Container Registry username (service principal ID or username)'
        required: false
      ACR_PASSWORD:
        description: 'Azure Container Registry password or token'
        required: false

env:
  CARGO_TERM_COLOR: always
  RUST_BACKTRACE: 1

jobs:
  release:
    runs-on: ubuntu-latest
    
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
        with:
          repository: ${{ inputs.repository }}
          fetch-depth: 0
          token: ${{ secrets.GH_PAT }}
      
      - name: Setup Rust
        uses: dtolnay/rust-toolchain@stable
        with:
          components: rustfmt, clippy
      
      - name: Cache cargo dependencies
        uses: Swatinem/rust-cache@v2
        with:
          key: ${{ inputs.repository }}
          cache-on-failure: true
      
      - name: Install cargo-workspaces (if needed)
        run: |
          # Check if this is a workspace
          PACKAGE_COUNT=$(cargo metadata --no-deps --format-version 1 | jq '.packages | length')
          if [ "$PACKAGE_COUNT" -gt 1 ] && [ "${{ inputs.package-type }}" = "library" ]; then
            echo "Installing cargo-workspaces for better dependency handling..."
            cargo install cargo-workspaces || echo "cargo-workspaces installation failed, will use fallback method"
          fi
      
      - name: Check code formatting
        run: cargo fmt -- --check
        
      - name: Run clippy
        run: cargo clippy -- -D warnings
      
      - name: Run tests
        run: cargo test --all-features
      
      - name: Get package info
        id: package_info
        run: |
          # Check if this is a workspace or single package
          PACKAGE_COUNT=$(cargo metadata --no-deps --format-version 1 | jq '.packages | length')
          
          if [ "$PACKAGE_COUNT" -gt 1 ]; then
            # For workspace, find all publishable packages in dependency order
            echo "Workspace with $PACKAGE_COUNT packages detected"
            
            # Get all publishable packages
            PUBLISHABLE_PACKAGES=$(cargo metadata --no-deps --format-version 1 | jq -r '.packages[] | select(.publish != false) | .name' | tr '\n' ' ')
            echo "Publishable packages: $PUBLISHABLE_PACKAGES"
            
            # For now, we'll handle the main package (this will be improved for dependency ordering)
            if [ "${{ inputs.package-type }}" = "application" ]; then
              # Find binary package
              PACKAGE_NAME=$(cargo metadata --no-deps --format-version 1 | jq -r '.packages[] | select(.targets[]?.kind[]? == "bin") | .name' | head -n1)
            else
              # Find main library package (usually doesn't have -macros, -derive, etc. suffix)
              PACKAGE_NAME=$(cargo metadata --no-deps --format-version 1 | jq -r '.packages[] | select(.publish != false) | select(.name | test("-macros$|-derive$|-core$") | not) | .name' | head -n1)
            fi
            PACKAGE_VERSION=$(cargo metadata --no-deps --format-version 1 | jq -r ".packages[] | select(.name == \"$PACKAGE_NAME\") | .version")
            
            # Store all publishable packages for later use
            echo "publishable_packages=$PUBLISHABLE_PACKAGES" >> $GITHUB_OUTPUT
          else
            # Single package
            PACKAGE_NAME=$(cargo metadata --no-deps --format-version 1 | jq -r '.packages[0].name')
            PACKAGE_VERSION=$(cargo metadata --no-deps --format-version 1 | jq -r '.packages[0].version')
            echo "publishable_packages=$PACKAGE_NAME" >> $GITHUB_OUTPUT
          fi
          
          echo "name=$PACKAGE_NAME" >> $GITHUB_OUTPUT
          echo "version=$PACKAGE_VERSION" >> $GITHUB_OUTPUT
          echo "count=$PACKAGE_COUNT" >> $GITHUB_OUTPUT
          echo "Main package: $PACKAGE_NAME v$PACKAGE_VERSION (workspace: $PACKAGE_COUNT packages)"
      
      - name: Check if version exists on crates.io
        if: inputs.package-type == 'library' && inputs.skip-publish != true
        id: check_crates
        run: |
          CRATE_VERSION=$(curl -s https://crates.io/api/v1/crates/${{ steps.package_info.outputs.name }} | jq -r '.crate.max_version // "none"')
          echo "Current crates.io version: $CRATE_VERSION"
          echo "Local version: ${{ steps.package_info.outputs.version }}"
          
          if [ "$CRATE_VERSION" = "${{ steps.package_info.outputs.version }}" ]; then
            echo "Version ${{ steps.package_info.outputs.version }} already exists on crates.io"
            echo "exists=true" >> $GITHUB_OUTPUT
            exit 1
          else
            echo "Version ${{ steps.package_info.outputs.version }} is new"
            echo "exists=false" >> $GITHUB_OUTPUT
          fi
      
      - name: Configure git
        run: |
          git config --global user.name "GitHub Actions"
          git config --global user.email "actions@github.com"
      
      - name: Create and push tag
        id: tag
        run: |
          TAG="v${{ steps.package_info.outputs.version }}"
          
          # Check if tag already exists
          if git rev-parse "$TAG" >/dev/null 2>&1; then
            echo "Tag $TAG already exists"
            echo "exists=true" >> $GITHUB_OUTPUT
          else
            git tag -a "$TAG" -m "Release $TAG - ${{ steps.package_info.outputs.name }}"
            
            # Configure remote with PAT
            git remote set-url origin https://x-access-token:${{ secrets.GH_PAT }}@github.com/${{ inputs.repository }}.git
            
            git push origin "$TAG"
            echo "Created and pushed tag $TAG"
            echo "exists=false" >> $GITHUB_OUTPUT
          fi
      
      - name: Build release (application)
        if: inputs.package-type == 'application'
        run: |
          if [ "${{ steps.package_info.outputs.count }}" -gt 1 ]; then
            # Workspace: build specific package
            cargo build --release --package ${{ steps.package_info.outputs.name }}
          else
            # Single package
            cargo build --release
          fi
          echo "Binary built at: target/release/${{ steps.package_info.outputs.name }}"
      
      - name: Package release artifacts (application)
        if: inputs.package-type == 'application' && steps.tag.outputs.exists != 'true'
        run: |
          mkdir -p release-artifacts
          cp target/release/${{ steps.package_info.outputs.name }} release-artifacts/
          cp README.md release-artifacts/ 2>/dev/null || echo "No README.md found"
          cp LICENSE release-artifacts/ 2>/dev/null || echo "No LICENSE found"
          
          cd release-artifacts
          tar -czf ../${{ steps.package_info.outputs.name }}-v${{ steps.package_info.outputs.version }}-linux-x86_64.tar.gz *
          cd ..
          
          echo "Release artifacts packaged"
      
      - name: Login to Azure Container Registry
        if: inputs.docker-enabled == true && inputs.dry-run != true
        run: |
          echo "Logging in to Azure Container Registry: ${{ secrets.ACR_URL }}"
          echo "${{ secrets.ACR_PASSWORD }}" | docker login "${{ secrets.ACR_URL }}" \
            --username "${{ secrets.ACR_USERNAME }}" \
            --password-stdin
      
      - name: Create default Dockerfile if needed
        if: inputs.docker-enabled == true
        run: |
          if [ ! -f "Dockerfile" ]; then
            echo "Creating multi-stage Dockerfile for Rust application"
            cat > Dockerfile << 'DOCKERFILE_END'
          # Build stage
          FROM rust:1.75-slim as builder
          
          WORKDIR /app
          
          # Install build dependencies
          RUN apt-get update && apt-get install -y \
              pkg-config \
              libssl-dev \
              && rm -rf /var/lib/apt/lists/*
          
          # Copy manifests
          COPY Cargo.toml Cargo.lock ./
          
          # Copy source code
          COPY src ./src
          
          # Build release binary
          RUN cargo build --release
          
          # Runtime stage
          FROM debian:bookworm-slim
          
          # Install runtime dependencies
          RUN apt-get update && apt-get install -y \
              ca-certificates \
              libssl3 \
              && rm -rf /var/lib/apt/lists/*
          
          # Copy the binary from builder
          COPY --from=builder /app/target/release/${{ steps.package_info.outputs.name }} /usr/local/bin/${{ steps.package_info.outputs.name }}
          
          # Create non-root user
          RUN useradd -m -u 1000 appuser && \
              chown appuser:appuser /usr/local/bin/${{ steps.package_info.outputs.name }}
          
          USER appuser
          
          ENTRYPOINT ["/usr/local/bin/${{ steps.package_info.outputs.name }}"]
          DOCKERFILE_END
            echo "Created default Dockerfile"
          else
            echo "Using existing Dockerfile"
          fi
      
      - name: Build Docker image
        if: inputs.docker-enabled == true
        run: |
          IMAGE_NAME="${{ inputs.docker-image-name || steps.package_info.outputs.name }}"
          IMAGE_TAG="${{ steps.package_info.outputs.version }}"
          FULL_IMAGE="${{ secrets.ACR_URL }}/${IMAGE_NAME}:${IMAGE_TAG}"
          LATEST_IMAGE="${{ secrets.ACR_URL }}/${IMAGE_NAME}:latest"

          echo "Building Docker image: ${FULL_IMAGE}"

          # Check if Dockerfile expects PACKAGE_URL build arg (for Reframe)
          if grep -q "ARG PACKAGE_URL" Dockerfile 2>/dev/null; then
            echo "Dockerfile requires PACKAGE_URL build argument"
            # Default package URL for Reframe SWIFT CBPR package
            PACKAGE_URL="${PACKAGE_URL:-https://github.com/GoPlasmatic/reframe-package-swift-cbpr/releases/download/v2.1.0/reframe-swift-cbpr-v2.1.0.zip}"
            echo "Using PACKAGE_URL: ${PACKAGE_URL}"
            docker build --build-arg PACKAGE_URL="${PACKAGE_URL}" -t "${FULL_IMAGE}" -t "${LATEST_IMAGE}" .
          else
            echo "Building without PACKAGE_URL argument"
            docker build -t "${FULL_IMAGE}" -t "${LATEST_IMAGE}" .
          fi

          echo "docker_image=${FULL_IMAGE}" >> $GITHUB_OUTPUT
          echo "docker_image_latest=${LATEST_IMAGE}" >> $GITHUB_OUTPUT
      
      - name: Push Docker image to Azure Container Registry
        if: inputs.docker-enabled == true && inputs.dry-run != true
        run: |
          IMAGE_NAME="${{ inputs.docker-image-name || steps.package_info.outputs.name }}"
          IMAGE_TAG="${{ steps.package_info.outputs.version }}"
          FULL_IMAGE="${{ secrets.ACR_URL }}/${IMAGE_NAME}:${IMAGE_TAG}"
          LATEST_IMAGE="${{ secrets.ACR_URL }}/${IMAGE_NAME}:latest"
          
          echo "Pushing Docker images to Azure Container Registry"
          docker push "${FULL_IMAGE}"
          docker push "${LATEST_IMAGE}"
          
          echo "✅ Docker images pushed:"
          echo "  - ${FULL_IMAGE}"
          echo "  - ${LATEST_IMAGE}"
      
      - name: Create GitHub Release
        if: steps.tag.outputs.exists != 'true'
        uses: softprops/action-gh-release@v2
        with:
          tag_name: v${{ steps.package_info.outputs.version }}
          name: ${{ steps.package_info.outputs.name }} v${{ steps.package_info.outputs.version }}
          body: |
            ## ${{ steps.package_info.outputs.name }} v${{ steps.package_info.outputs.version }}
            
            ### Installation
            ${{ inputs.package-type == 'library' && format('Add to your `Cargo.toml`:
            ```toml
            [dependencies]
            {0} = "{1}"
            ```', steps.package_info.outputs.name, steps.package_info.outputs.version) || format('Download and extract the binary:
            ```bash
            tar -xzf {0}-v{1}-linux-x86_64.tar.gz
            chmod +x {0}
            ./{0} --version
            ```', steps.package_info.outputs.name, steps.package_info.outputs.version) }}
            
            ### Documentation
            - [Repository](https://github.com/${{ inputs.repository }})
            ${{ inputs.package-type == 'library' && format('- [API Documentation](https://docs.rs/{0})', steps.package_info.outputs.name) || '' }}
          draft: false
          prerelease: false
          token: ${{ secrets.GH_PAT }}
          files: ${{ inputs.package-type == 'application' && format('{0}-v{1}-linux-x86_64.tar.gz', steps.package_info.outputs.name, steps.package_info.outputs.version) || '' }}
      
      - name: Publish to crates.io (library)
        if: inputs.package-type == 'library' && inputs.skip-publish != true && inputs.dry-run != true && steps.check_crates.outputs.exists != 'true'
        env:
          CARGO_REGISTRY_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}
        run: |
          if [ "${{ steps.package_info.outputs.count }}" -gt 1 ]; then
            echo "Publishing workspace packages..."
            
            # First, try to publish all workspace packages in dependency order
            # This uses cargo-workspaces if available, otherwise falls back to manual publish
            if command -v cargo-workspaces &> /dev/null; then
              echo "Using cargo-workspaces for publishing"
              cargo workspaces publish --from-git --no-verify --yes
            else
              echo "Publishing packages individually"
              
              # Get packages in dependency order using cargo metadata
              PACKAGES_JSON=$(cargo metadata --format-version 1)
              
              # Function to publish a package and its dependencies
              publish_with_deps() {
                local pkg=$1
                local version=$(echo "$PACKAGES_JSON" | jq -r ".packages[] | select(.name == \"$pkg\") | .version")
                
                # Check if already published
                CRATE_VERSION=$(curl -s https://crates.io/api/v1/crates/$pkg | jq -r '.crate.max_version // "none"')
                if [ "$CRATE_VERSION" = "$version" ]; then
                  echo "$pkg v$version already published"
                  return 0
                fi
                
                # Try to publish
                echo "Publishing $pkg v$version..."
                if cargo publish --package $pkg --no-verify; then
                  echo "✅ Published $pkg v$version"
                  # Wait for crates.io to index
                  sleep 10
                else
                  echo "⚠️ Failed to publish $pkg v$version (might have dependencies)"
                  return 1
                fi
              }
              
              # Try to publish packages, starting with those that might be dependencies
              for pkg in ${{ steps.package_info.outputs.publishable_packages }}; do
                # Skip if it's the main package (we'll do it last)
                if [ "$pkg" != "${{ steps.package_info.outputs.name }}" ]; then
                  publish_with_deps "$pkg" || true
                fi
              done
              
              # Finally publish the main package
              publish_with_deps "${{ steps.package_info.outputs.name }}"
            fi
          else
            # Single package
            cargo publish --no-verify
            echo "✅ Published ${{ steps.package_info.outputs.name }} v${{ steps.package_info.outputs.version }} to crates.io"
          fi
      
      - name: Release summary
        run: |
          if [ "${{ inputs.dry-run }}" = "true" ]; then
            echo "🔍 DRY RUN: Skipping release"
            echo "Would have released ${{ steps.package_info.outputs.name }} v${{ steps.package_info.outputs.version }}"
          else
            echo "✅ Released ${{ steps.package_info.outputs.name }} v${{ steps.package_info.outputs.version }}"
            if [ "${{ inputs.package-type }}" = "application" ]; then
              echo "📦 Binary package: ${{ steps.package_info.outputs.name }}-v${{ steps.package_info.outputs.version }}-linux-x86_64.tar.gz"
            elif [ "${{ inputs.skip-publish }}" = "true" ]; then
              echo "📦 Git tag and GitHub release created (no crates.io publish)"
            else
              echo "📦 Published to crates.io"
            fi
            echo "🏷️ Git tag: v${{ steps.package_info.outputs.version }}"
            
            if [ "${{ inputs.docker-enabled }}" = "true" ]; then
              IMAGE_NAME="${{ inputs.docker-image-name || steps.package_info.outputs.name }}"
              echo "🐳 Docker images pushed to Azure Container Registry:"
              echo "   - ${{ secrets.ACR_URL }}/${IMAGE_NAME}:${{ steps.package_info.outputs.version }}"
              echo "   - ${{ secrets.ACR_URL }}/${IMAGE_NAME}:latest"
            fi
          fi