validate-examples.yml

name: validate-examples

on:
  schedule:
    - cron: '8 8 * * *'
  push:
    branches:
      - main
      - release-*
    tags:
      - v*
  pull_request:
    branches:
      - main
      - release-*
  workflow_dispatch:
    inputs:
      dapr_commit:
        description: "Dapr/Dapr commit to build custom daprd from"
        required: false
        default: ""
      daprcli_commit:
        description: "Dapr/CLI commit to build custom dapr CLI from"
        required: false
        default: ""
      dapr_version:
        description: "Dapr/Dapr version to use"
        required: false
        default: ""
      daprcli_version:
        description: "Dapr/CLI version to use"
        required: false
        default: ""
  repository_dispatch:
    types: [ validate-examples ]
  merge_group:
jobs:
  setup:
    permissions:
      packages: read
    runs-on: ubuntu-latest
    env:
      GOOS: linux
      GOARCH: amd64
      GOPROXY: https://proxy.golang.org
      DAPR_INSTALL_URL: https://raw.githubusercontent.com/dapr/cli/master/install/install.sh
      DAPR_CLI_REF: ${{ github.event.inputs_daprcli_commit }}
      DAPR_CLI_VERSION: ${{ github.event.inputs_daprcli_version }}
      DAPR_REF: ${{ github.event.inputs.dapr_commit }}
      DAPR_RUNTIME_VERSION: ${{ github.event.inputs.dapr_version }}
      CHECKOUT_REPO: ${{ github.repository }}
      CHECKOUT_REF: ${{ github.ref }}
    outputs:
      DAPR_INSTALL_URL: ${{ env.DAPR_INSTALL_URL }}
      DAPR_CLI_VERSION: ${{ steps.outputs.outputs.DAPR_CLI_VERSION }}
      DAPR_RUNTIME_VERSION: ${{ steps.outputs.outputs.DAPR_RUNTIME_VERSION }}
      CHECKOUT_REPO: ${{ steps.outputs.outputs.CHECKOUT_REPO }}
      CHECKOUT_REF: ${{ steps.outputs.outputs.CHECKOUT_REF }}
      GITHUB_SHA: ${{ steps.outputs.outputs.GITHUB_SHA }}
    steps:
      - name: Parse repository_dispatch payload
        if: github.event_name == 'repository_dispatch'
        run: |
          if [ ${{ github.event.client_payload.command }} = "ok-to-test" ]; then
            echo "CHECKOUT_REPO=${{ github.event.client_payload.pull_head_repo }}" >> $GITHUB_ENV
            echo "CHECKOUT_REF=${{ github.event.client_payload.pull_head_ref }}" >> $GITHUB_ENV
            echo "DAPR_REF=master" >> $GITHUB_ENV
          fi

      - name: Check out code
        uses: actions/checkout@v4
        with:
          repository: ${{ env.CHECKOUT_REPO }}
          ref: ${{ env.CHECKOUT_REF }}

      - name: Determine latest Dapr Runtime version
        if: env.DAPR_RUNTIME_VERSION == ''
        run: |
          RUNTIME_VERSION=$(curl -s "https://api.github.com/repos/dapr/dapr/releases/latest" | grep '"tag_name"' | cut -d ':' -f2 | tr -d '",v')
          echo "DAPR_RUNTIME_VERSION=$RUNTIME_VERSION" >> $GITHUB_ENV
          echo "Found $RUNTIME_VERSION"

      - name: Determine latest Dapr Cli version
        if: env.DAPR_CLI_VERSION == ''
        run: |
          CLI_VERSION=$(curl -s "https://api.github.com/repos/dapr/cli/releases/latest" | grep '"tag_name"' | cut -d ':' -f2 | tr -d '",v')
          echo "DAPR_CLI_VERSION=$CLI_VERSION" >> $GITHUB_ENV
          echo "Found $CLI_VERSION"

      - name: Checkout Dapr CLI repo to override dapr command.
        uses: actions/checkout@v4
        if: env.DAPR_CLI_REF != ''
        with:
          repository: dapr/cli
          ref: ${{ env.DAPR_CLI_REF }}
          path: cli

      - name: Checkout Dapr repo to override daprd.
        uses: actions/checkout@v4
        if: env.DAPR_REF != ''
        with:
          repository: dapr/dapr
          ref: ${{ env.DAPR_REF }}
          path: dapr_runtime

      - name: Set up Go
        uses: actions/setup-go@v5
        if: env.DAPR_REF != '' || env.DAPR_CLI_REF != ''
        with:
          cache: false
          go-version: "stable"

      - name: Build dapr cli with referenced commit and override version
        if: env.DAPR_CLI_REF != ''
        run: |
          cd cli
          make
          echo "artifactPath=~/artifacts/$GITHUB_SHA/" >> $GITHUB_ENV
          mkdir -p $HOME/artifacts/$GITHUB_SHA/
          cp dist/linux_amd64/release/dapr $HOME/artifacts/$GITHUB_SHA/dapr
          CLI_VERSION=edge
          echo "DAPR_CLI_VERSION=$CLI_VERSION" >> $GITHUB_ENV

      - name: Build daprd and placement with referenced commit and override version
        if: env.DAPR_REF != ''
        run: |
          cd dapr_runtime
          make
          echo "artifactPath=~/artifacts/$GITHUB_SHA/" >> $GITHUB_ENV
          RUNTIME_VERSION=edge
          echo "DAPR_RUNTIME_VERSION=$RUNTIME_VERSION" >> $GITHUB_ENV

      - name: Build Docker Image
        if: env.DAPR_REF != ''
        run: |
          mkdir ~/dapr_docker
          cd dapr_runtime
          docker build --build-arg "PKG_FILES=*" -f ./docker/Dockerfile ./dist/linux_amd64/release -t daprio/dapr:0.0.0-dev

      - name: Download Install Bundle CLI
        if: env.DAPR_REF != '' && env.DAPR_CLI_REF == ''
        run: |
          mkdir -p cli/dist/linux_amd64/release
          cd cli/dist/linux_amd64/release/
          curl -L --remote-name https://github.com/dapr/cli/releases/download/v$DAPR_CLI_VERSION/dapr_linux_amd64.tar.gz
          tar xvzf dapr_linux_amd64.tar.gz
          ls -la

      - name: Build Custom Install Bundle
        if: env.DAPR_REF != '' && env.DAPR_CLI_REF != ''
        run: |
          : # Create daprbundle directory
          mkdir ~/daprbundle
          cp .github/workflows/validate-examples/details.json ~/daprbundle/

          : # Add cli
          cp ~/artifacts/$GITHUB_SHA/dapr ~/daprbundle/dapr

          : # Compress executables to /dist/ appending _linux_amd64 to the name
          mkdir ~/daprbundle/dist
          cd dapr_runtime/dist/linux_amd64/release/
          for file in $(ls -1)
          do
            echo "packing $file"
            tar czvf ~/daprbundle/dist/${file}_linux_amd64.tar.gz ${file}
          done
          cd ~/daprbundle/dist/
          curl -L --remote-name https://github.com/dapr/dashboard/releases/download/v0.14.0/dashboard_linux_amd64.tar.gz

          : # Add docker image
          mkdir ~/daprbundle/docker
          docker save daprio/dapr:0.0.0-dev | gzip > ~/daprbundle/docker/daprio-dapr-0.0.0-dev.tar.gz

          : # Bundle
          cd ~/daprbundle
          tar czvf $HOME/artifacts/$GITHUB_SHA/daprbundle.tar.gz .

      - name: List artifacts
        if: env.DAPR_REF != '' || env.DAPR_CLI_REF != ''
        run: |
          ls -la $HOME/artifacts/$GITHUB_SHA/

      - name: Upload dapr-artifacts
        uses: actions/upload-artifact@v4
        if: env.DAPR_REF != '' || env.DAPR_CLI_REF != ''
        with:
          name: dapr-artifacts
          path: ${{ env.artifactPath }}
          if-no-files-found: error
          retention-days: 1
          compression-level: 0

      - name: Outputs
        id: outputs
        run: |
          echo "DAPR_INSTALL_URL=$DAPR_INSTALL_URL"
          echo "DAPR_CLI_VERSION=$DAPR_CLI_VERSION" >> "$GITHUB_OUTPUT"
          echo "DAPR_RUNTIME_VERSION=$DAPR_RUNTIME_VERSION" >> "$GITHUB_OUTPUT"
          echo "CHECKOUT_REPO=$CHECKOUT_REPO" >> "$GITHUB_OUTPUT"
          echo "CHECKOUT_REF=$CHECKOUT_REF" >> "$GITHUB_OUTPUT"
          echo "GITHUB_SHA=$GITHUB_SHA" >> "$GITHUB_OUTPUT"

  validate-example:
    permissions:
      packages: read
    needs: setup
    runs-on: ubuntu-latest
    env:
      PYTHON_VER: 3.12
      DAPR_INSTALL_URL: ${{ needs.setup.outputs.DAPR_INSTALL_URL }}
      DAPR_CLI_VERSION: ${{ needs.setup.outputs.DAPR_CLI_VERSION }}
      DAPR_RUNTIME_VERSION: ${{ needs.setup.outputs.DAPR_RUNTIME_VERSION }}
      CHECKOUT_REPO: ${{ needs.setup.outputs.CHECKOUT_REPO }}
      CHECKOUT_REF: ${{ needs.setup.outputs.CHECKOUT_REF }}
      GITHUB_SHA: ${{ needs.setup.outputs.GITHUB_SHA }}
      RUST_BACKTRACE: full

    strategy:
      fail-fast: false
      matrix:
        examples:
          [ "actors", "bindings", "client", "configuration", "crypto", "invoke/grpc", "invoke/grpc-proxying", "jobs", "pubsub", "query_state", "secrets-bulk" ]
    steps:
      - name: Check out code
        uses: actions/checkout@v4
        with:
          repository: ${{ env.CHECKOUT_REPO }}
          ref: ${{ env.CHECKOUT_REF }}

      - name: Make Artifacts destination folder
        if: env.DAPR_CLI_VERSION == 'edge' || env.DAPR_RUNTIME_VERSION == 'edge'
        run: |
          mkdir -p $HOME/artifacts/$GITHUB_SHA/

      - name: Retrieve dapr-artifacts
        if: env.DAPR_CLI_VERSION == 'edge' || env.DAPR_RUNTIME_VERSION == 'edge'
        uses: actions/download-artifact@v4
        with:
          name: dapr-artifacts
          path: ~/artifacts/${{ env.GITHUB_SHA }}

      - name: Display downloaded artifacts
        if: env.DAPR_CLI_VERSION == 'edge' || env.DAPR_RUNTIME_VERSION == 'edge'
        run: |
          ls -la $HOME/artifacts/$GITHUB_SHA/

      - name: Rust setup
        run: rustup toolchain install stable --profile minimal

      - name: Install Protoc
        uses: arduino/setup-protoc@v3
        with:
          version: "24.4"
          repo-token: ${{ secrets.GITHUB_TOKEN }}

      - name: Set up Dapr CLI ${{ env.DAPR_CLI_VERSION }}
        if: env.DAPR_CLI_VERSION != 'edge'
        run: wget -q ${{ env.DAPR_INSTALL_URL }} -O - | /bin/bash -s ${{ env.DAPR_CLI_VERSION }}

      - name: Set up Dapr CLI (edge)
        if: env.DAPR_CLI_VERSION == 'edge'
        run: |
          sudo cp $HOME/artifacts/$GITHUB_SHA/dapr /usr/local/bin/dapr
          sudo chmod +x /usr/local/bin/dapr

      - name: Initialize Dapr runtime ${{ env.DAPR_RUNTIME_VERSION }}
        if: env.DAPR_RUNTIME_VERSION != 'edge'
        run: |
          dapr uninstall --all
          dapr init --runtime-version ${{ env.DAPR_RUNTIME_VERSION }}

      - name: Initialize Dapr runtime with installer bundle - EDGE
        if: env.DAPR_RUNTIME_VERSION == 'edge'
        run: |
          : # Unpack Bundle
          mkdir ~/daprbundle
          tar xvzf $HOME/artifacts/$GITHUB_SHA/daprbundle.tar.gz -C ~/daprbundle

          : # Run installer
          dapr uninstall --all
          dapr init --from-dir ~/daprbundle/

          : # Initialize redis and zipkin
          docker run --name "dapr_redis" --restart always -d -p 6379:6379 redislabs/rejson
          docker run --name "dapr_zipkin" --restart always -d -p 9411:9411 openzipkin/zipkin

      - name: List running containers
        run: |
          docker ps -a

      - name: Set up Python ${{ env.PYTHON_VER }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ env.PYTHON_VER }}

      - name: Install Mechanical Markdown
        run: |
          python -m pip install --upgrade pip
          pip install mechanical-markdown

      - name: Dapr version
        run: |
          dapr version
          docker ps -a

      - name: Check Example
        run: |
          cd examples
          ./validate.sh ${{ matrix.examples }}