#!/usr/bin/env bash
          
        
      
        

          

            

            

            # Retention cleanup: read PV directly, no git-pages API.
          
        
      
        

          

            

            

            # Removes old commit-level report dirs based on branch existence + age rules.
          
        
      
        

          

            

            

            set -euo pipefail
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            DATA_ROOT="${DATA_ROOT:-/app/data}"
          
        
      
        

          

            

            

            CONFIG="${RETENTION_CONFIG:-/etc/retention/retention.json}"
          
        
      
        

          

            

            

            GITEA_API_URL="${GITEA_API_URL:-}"
          
        
      
        

          

            

            

            GITEA_TOKEN="${GITEA_TOKEN:-}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            [ -f "$CONFIG" ] || { echo "ERROR: config missing: $CONFIG" >&2; exit 1; }
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
          
        
      
        

          

            

            

            source "$SCRIPT_DIR/retention-lib.sh"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            DELETED_COUNT=0
          
        
      
        

          

            

            

            ERROR_COUNT=0
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            for owner_dir in "$DATA_ROOT"/*/; do
          
        
      
        

          

            

            

              [ -d "$owner_dir" ] || continue
          
        
      
        

          

            

            

              owner=$(basename "$owner_dir")
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              for repo_dir in "$owner_dir"*/; do
          
        
      
        

          

            

            

                [ -d "$repo_dir" ] || continue
          
        
      
        

          

            

            

                repo=$(basename "$repo_dir")
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                for branch_dir in "$repo_dir"*/; do
          
        
      
        

          

            

            

                  [ -d "$branch_dir" ] || continue
          
        
      
        

          

            

            

                  branch=$(basename "$branch_dir")
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  echo "=== ${owner}/${repo}/${branch} ==="
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  if ! branch_exists "$owner" "$repo" "$branch"; then
          
        
      
        

          

            

            

                    echo "  Branch does not exist in Gitea -> DELETE ALL"
          
        
      
        

          

            

            

                    rm -rf "$branch_dir"
          
        
      
        

          

            

            

                    DELETED_COUNT=$((DELETED_COUNT + 1))
          
        
      
        

          

            

            

                    continue
          
        
      
        

          

            

            

                  fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  rules=$(jq -r ".branches.\"$branch\" // .branches.default" "$CONFIG")
          
        
      
        

          

            

            

                  keep_min=$(echo "$rules" | jq -r '.keepMin // 5')
          
        
      
        

          

            

            

                  min_age=$(echo "$rules" | jq -r '.minAgeDays // 7')
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  commits=$(ls -1t "$branch_dir" 2>/dev/null || true)
          
        
      
        

          

            

            

                  count=0
          
        
      
        

          

            

            

                  for sha8 in $commits; do
          
        
      
        

          

            

            

                    [ -d "$branch_dir/$sha8" ] || continue
          
        
      
        

          

            

            

                    count=$((count + 1))
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                    [ "$count" -le "$keep_min" ] && continue
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                    age=$(age_days_from_stat "$branch_dir/$sha8")
          
        
      
        

          

            

            

                    [ "$age" -lt "$min_age" ] && continue
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                    echo "  DELETE: ${owner}/${repo}/${branch}/${sha8} (age=${age}d, keepMin=${keep_min})"
          
        
      
        

          

            

            

                    rm -rf "$branch_dir/$sha8"
          
        
      
        

          

            

            

                    DELETED_COUNT=$((DELETED_COUNT + 1))
          
        
      
        

          

            

            

                  done
          
        
      
        

          

            

            

                done
          
        
      
        

          

            

            

              done
          
        
      
        

          

            

            

            done
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            echo ""
          
        
      
        

          

            

            

            echo "=== Summary ==="
          
        
      
        

          

            

            

            echo "  Deleted: ${DELETED_COUNT}"
          
        
      
        

          

            

            

            echo "  Errors:  ${ERROR_COUNT}"
          
        
      
    
  

    

      
        

          

            

            

            #!/usr/bin/env bash
          
        
      
        

          

            

            

            # Shared functions for retention-cleanup.sh
          
        
      
        

          

            

            

            # Can be sourced by tests for unit testing
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            age_days_from_stat() {
          
        
      
        

          

            

            

              local dir="$1" epoch_dir now
          
        
      
        

          

            

            

              epoch_dir=$(stat -c %Y "$dir" 2>/dev/null || stat -f %m "$dir" 2>/dev/null || echo 0)
          
        
      
        

          

            

            

              [ "$epoch_dir" -eq 0 ] && echo 99999 && return
          
        
      
        

          

            

            

              now=$(date +%s)
          
        
      
        

          

            

            

              echo $(( (now - epoch_dir) / 86400 ))
          
        
      
        

          

            

            

            }
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            read_rule() {
          
        
      
        

          

            

            

              local config="$1" branch="$2" key="$3" default="$4"
          
        
      
        

          

            

            

              v=$(jq -r --arg b "$branch" --arg k "$key" '.branches[$b][$k] // empty' "$config")
          
        
      
        

          

            

            

              [ -n "$v" ] && echo "$v" || echo "$default"
          
        
      
        

          

            

            

            }
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            branch_exists() {
          
        
      
        

          

            

            

              local owner="$1" repo="$2" branch="$3"
          
        
      
        

          

            

            

              local branch_urlenc code
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              [ -z "$GITEA_API_URL" ] && return 0
          
        
      
        

          

            

            

              [ -z "$GITEA_TOKEN" ] && return 0
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              branch_urlenc=$(echo "$branch" | sed 's/\//%2F/g')
          
        
      
        

          

            

            

              code=$(curl -s -o /dev/null -w "%{http_code}" \
          
        
      
        

          

            

            

                -H "Authorization: token $GITEA_TOKEN" \
          
        
      
        

          

            

            

                "$GITEA_API_URL/api/v1/repos/$owner/$repo/branches/$branch_urlenc" 2>/dev/null || echo "000")
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              [ "$code" = "200" ]
          
        
      
        

          

            

            

            }
          
        
      
    
  

    

      
        

          

            

            

            #!/usr/bin/env bash
          
        
      
        

          

            

            

            # Run retention cleanup on PVC directly (no git-pages API).
          
        
      
        

          

            

            

            set -euo pipefail
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            /scripts/retention-cleanup.sh
          
        
      
        

          

            

            

            echo "Retention job done."
          
        
      
    
  

    

      
        

          

            

            

            #!/usr/bin/env bash
          
        
      
        

          

            
              12
            

            

            set -e
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              12
            

            

            RAW_VERSION=""
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              21
            

            

            if [ -n "${VERSION_FILE-}" ] && [ -f "${VERSION_FILE-}" ]; then
          
        
      
        

          

            
              36
            

            

              RAW_VERSION=$(tr -d "$(printf '\xef\xbb\xbf')" < "${VERSION_FILE}" | sed -n 's/^version:[[:space:]]*\([^[:space:]]*\).*/\1/p')
          
        
      
        

          

            
              9
            

            

              if [ -z "${RAW_VERSION}" ]; then
          
        
      
        

          

            
              12
            

            

                if echo "${VERSION_FILE}" | grep -q -E '\.json$'; then
          
        
      
        

          

            
              2
            

            

                  RAW_VERSION=$(jq -r '.version' "${VERSION_FILE}")
          
        
      
        

          

            

            

                else
          
        
      
        

          

            
              15
            

            

                  RAW_VERSION=$(cat "${VERSION_FILE}" | tr -d '[:space:]')
          
        
      
        

          

            

            

                fi
          
        
      
        

          

            

            

              fi
          
        
      
        

          

            

            

            fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              12
            

            

            if [ -z "${RAW_VERSION}" ]; then
          
        
      
        

          

            
              3
            

            

              if [ -f VERSION ]; then
          
        
      
        

          

            
              3
            

            

                RAW_VERSION=$(cat VERSION | tr -d '[:space:]')
          
        
      
        

          

            
              2
            

            

              elif [ -f package.json ]; then
          
        
      
        

          

            

            

                RAW_VERSION=$(jq -r '.version' package.json)
          
        
      
        

          

            
              2
            

            

              elif [ -f pom.xml ]; then
          
        
      
        

          

            

            

                RAW_VERSION=$(grep -oP '<version>\K[^<]+' pom.xml | head -1)
          
        
      
        

          

            
              2
            

            

              elif [ -f Chart.yaml ]; then
          
        
      
        

          

            
              4
            

            

                RAW_VERSION=$(tr -d "$(printf '\xef\xbb\xbf')" < Chart.yaml | sed -n 's/^version:[[:space:]]*\([^[:space:]]*\).*/\1/p')
          
        
      
        

          

            

            

              else
          
        
      
        

          

            
              1
            

            

                echo "ERROR: No version source found (VERSION_FILE, VERSION, package.json, pom.xml, Chart.yaml)" >&2
          
        
      
        

          

            
              1
            

            

                exit 1
          
        
      
        

          

            

            

              fi
          
        
      
        

          

            

            

            fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              33
            

            

            BASE_VERSION=$(echo "$RAW_VERSION" | cut -d'.' -f1-2)
          
        
      
        

          

            
              11
            

            

            echo "gitea-ci-library - Tunnistettu Major.Minor versio: $BASE_VERSION"
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              22
            

            

            TAGS_JSON=$(curl -s -f -H "Authorization: token ${GITEA_TOKEN}" \
          
        
      
        

          

            
              22
            

            

              "${SERVER_URL}/api/v1/repos/${REPO}/tags")
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              33
            

            

            TAG=$(echo "$TAGS_JSON" | jq -r --arg prefix "${GIT_TAG_PREFIX-}" --arg sha "${SHA}" '
          
        
      
        

          

            
              33
            

            

              if type == "array" then
          
        
      
        

          

            
              33
            

            

                .[] | select(.commit.sha == $sha and (.name | startswith($prefix))) | .name
          
        
      
        

          

            
              33
            

            

              else empty end' | head -1)
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              11
            

            

            mkdir -p /tmp/build-ctx
          
        
      
        

          

            
              11
            

            

            
          
        
      
        

          

            
              11
            

            

            if [ -n "$TAG" ]; then
          
        
      
        

          

            
              2
            

            

              echo "ARTIFACT_EXISTS=true" > /tmp/build-ctx/build.env
          
        
      
        

          

            
              2
            

            

              echo "NEXT_VERSION=$TAG" >> /tmp/build-ctx/build.env
          
        
      
        

          

            
              2
            

            

              echo "gitea-ci-library - Artefakti löytyi jo tagilla: $TAG."
          
        
      
        

          

            

            

            else
          
        
      
        

          

            
              9
            

            

              echo "ARTIFACT_EXISTS=false" > /tmp/build-ctx/build.env
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              27
            

            

              HIGHEST_PATCH=$(echo "$TAGS_JSON" | jq -r --arg prefix "${GIT_TAG_PREFIX-}" --arg bv "${GIT_TAG_PREFIX-}${BASE_VERSION}." '
          
        
      
        

          

            
              27
            

            

                if type == "array" then .[] | .name | select(startswith($bv)) | sub($bv; "") | tonumber else empty end' | sort -rn | head -1)
          
        
      
        

          

            
              18
            

            

            
          
        
      
        

          

            
              18
            

            

              if [ -z "$HIGHEST_PATCH" ]; then NEXT_PATCH=0; else NEXT_PATCH=$((HIGHEST_PATCH + 1)); fi
          
        
      
        

          

            
              9
            

            

              FULL_VERSION="${BASE_VERSION}.${NEXT_PATCH}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              9
            

            

              echo "NEXT_VERSION=$FULL_VERSION" >> /tmp/build-ctx/build.env
          
        
      
        

          

            
              9
            

            

              echo "gitea-ci-library - Uusi vapaa versio: $FULL_VERSION"
          
        
      
        

          

            

            

            fi
          
        
      
    
  

    

      
        

          

            

            

            #!/usr/bin/env sh
          
        
      
        

          

            

            

            set -eu
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            DESCRIPTION="${1:-}"
          
        
      
        

          

            

            

            CONTEXT="${2:-}"
          
        
      
        

          

            

            

            SUITE="${3:-}"
          
        
      
        

          

            

            

            STATUS="${4:-success}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            [ -n "$DESCRIPTION" ] || { echo "ERROR: description argument required" >&2; exit 1; }
          
        
      
        

          

            

            

            [ -n "$CONTEXT" ] || { echo "ERROR: context argument required" >&2; exit 1; }
          
        
      
        

          

            

            

            [ -n "$SUITE" ] || { echo "ERROR: suite argument required" >&2; exit 1; }
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            REPORT_DIR="reports/${SUITE}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            if [ ! -d "$REPORT_DIR" ]; then
          
        
      
        

          

            

            

              echo "ERROR: $REPORT_DIR not found" >&2
          
        
      
        

          

            

            

              sh .ci/scripts/report-status.sh failure "$DESCRIPTION" "$CONTEXT"
          
        
      
        

          

            

            

              exit 1
          
        
      
        

          

            

            

            fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            FILE_COUNT=0
          
        
      
        

          

            

            

            SUBDIR_COUNT=0
          
        
      
        

          

            

            

            ENTRIES=""
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            for f in "$REPORT_DIR"/*; do
          
        
      
        

          

            

            

              [ -f "$f" ] || continue
          
        
      
        

          

            

            

              base=$(basename "$f")
          
        
      
        

          

            

            

              [ "$base" = "index.html" ] && continue
          
        
      
        

          

            

            

              FILE_COUNT=$((FILE_COUNT + 1))
          
        
      
        

          

            

            

              ENTRIES="${ENTRIES}file:${base}
          
        
      
        

          

            

            

            "
          
        
      
        

          

            

            

            done
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            for d in "$REPORT_DIR"/*/; do
          
        
      
        

          

            

            

              [ -d "$d" ] || continue
          
        
      
        

          

            

            

              base=$(basename "$d")
          
        
      
        

          

            

            

              [ -f "$d/index.html" ] || continue
          
        
      
        

          

            

            

              SUBDIR_COUNT=$((SUBDIR_COUNT + 1))
          
        
      
        

          

            

            

              ENTRIES="${ENTRIES}dir:${base}
          
        
      
        

          

            

            

            "
          
        
      
        

          

            

            

            done
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            TOTAL=$((FILE_COUNT + SUBDIR_COUNT))
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            if [ "$TOTAL" -eq 0 ]; then
          
        
      
        

          

            

            

              echo "ERROR: no reportable items in $REPORT_DIR" >&2
          
        
      
        

          

            

            

              sh .ci/scripts/report-status.sh failure "$DESCRIPTION" "$CONTEXT"
          
        
      
        

          

            

            

              exit 1
          
        
      
        

          

            

            

            fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            SHA8=$(echo "${GITHUB_SHA:-xxxxxxxx}" | cut -c1-8)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            humanize() {
          
        
      
        

          

            

            

              name="$1"
          
        
      
        

          

            

            

              name=$(echo "$name" | sed -e 's/\.[^.]*$//' -e 's/[-_]/ /g')
          
        
      
        

          

            

            

              first=$(echo "$name" | cut -c1 | tr '[:lower:]' '[:upper:]')
          
        
      
        

          

            

            

              rest=$(echo "$name" | cut -c2-)
          
        
      
        

          

            

            

              echo "${first}${rest}"
          
        
      
        

          

            

            

            }
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            generate_index() {
          
        
      
        

          

            

            

              {
          
        
      
        

          

            

            

                echo '<!DOCTYPE html><html lang="en"><head><meta charset="utf-8">'
          
        
      
        

          

            

            

                echo "<title>$DESCRIPTION</title>"
          
        
      
        

          

            

            

                echo '<style>body{font-family:sans-serif;margin:2em;max-width:960px}h1{color:#1e293b}ul{list-style:none;padding:0}li{margin:.5em 0;padding:.5em;background:#f8fafc;border-radius:6px}a{color:#2563eb;text-decoration:none}a:hover{text-decoration:underline}</style>'
          
        
      
        

          

            

            

                echo "</head><body><h1>$DESCRIPTION</h1><ul>"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                echo "$ENTRIES" | while IFS= read -r entry; do
          
        
      
        

          

            

            

                  [ -z "$entry" ] && continue
          
        
      
        

          

            

            

                  entry_type=$(echo "$entry" | cut -d: -f1)
          
        
      
        

          

            

            

                  entry_name=$(echo "$entry" | cut -d: -f2-)
          
        
      
        

          

            

            

                  if [ "$entry_type" = "file" ]; then
          
        
      
        

          

            

            

                    echo "<li><a href=\"$entry_name\">$(humanize "$entry_name")</a></li>"
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    cap=$(echo "$entry_name" | sed 's/\(.\).*/\1/' | tr '[:lower:]' '[:upper:]')$(echo "$entry_name" | sed 's/.//')
          
        
      
        

          

            

            

                    echo "<li><a href=\"$entry_name/index.html\">${cap}</a></li>"
          
        
      
        

          

            

            

                  fi
          
        
      
        

          

            

            

                done
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                echo '</ul></body></html>'
          
        
      
        

          

            

            

              } > "$REPORT_DIR/index.html"
          
        
      
        

          

            

            

            }
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            mkdir -p "$SUITE"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            if [ "$TOTAL" -eq 1 ]; then
          
        
      
        

          

            

            

              cp -a "$REPORT_DIR/." "$SUITE/"
          
        
      
        

          

            

            

              sh .ci/scripts/publish-git-pages.sh "$SUITE"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              first_entry=$(echo "$ENTRIES" | head -1)
          
        
      
        

          

            

            

              first_type=$(echo "$first_entry" | cut -d: -f1)
          
        
      
        

          

            

            

              first_name=$(echo "$first_entry" | cut -d: -f2-)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              if [ "$first_type" = "file" ]; then
          
        
      
        

          

            

            

                SINGLE_ENTRY="$first_name"
          
        
      
        

          

            

            

              else
          
        
      
        

          

            

            

                SINGLE_ENTRY="${first_name}/index.html"
          
        
      
        

          

            

            

              fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              URL="${GIT_PAGES_URL}/${GITHUB_REPOSITORY}/${GITHUB_REF_NAME}/${SHA8}/${SUITE}/${SINGLE_ENTRY}"
          
        
      
        

          

            

            

              sh .ci/scripts/report-status.sh "$STATUS" "$DESCRIPTION" "$CONTEXT" "" "$URL"
          
        
      
        

          

            

            

            else
          
        
      
        

          

            

            

              generate_index
          
        
      
        

          

            

            

              cp -a "$REPORT_DIR/." "$SUITE/"
          
        
      
        

          

            

            

              sh .ci/scripts/publish-git-pages.sh "$SUITE"
          
        
      
        

          

            

            

              sh .ci/scripts/report-status.sh "$STATUS" "$DESCRIPTION" "$CONTEXT" "$SUITE"
          
        
      
        

          

            

            

            fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            rm -rf "$SUITE"
          
        
      
    
  

    

      
        

          

            

            

            #!/usr/bin/env bash
          
        
      
        

          

            
              7
            

            

            set -euo pipefail
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              7
            

            

            CONF_FILE="${CI_CONF_FILE:-.gitea/workflows/gitea-env.conf}"
          
        
      
        

          

            
              7
            

            

            ERRORS=0
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              9
            

            

            [ -f "$CONF_FILE" ] || { echo "ERROR: $CONF_FILE not found — checkout missing?" >&2; exit 1; }
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              6
            

            

            echo "Reading $CONF_FILE..."
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              36
            

            

            while IFS='=' read -r key value || [ -n "$key" ]; do
          
        
      
        

          

            
              27
            

            

              key=$(echo "$key" | xargs)
          
        
      
        

          

            
              27
            

            

              value=$(echo "$value" | xargs)
          
        
      
        

          

            
              10
            

            

              [ -z "$key" ] && continue
          
        
      
        

          

            
              9
            

            

              [[ "$key" == "#"* ]] && continue
          
        
      
        

          

            
              9
            

            

              [ -z "$value" ] && echo "ERROR: $key is empty in $CONF_FILE" >&2 && ERRORS=1
          
        
      
        

          

            
              19
            

            

              if [ -n "$value" ] && [[ "$key" == *"URL"* ]] && [[ "$value" != http://* ]] && [[ "$value" != https://* ]]; then
          
        
      
        

          

            
              1
            

            

                echo "ERROR: $key should be a URL (http/https), got: $value" >&2
          
        
      
        

          

            
              1
            

            

                ERRORS=1
          
        
      
        

          

            

            

              fi
          
        
      
        

          

            

            

            done < "$CONF_FILE"
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              8
            

            

            [ -z "${GITEA_TOKEN:-}" ] && echo "ERROR: GITEA_TOKEN secret is not set" >&2 && ERRORS=1
          
        
      
        

          

            
              8
            

            

            [ -z "${REPORTS_PUBLISH_TOKEN:-}" ] && echo "ERROR: REPORTS_PUBLISH_TOKEN secret is not set" >&2 && ERRORS=1
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              6
            

            

            if [ "$ERRORS" -ne 0 ]; then
          
        
      
        

          

            
              4
            

            

              echo "FATAL: CI config validation failed" >&2
          
        
      
        

          

            
              4
            

            

              exit 1
          
        
      
        

          

            

            

            fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              2
            

            

            echo "OK: all CI env vars validated"
          
        
      
    
  

    

      
        

          

            

            

            #!/usr/bin/env bash
          
        
      
        

          

            
              13
            

            

            set -euo pipefail
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              13
            

            

            TARGET_REPO="${1:-}"
          
        
      
        

          

            
              13
            

            

            WORKFLOW_FILE="${2:-}"
          
        
      
        

          

            
              13
            

            

            REF="${3:-}"
          
        
      
        

          

            
              13
            

            

            INPUTS_JSON="${4:-}"
          
        
      
        

          

            
              13
            

            

            GITEA_API_URL="${5:-}"
          
        
      
        

          

            
              13
            

            

            GITEA_TOKEN="${6:-}"
          
        
      
        

          

            
              13
            

            

            TIMEOUT_MINUTES="${7:-360}"
          
        
      
        

          

            
              13
            

            

            POLL_INTERVAL="${DISPATCH_POLL_INTERVAL:-10}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              15
            

            

            [ -z "$TARGET_REPO" ] && echo "ERROR: target_repo argument is required" >&2 && exit 1
          
        
      
        

          

            
              14
            

            

            [ -z "$WORKFLOW_FILE" ] && echo "ERROR: workflow_file argument is required" >&2 && exit 1
          
        
      
        

          

            
              13
            

            

            [ -z "$REF" ] && echo "ERROR: ref argument is required" >&2 && exit 1
          
        
      
        

          

            
              12
            

            

            [ -z "$INPUTS_JSON" ] && echo "ERROR: inputs_json argument is required" >&2 && exit 1
          
        
      
        

          

            
              11
            

            

            [ -z "$GITEA_API_URL" ] && echo "ERROR: gitea_api_url argument is required" >&2 && exit 1
          
        
      
        

          

            
              10
            

            

            [ -z "$GITEA_TOKEN" ] && echo "ERROR: gitea_token argument is required" >&2 && exit 1
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            # Generate unique dispatch_id for display_title matching
          
        
      
        

          

            

            

            # Can be overridden via DISPATCH_ID env var (for tests)
          
        
      
        

          

            
              7
            

            

            DISPATCH_ID="${DISPATCH_ID:-$(xxd -l 4 -p /dev/urandom 2>/dev/null || openssl rand -hex 4 2>/dev/null || od -An -N4 -tx1 /dev/urandom | tr -d ' \n')}"
          
        
      
        

          

            
              21
            

            

            INPUTS_JSON=$(echo "$INPUTS_JSON" | jq --arg id "$DISPATCH_ID" '. + {dispatch_id: $id}')
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              7
            

            

            DISPATCH_URL="$GITEA_API_URL/api/v1/repos/$TARGET_REPO/actions/workflows/$WORKFLOW_FILE/dispatches"
          
        
      
        

          

            
              14
            

            

            DISPATCH_BODY=$(jq -nc --arg ref "$REF" --argjson inputs "$INPUTS_JSON" '{ref: $ref, inputs: $inputs}')
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            DISPATCH_CODE=$(curl -s -o /dev/null -w "%{http_code}" \
          
        
      
        

          

            

            

              --connect-timeout 5 --max-time 10 \
          
        
      
        

          

            

            

              -X POST "$DISPATCH_URL" \
          
        
      
        

          

            

            

              -H "Authorization: token $GITEA_TOKEN" \
          
        
      
        

          

            

            

              -H "Content-Type: application/json" \
          
        
      
        

          

            
              14
            

            

              -d "$DISPATCH_BODY")
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              7
            

            

            if [ "$DISPATCH_CODE" != "201" ]; then
          
        
      
        

          

            
              1
            

            

              echo "ERROR: Dispatch failed with HTTP $DISPATCH_CODE" >&2
          
        
      
        

          

            
              1
            

            

              exit 1
          
        
      
        

          

            

            

            fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            # Poll: find dispatched run by display_title matching
          
        
      
        

          

            
              6
            

            

            RUN_ID=""
          
        
      
        

          

            
              12
            

            

            TIMEOUT_SECONDS=$(awk "BEGIN {printf \"%.3f\", $TIMEOUT_MINUTES * 60}")
          
        
      
        

          

            
              12
            

            

            START_TIME=$(date +%s)
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              19
            

            

            while [ -z "$RUN_ID" ]; do
          
        
      
        

          

            
              30
            

            

              NOW=$(date +%s)
          
        
      
        

          

            
              15
            

            

              ELAPSED=$((NOW - START_TIME))
          
        
      
        

          

            
              15
            

            

              if awk -v e="$ELAPSED" -v t="$TIMEOUT_SECONDS" 'BEGIN { exit !(e >= t) }'; then
          
        
      
        

          

            
              2
            

            

                echo "ERROR: Timeout after ${TIMEOUT_MINUTES} minutes — run not found" >&2
          
        
      
        

          

            
              2
            

            

                exit 124
          
        
      
        

          

            

            

              fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              RUNS_RESP=$(curl -s --connect-timeout 5 --max-time 10 \
          
        
      
        

          

            

            

                "$GITEA_API_URL/api/v1/repos/$TARGET_REPO/actions/runs?event=workflow_dispatch&limit=10" \
          
        
      
        

          

            
              26
            

            

                -H "Authorization: token $GITEA_TOKEN")
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              39
            

            

              RUN_ID=$(echo "$RUNS_RESP" | jq -r --arg id "$DISPATCH_ID" \
          
        
      
        

          

            
              39
            

            

                '[.workflow_runs[] | select(.display_title | contains($id))] | .[0].id // empty')
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              22
            

            

              [ -z "$RUN_ID" ] && sleep "$POLL_INTERVAL"
          
        
      
        

          

            

            

            done
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            # Poll: wait for run to complete
          
        
      
        

          

            
              8
            

            

            while true; do
          
        
      
        

          

            
              16
            

            

              NOW=$(date +%s)
          
        
      
        

          

            
              8
            

            

              ELAPSED=$((NOW - START_TIME))
          
        
      
        

          

            
              8
            

            

              if awk -v e="$ELAPSED" -v t="$TIMEOUT_SECONDS" 'BEGIN { exit !(e >= t) }'; then
          
        
      
        

          

            

            

                echo "ERROR: Timeout after ${TIMEOUT_MINUTES} minutes" >&2
          
        
      
        

          

            

            

                exit 124
          
        
      
        

          

            

            

              fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              8
            

            

              RUN_URL="$GITEA_API_URL/api/v1/repos/$TARGET_REPO/actions/runs/$RUN_ID"
          
        
      
        

          

            

            

              RUN_RESP=$(curl -s --connect-timeout 5 --max-time 10 \
          
        
      
        

          

            
              16
            

            

                -H "Authorization: token $GITEA_TOKEN" "$RUN_URL")
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              24
            

            

              STATUS=$(echo "$RUN_RESP" | jq -r '.status // "running"')
          
        
      
        

          

            
              8
            

            

              if [ "$STATUS" = "completed" ]; then
          
        
      
        

          

            
              12
            

            

                CONCLUSION=$(echo "$RUN_RESP" | jq -r '.conclusion // "failure"')
          
        
      
        

          

            
              4
            

            

                if [ "$CONCLUSION" = "success" ]; then
          
        
      
        

          

            
              2
            

            

                  GITOPS_COMMIT=""
          
        
      
        

          

            

            

                  BRANCH_RESP=$(curl -s --connect-timeout 5 --max-time 10 \
          
        
      
        

          

            

            

                    "$GITEA_API_URL/api/v1/repos/$TARGET_REPO/branches/$REF" \
          
        
      
        

          

            
              4
            

            

                    -H "Authorization: token $GITEA_TOKEN") || true
          
        
      
        

          

            
              6
            

            

                  GITOPS_COMMIT=$(echo "$BRANCH_RESP" | jq -r '.commit.id // empty')
          
        
      
        

          

            
              2
            

            

                  echo "GITOPS_COMMIT=$GITOPS_COMMIT"
          
        
      
        

          

            
              2
            

            

                  exit 0
          
        
      
        

          

            

            

                fi
          
        
      
        

          

            
              2
            

            

                echo "ERROR: Workflow completed with conclusion: $CONCLUSION" >&2
          
        
      
        

          

            
              2
            

            

                exit 1
          
        
      
        

          

            

            

              fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              4
            

            

              sleep "$POLL_INTERVAL"
          
        
      
        

          

            

            

            done
          
        
      
    
  

    

      
        

          

            

            

            #!/usr/bin/env bash
          
        
      
        

          

            

            

            set -euo pipefail
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            echo "gitops-dispatch: validating env vars..."
          
        
      
        

          

            

            

            : "${GITOPS_FILE:?}"
          
        
      
        

          

            

            

            : "${GITOPS_YQ_TPL:?}"
          
        
      
        

          

            

            

            : "${GITOPS_VERSION:?}"
          
        
      
        

          

            

            

            : "${GITOPS_SOURCE_REPO:?}"
          
        
      
        

          

            

            

            : "${GITOPS_SOURCE_COMMIT:?}"
          
        
      
        

          

            

            

            : "${GITOPS_REPO:?}"
          
        
      
        

          

            

            

            : "${GITOPS_WORKFLOW:?}"
          
        
      
        

          

            

            

            : "${GITEA_API_URL:?}"
          
        
      
        

          

            

            

            : "${GITEA_TOKEN:?}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            TIMEOUT="${GITOPS_DISPATCH_TIMEOUT:-30}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            echo "gitops-dispatch: constructing inputs..."
          
        
      
        

          

            

            

            INPUTS=$(jq -nc \
          
        
      
        

          

            

            

              --arg file "$GITOPS_FILE" \
          
        
      
        

          

            

            

              --arg yq_tpl "$GITOPS_YQ_TPL" \
          
        
      
        

          

            

            

              --arg version "$GITOPS_VERSION" \
          
        
      
        

          

            

            

              --arg source_repo "$GITOPS_SOURCE_REPO" \
          
        
      
        

          

            

            

              --arg source_commit "$GITOPS_SOURCE_COMMIT" \
          
        
      
        

          

            

            

              --arg git_tag_prefix "${GITOPS_TAG_PREFIX:-}" \
          
        
      
        

          

            

            

              --arg extra_cmd "${GITOPS_EXTRA_CMD:-}" \
          
        
      
        

          

            

            

              --arg author_name "${GIT_USER_NAME:-}" \
          
        
      
        

          

            

            

              --arg author_email "${GIT_USER_EMAIL:-}" \
          
        
      
        

          

            

            

              '{file: $file, yq_tpl: $yq_tpl, version: $version, source_repo: $source_repo, source_commit: $source_commit, git_tag_prefix: $git_tag_prefix, extra_cmd: $extra_cmd, author_name: $author_name, author_email: $author_email}')
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            DIR="$(cd "$(dirname "$0")" && pwd)"
          
        
      
        

          

            

            

            echo "gitops-dispatch: dispatching to $GITOPS_REPO/$GITOPS_WORKFLOW..."
          
        
      
        

          

            

            

            set +e
          
        
      
        

          

            

            

            OUTPUT=$(bash "$DIR/dispatch-workflow.sh" \
          
        
      
        

          

            

            

              "$GITOPS_REPO" "$GITOPS_WORKFLOW" "main" \
          
        
      
        

          

            

            

              "$INPUTS" "$GITEA_API_URL" "$GITEA_TOKEN" "$TIMEOUT" 2>&1)
          
        
      
        

          

            

            

            EXIT=$?
          
        
      
        

          

            

            

            set -e
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            echo "=== DISPATCH OUTPUT (exit=$EXIT) ==="
          
        
      
        

          

            

            

            echo "$OUTPUT"
          
        
      
        

          

            

            

            echo "=== END DISPATCH ==="
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            STATUS="failure"
          
        
      
        

          

            

            

            GITOPS_SHA=""
          
        
      
        

          

            

            

            if [ "$EXIT" = "0" ]; then
          
        
      
        

          

            

            

              STATUS="success"
          
        
      
        

          

            

            

              GITOPS_SHA=$(echo "$OUTPUT" | grep '^GITOPS_COMMIT=' | cut -d= -f2)
          
        
      
        

          

            

            

            fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            COMPONENT="${GITOPS_TAG_PREFIX:-${GITOPS_FILE}}"
          
        
      
        

          

            

            

            echo "GITOPS_SUMMARY=${COMPONENT}|${GITOPS_VERSION}|${STATUS}|${GITOPS_SHA}|${GITOPS_REPO}"
          
        
      
        

          

            

            

            exit "$EXIT"
          
        
      
    
  

    

      
        

          

            

            

            #!/usr/bin/env bash
          
        
      
        

          

            
              14
            

            

            set -euo pipefail
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              56
            

            

            SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            _gitops_fail() {
          
        
      
        

          

            
              8
            

            

              local MSG="${1:-GitOps update failed}"
          
        
      
        

          

            
              8
            

            

              echo "[ERROR] ${MSG}" >&2
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              15
            

            

              if [ -n "${GITOPS_REPO:-}" ] && [ -n "${GITOPS_SHA:-}" ] && \
          
        
      
        

          

            

            

                 [ -n "${SOURCE_REPO:-}" ] && [ -n "${SOURCE_COMMIT:-}" ] && \
          
        
      
        

          

            

            

                 [ -n "${GITEA_API_URL:-}" ] && [ -n "${GITEA_TOKEN:-}" ]; then
          
        
      
        

          

            

            

                local env repo context
          
        
      
        

          

            

            

                env=$(dirname "${INPUT_FILE}")
          
        
      
        

          

            

            

                repo=$(basename "${SOURCE_REPO}")
          
        
      
        

          

            

            

                context="${repo} ${GITHUB_RUN_ID:-unknown}"
          
        
      
        

          

            

            

                [ -n "${GIT_TAG_PREFIX:-}" ] && context="${repo}/${GIT_TAG_PREFIX} ${GITHUB_RUN_ID:-unknown}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                local SOURCE_URL="${GITEA_API_URL}/${SOURCE_REPO}/commit/${SOURCE_COMMIT}"
          
        
      
        

          

            

            

                ROOT_REPO="${GITOPS_REPO}" ROOT_COMMIT="${GITOPS_SHA}" \
          
        
      
        

          

            

            

                  GITEA_API_URL="${GITEA_API_URL}" GITEA_TOKEN="${GITEA_TOKEN}" \
          
        
      
        

          

            

            

                  bash "${SCRIPT_DIR}/report-status.sh" failure "Install to ${env} ${VERSION}" \
          
        
      
        

          

            

            

                  "${context}" "" "${SOURCE_URL}" 2>/dev/null || true
          
        
      
        

          

            

            

              fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              8
            

            

              exit 1
          
        
      
        

          

            

            

            }
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            _gitops_validate() {
          
        
      
        

          

            
              15
            

            

              [ -n "${INPUT_FILE:-}" ] || _gitops_fail "INPUT_FILE is required"
          
        
      
        

          

            
              14
            

            

              [ -n "${YQ_TPL:-}" ] || _gitops_fail "YQ_TPL is required"
          
        
      
        

          

            
              13
            

            

              [ -n "${VERSION:-}" ] || _gitops_fail "VERSION is required"
          
        
      
        

          

            
              12
            

            

              [ -n "${SOURCE_REPO:-}" ] || _gitops_fail "SOURCE_REPO is required"
          
        
      
        

          

            
              11
            

            

              [ -n "${SOURCE_COMMIT:-}" ] || _gitops_fail "SOURCE_COMMIT is required"
          
        
      
        

          

            
              10
            

            

              [ -n "${GITOPS_REPO:-}" ] || _gitops_fail "GITOPS_REPO is required"
          
        
      
        

          

            
              9
            

            

              [ -n "${GITEA_TOKEN:-}" ] || _gitops_fail "GITEA_TOKEN is required"
          
        
      
        

          

            
              8
            

            

              [ -n "${GITEA_API_URL:-}" ] || _gitops_fail "GITEA_API_URL is required"
          
        
      
        

          

            

            

            }
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            _gitops_success() {
          
        
      
        

          

            
              2
            

            

              local env repo context
          
        
      
        

          

            
              4
            

            

              env=$(dirname "${INPUT_FILE}")
          
        
      
        

          

            
              4
            

            

              repo=$(basename "${SOURCE_REPO}")
          
        
      
        

          

            
              2
            

            

              context="${repo} ${GITHUB_RUN_ID:-unknown}"
          
        
      
        

          

            
              2
            

            

              [ -n "${GIT_TAG_PREFIX:-}" ] && context="${repo}/${GIT_TAG_PREFIX} ${GITHUB_RUN_ID:-unknown}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              2
            

            

              local SOURCE_URL="${GITEA_API_URL}/${SOURCE_REPO}/commit/${SOURCE_COMMIT}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              10
            

            

              ROOT_REPO="${GITOPS_REPO}" ROOT_COMMIT="${GITOPS_SHA}" \
          
        
      
        

          

            
              10
            

            

                GITEA_API_URL="${GITEA_API_URL}" GITEA_TOKEN="${GITEA_TOKEN}" \
          
        
      
        

          

            
              10
            

            

                bash "${SCRIPT_DIR}/report-status.sh" success \
          
        
      
        

          

            
              10
            

            

                "Install to ${env} ${VERSION}" \
          
        
      
        

          

            
              10
            

            

                "${context}" "" "${SOURCE_URL}"
          
        
      
        

          

            

            

            }
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            _gitops_nochange() {
          
        
      
        

          

            

            

              local env repo context
          
        
      
        

          

            

            

              env=$(dirname "${INPUT_FILE}")
          
        
      
        

          

            

            

              repo=$(basename "${SOURCE_REPO}")
          
        
      
        

          

            

            

              context="${repo} ${GITHUB_RUN_ID:-unknown}"
          
        
      
        

          

            

            

              [ -n "${GIT_TAG_PREFIX:-}" ] && context="${repo}/${GIT_TAG_PREFIX} ${GITHUB_RUN_ID:-unknown}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              local SOURCE_URL="${GITEA_API_URL}/${SOURCE_REPO}/commit/${SOURCE_COMMIT}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              ROOT_REPO="${GITOPS_REPO}" ROOT_COMMIT="${GITOPS_SHA}" \
          
        
      
        

          

            

            

                GITEA_API_URL="${GITEA_API_URL}" GITEA_TOKEN="${GITEA_TOKEN}" \
          
        
      
        

          

            

            

                bash "${SCRIPT_DIR}/report-status.sh" success \
          
        
      
        

          

            

            

                "Install to ${env} ${VERSION} — no change" \
          
        
      
        

          

            

            

                "${context}" "" "${SOURCE_URL}"
          
        
      
        

          

            

            

            }
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            _gitops_substitute() {
          
        
      
        

          

            
              16
            

            

              echo "$1" | sed "s/{{VERSION}}/$2/g"
          
        
      
        

          

            

            

            }
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            _gitops_update() {
          
        
      
        

          

            
              4
            

            

              local CLONE_DIR="${GITOPS_TARGET_DIR:-$(mktemp -d)}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              2
            

            

              if [ -n "${GITOPS_CLONE_URL:-}" ]; then
          
        
      
        

          

            

            

                git clone "${GITOPS_CLONE_URL}" "${CLONE_DIR}" || _gitops_fail "Failed to clone GitOps repo"
          
        
      
        

          

            

            

              else
          
        
      
        

          

            
              2
            

            

                git clone "${CLONE_URL}" "${CLONE_DIR}" || _gitops_fail "Failed to clone GitOps repo"
          
        
      
        

          

            

            

              fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              2
            

            

              cd "${CLONE_DIR}" || _gitops_fail "Failed to enter clone directory"
          
        
      
        

          

            
              2
            

            

              yq eval -i "${YQ_EXPR}" "${INPUT_FILE}" || _gitops_fail "Failed to update ${INPUT_FILE}"
          
        
      
        

          

            
              2
            

            

              if [ -n "${GITOPS_EXTRA_CMD:-}" ]; then
          
        
      
        

          

            

            

                eval "${GITOPS_EXTRA_CMD}" || _gitops_fail "Extra command failed: ${GITOPS_EXTRA_CMD}"
          
        
      
        

          

            

            

                git add -A || _gitops_fail "Failed to stage all changes"
          
        
      
        

          

            

            

              else
          
        
      
        

          

            
              2
            

            

                git add "${INPUT_FILE}" || _gitops_fail "Failed to stage ${INPUT_FILE}"
          
        
      
        

          

            

            

              fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              2
            

            

              if git diff --cached --quiet; then
          
        
      
        

          

            

            

                echo "No changes — ${INPUT_FILE} already at ${VERSION}"
          
        
      
        

          

            

            

                GITOPS_SHA="$(git rev-parse HEAD)"
          
        
      
        

          

            

            

                _gitops_nochange
          
        
      
        

          

            

            

                exit 0
          
        
      
        

          

            

            

              fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              2
            

            

              git -c user.name="${GIT_USER_NAME:-gitea-ci-bot}" \
          
        
      
        

          

            

            

                  -c user.email="${GIT_USER_EMAIL:-ci@keskikuja.site}" \
          
        
      
        

          

            

            

                  commit -m "[skip ci] gitops: update version to ${VERSION}" || _gitops_fail "Failed to commit"
          
        
      
        

          

            
              4
            

            

              GITOPS_SHA="$(git rev-parse HEAD)"
          
        
      
        

          

            
              2
            

            

              git push || _gitops_fail "Failed to push"
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              2
            

            

              _gitops_success
          
        
      
        

          

            

            

            }
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              14
            

            

            _gitops_validate
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              12
            

            

            YQ_EXPR=$(_gitops_substitute "${YQ_TPL}" "${VERSION}")
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              24
            

            

            GITEA_HOST=$(echo "${GITEA_API_URL}" | sed 's|https://||' | sed 's|http://||')
          
        
      
        

          

            
              6
            

            

            CLONE_URL="${GITOPS_CLONE_URL:-https://${GITEA_TOKEN}@${GITEA_HOST}/${GITOPS_REPO}.git}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              6
            

            

            if [ "${BASH_SOURCE[0]}" = "${0}" ]; then
          
        
      
        

          

            
              2
            

            

              _gitops_update
          
        
      
        

          

            

            

            fi
          
        
      
    
  

    

      
        

          

            
              3
            

            

            #!/usr/bin/env sh
          
        
      
        

          

            
              10
            

            

            set -eu
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              10
            

            

            SUITE_PATH="${1:-}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              12
            

            

            [ -n "$SUITE_PATH" ] || { echo "ERROR: suite_path argument required" >&2; exit 1; }
          
        
      
        

          

            
              11
            

            

            [ -n "${GIT_PAGES_URL:-}" ] || { echo "ERROR: GIT_PAGES_URL is not set" >&2; exit 1; }
          
        
      
        

          

            
              10
            

            

            [ -n "${REPORTS_PUBLISH_TOKEN:-}" ] || { echo "ERROR: REPORTS_PUBLISH_TOKEN is not set" >&2; exit 1; }
          
        
      
        

          

            
              9
            

            

            [ -n "${GITHUB_REPOSITORY:-}" ] || { echo "ERROR: GITHUB_REPOSITORY is not set" >&2; exit 1; }
          
        
      
        

          

            
              6
            

            

            [ -n "${GITHUB_SHA:-}" ] || { echo "ERROR: GITHUB_SHA is not set" >&2; exit 1; }
          
        
      
        

          

            
              8
            

            

            [ -n "${GITHUB_REF_NAME:-}" ] || { echo "ERROR: GITHUB_REF_NAME is not set" >&2; exit 1; }
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              5
            

            

            OWNER="${GITHUB_REPOSITORY%%/*}"
          
        
      
        

          

            
              5
            

            

            REPO="${GITHUB_REPOSITORY##*/}"
          
        
      
        

          

            
              15
            

            

            SHA8=$(echo "$GITHUB_SHA" | cut -c1-8)
          
        
      
        

          

            
              5
            

            

            BRANCH="${GITHUB_REF_NAME}"
          
        
      
        

          

            
              5
            

            

            SUITE="${SUITE_PATH%/}"
          
        
      
        

          

            
              5
            

            

            PAGES_USER="${GIT_PAGES_PUBLISH_USER:-publish}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              7
            

            

            [ -d "$SUITE" ] || { echo "ERROR: not a directory: $SUITE" >&2; exit 1; }
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              4
            

            

            EMPTY=1
          
        
      
        

          

            
              5
            

            

            for _f in "$SUITE"/* "$SUITE"/.*; do
          
        
      
        

          

            
              11
            

            

              [ -e "$_f" ] && { EMPTY=0; break; }
          
        
      
        

          

            

            

            done
          
        
      
        

          

            
              6
            

            

            [ "$EMPTY" -eq 0 ] || { echo "ERROR: no files to publish in $SUITE" >&2; exit 1; }
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              6
            

            

            WORK=$(mktemp -d)
          
        
      
        

          

            
              6
            

            

            TAR=$(mktemp)
          
        
      
        

          

            
              3
            

            

            trap 'rm -rf "$WORK" "$TAR"' EXIT
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            # Kopioi raporttitiedostot
          
        
      
        

          

            
              3
            

            

            mkdir -p "$WORK/$SUITE"
          
        
      
        

          

            
              3
            

            

            cp -a "$SUITE/." "$WORK/$SUITE/"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            # Generoi index.html (sama logiikka kuin nykyään)
          
        
      
        

          

            
              3
            

            

            cd "$WORK/$SUITE"
          
        
      
        

          

            
              3
            

            

            if [ ! -f "index.html" ]; then
          
        
      
        

          

            
              1
            

            

              ITEM_LIST=""
          
        
      
        

          

            
              1
            

            

              ITEM_COUNT=0
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              1
            

            

              for f in *; do
          
        
      
        

          

            
              1
            

            

                [ -f "$f" ] || continue
          
        
      
        

          

            
              1
            

            

                [ "$f" = "index.html" ] && continue
          
        
      
        

          

            
              2
            

            

                ITEM_LIST="${ITEM_LIST}file:${f}
          
        
      
        

          

            
              1
            

            

            "
          
        
      
        

          

            
              1
            

            

                ITEM_COUNT=$((ITEM_COUNT + 1))
          
        
      
        

          

            
              2
            

            

              done
          
        
      
        

          

            
              2
            

            

            
          
        
      
        

          

            
              1
            

            

              for d in */; do
          
        
      
        

          

            
              2
            

            

                [ -d "$d" ] || continue
          
        
      
        

          

            

            

                d="${d%/}"
          
        
      
        

          

            

            

                [ -f "$d/index.html" ] || continue
          
        
      
        

          

            
              1
            

            

                ITEM_LIST="${ITEM_LIST}dir:${d}
          
        
      
        

          

            
              1
            

            

            "
          
        
      
        

          

            
              1
            

            

                ITEM_COUNT=$((ITEM_COUNT + 1))
          
        
      
        

          

            
              1
            

            

              done
          
        
      
        

          

            
              1
            

            

            
          
        
      
        

          

            
              1
            

            

              if [ "$ITEM_COUNT" -gt 1 ]; then
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  echo '<!DOCTYPE html><html lang="en"><head><meta charset="utf-8">'
          
        
      
        

          

            

            

                  echo "<title>Test report ${SHA8}</title>"
          
        
      
        

          

            

            

                  echo '<style>body{font-family:sans-serif;margin:2em;max-width:960px}'
          
        
      
        

          

            

            

                  echo 'h1{color:#1e293b}ul{list-style:none;padding:0}'
          
        
      
        

          

            

            

                  echo 'li{margin:.5em 0;padding:.5em;background:#f8fafc;border-radius:6px}'
          
        
      
        

          

            

            

                  echo 'a{color:#2563eb;text-decoration:none}a:hover{text-decoration:underline}'
          
        
      
        

          

            

            

                  echo '</style></head><body>'
          
        
      
        

          

            

            

                  echo "<h1>Test report <code>${SHA8}</code></h1><ul>"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  echo "$ITEM_LIST" | while IFS= read -r item; do
          
        
      
        

          

            

            

                    [ -z "$item" ] && continue
          
        
      
        

          

            

            

                    item_type=$(echo "$item" | cut -d: -f1)
          
        
      
        

          

            

            

                    item_name=$(echo "$item" | cut -d: -f2-)
          
        
      
        

          

            

            

                    label=$(echo "$item_name" | sed -e 's/\.[^.]*$//' -e 's/[-_]/ /g')
          
        
      
        

          

            

            

                    first=$(echo "$label" | cut -c1 | tr '[:lower:]' '[:upper:]')
          
        
      
        

          

            

            

                    rest=$(echo "$label" | cut -c2-)
          
        
      
        

          

            

            

                    if [ "$item_type" = "file" ]; then
          
        
      
        

          

            

            

                      echo "<li><a href=\"$item_name\">${first}${rest}</a></li>"
          
        
      
        

          

            

            

                    else
          
        
      
        

          

            

            

                      echo "<li><a href=\"$item_name/index.html\">${first}${rest}</a></li>"
          
        
      
        

          

            

            

                    fi
          
        
      
        

          

            

            

                  done
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  echo '</ul></body></html>'
          
        
      
        

          

            

            

                } > "index.html"
          
        
      
        

          

            

            

              fi
          
        
      
        

          

            

            

            fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            # .meta tiedosto retentionia varten
          
        
      
        

          

            
              6
            

            

            cat > ".meta" <<EOF
          
        
      
        

          

            
              6
            

            

            {"branch":"${BRANCH}","sha":"${GITHUB_SHA}","published_at":"$(date -u +%Y-%m-%dT%H:%M:%SZ)"}
          
        
      
        

          

            
              6
            

            

            EOF
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              3
            

            

            cd "$WORK"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            # Pakkaa: pelkät tiedostot ilman $SUITE-etuliitettä
          
        
      
        

          

            
              3
            

            

            tar czf "$TAR" -C "$WORK/$SUITE" .
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            # PUT upload-sidecariin
          
        
      
        

          

            
              3
            

            

            PUBLISH_URL="${GIT_PAGES_URL}/${OWNER}/${REPO}/${BRANCH}/${SHA8}/${SUITE}/"
          
        
      
        

          

            

            

            HTTP_CODE=$(curl -sS -X PUT "$PUBLISH_URL" \
          
        
      
        

          

            

            

              -u "${PAGES_USER}:${REPORTS_PUBLISH_TOKEN}" \
          
        
      
        

          

            

            

              -H "Content-Type: application/tar+gz" \
          
        
      
        

          

            

            

              --data-binary @"$TAR" \
          
        
      
        

          

            

            

              -o /tmp/git-pages-publish-response.txt \
          
        
      
        

          

            
              6
            

            

              -w "%{http_code}")
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              3
            

            

            case "$HTTP_CODE" in
          
        
      
        

          

            

            

              200|201|204) ;;
          
        
      
        

          

            

            

              *)
          
        
      
        

          

            
              1
            

            

                echo "ERROR: publish HTTP ${HTTP_CODE}" >&2
          
        
      
        

          

            
              1
            

            

                cat /tmp/git-pages-publish-response.txt >&2
          
        
      
        

          

            
              1
            

            

                exit 1
          
        
      
        

          

            

            

                ;;
          
        
      
        

          

            

            

            esac
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              2
            

            

            echo "${PUBLISH_URL}"
          
        
      
    
  

    

      
        

          

            

            

            #!/usr/bin/env bash
          
        
      
        

          

            
              1
            

            

            set -euo pipefail
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              1
            

            

            SUITE_PATH="${1:-}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              1
            

            

            [ -n "$SUITE_PATH" ] || { echo "ERROR: suite_path argument required" >&2; exit 1; }
          
        
      
        

          

            
              3
            

            

            [ -n "${GITEA_API_URL:-}" ] || { echo "ERROR: GITEA_API_URL is not set" >&2; exit 1; }
          
        
      
        

          

            
              3
            

            

            [ -n "${GITEA_TOKEN:-}" ] || { echo "ERROR: GITEA_TOKEN is not set" >&2; exit 1; }
          
        
      
        

          

            

            

            [ -n "${GIT_PAGES_URL:-}" ] || { echo "ERROR: GIT_PAGES_URL is not set" >&2; exit 1; }
          
        
      
        

          

            

            

            [ -n "${REPORTS_PUBLISH_TOKEN:-}" ] || { echo "ERROR: REPORTS_PUBLISH_TOKEN is not set" >&2; exit 1; }
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            SCRIPT_DIR="$(dirname "$0")"
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            REPORT_URL=$(bash "$SCRIPT_DIR/publish-git-pages.sh" "$SUITE_PATH")
          
        
      
        

          

            

            

            echo "Published: $REPORT_URL"
          
        
      
        

          

            

            

            bash "$SCRIPT_DIR/report-status.sh" success "Reports published" "ci-report"
          
        
      
    
  

    

      
        

          

            

            

            #!/usr/bin/env sh
          
        
      
        

          

            
              5
            

            

            set -eu
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              5
            

            

            STATE="${1:-}"
          
        
      
        

          

            
              5
            

            

            DESCRIPTION="${2:-}"
          
        
      
        

          

            
              31
            

            

            SHA8=$(echo "${GITHUB_SHA:-}" | cut -c1-8)
          
        
      
        

          

            
              11
            

            

            KEY="${3:-commit-${SHA8}}"
          
        
      
        

          

            
              11
            

            

            SUITE="${4:-}"
          
        
      
        

          

            
              11
            

            

            CUSTOM_URL="${5:-}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              13
            

            

            [ -z "$STATE" ] && echo "ERROR: state argument is required" >&2 && exit 1
          
        
      
        

          

            
              12
            

            

            [ -z "$DESCRIPTION" ] && echo "ERROR: description argument is required" >&2 && exit 1
          
        
      
        

          

            
              11
            

            

            [ -z "${GITEA_API_URL:-}" ] && echo "ERROR: GITEA_API_URL is not set" >&2 && exit 1
          
        
      
        

          

            
              10
            

            

            [ -z "${GITEA_TOKEN:-}" ] && echo "ERROR: GITEA_TOKEN is not set" >&2 && exit 1
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              7
            

            

            if [ -n "$CUSTOM_URL" ]; then
          
        
      
        

          

            
              2
            

            

              URL="$CUSTOM_URL"
          
        
      
        

          

            
              5
            

            

            elif [ -n "$SUITE" ]; then
          
        
      
        

          

            
              1
            

            

              SUITE="${SUITE%/}/"
          
        
      
        

          

            
              3
            

            

              SHA8_CUT=$(echo "$GITHUB_SHA" | cut -c1-8)
          
        
      
        

          

            
              1
            

            

              URL="${GIT_PAGES_URL}/${GITHUB_REPOSITORY}/${GITHUB_REF_NAME}/${SHA8_CUT}/${SUITE}"
          
        
      
        

          

            

            

            else
          
        
      
        

          

            
              4
            

            

              URL="${GITEA_API_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}"
          
        
      
        

          

            

            

            fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              7
            

            

            REPO="${ROOT_REPO:-${GITHUB_REPOSITORY:-}}"
          
        
      
        

          

            
              7
            

            

            COMMIT="${ROOT_COMMIT:-${GITHUB_SHA:-}}"
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              7
            

            

            [ -z "$REPO" ] && echo "ERROR: GITHUB_REPOSITORY is not set" >&2 && exit 1
          
        
      
        

          

            
              7
            

            

            [ -z "$COMMIT" ] && echo "ERROR: GITHUB_SHA is not set" >&2 && exit 1
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

            HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" \
          
        
      
        

          

            

            

              -X POST "$GITEA_API_URL/api/v1/repos/$REPO/statuses/$COMMIT" \
          
        
      
        

          

            

            

              -H "Authorization: token $GITEA_TOKEN" \
          
        
      
        

          

            

            

              -H "Content-Type: application/json" \
          
        
      
        

          

            
              15
            

            

              -d "{\"state\":\"$STATE\",\"target_url\":\"$URL\",\"description\":\"$DESCRIPTION\",\"context\":\"$KEY\"}" || true)
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              8
            

            

            if [ "$HTTP_CODE" = "201" ]; then
          
        
      
        

          

            
              7
            

            

              exit 0
          
        
      
        

          

            

            

            fi
          
        
      
        

          

            

            

            
          
        
      
        

          

            
              2
            

            

            if [ -z "$HTTP_CODE" ] || [ "$HTTP_CODE" = "000" ]; then
          
        
      
        

          

            

            

              echo "gitea-ci-library - ERROR: Failed to connect to Gitea API at $GITEA_API_URL" >&2
          
        
      
        

          

            

            

            else
          
        
      
        

          

            
              1
            

            

              echo "gitea-ci-library - ERROR: gitea-ci-library, API returned HTTP $HTTP_CODE" >&2
          
        
      
        

          

            

            

            fi
          
        
      
        

          

            
              1
            

            

            exit 1