go-caatsm/Taskfile.yml

version: '3'

vars:
  build_dir: bin
  binary: '{{.build_dir}}/receiver'
  cmd: ./cmd/main
  version:
    sh: echo "${VERSION:-dev}"
  git_commit:
    sh: git rev-parse --short HEAD 2>/dev/null || echo unknown
  build_time:
    sh: |
      mkdir -p .tmp
      echo 'package main' > .tmp/build_time.go
      echo 'import ("fmt"; "time")' >> .tmp/build_time.go
      echo 'func main() { fmt.Print(time.Now().UTC().Format("2006-01-02T15:04:05Z")) }' >> .tmp/build_time.go
      go run .tmp/build_time.go
      rm -rf .tmp

tasks:
  all:
    desc: Default target
    cmds:
      - task: build

  build:
    desc: Build the receiver binary
    cmds:
      - mkdir -p {{.build_dir}}
      - echo "Building receiver..."
      - |
        echo "  Version: {{.version}}"
        echo "  Commit: {{.git_commit}}"
        echo "  Built: {{.build_time}}"
      - |
        go build \
          -ldflags "-X 'caatsm/internal/infra/buildinfo.Version={{.version}}' \
                    -X 'caatsm/internal/infra/buildinfo.Commit={{.git_commit}}' \
                    -X 'caatsm/internal/infra/buildinfo.BuiltAt={{.build_time}}'" \
          -o {{.binary}} {{.cmd}}

  run:
    desc: Alias for run-dev
    cmds:
      - task: run-dev

  run-dev:
    desc: 'Run the receiver in development mode (uses core NATS mode by default). Use MONITORING_ADDR=ip:port to set monitoring address'
    vars:
      MONITORING_ADDR:
        sh: echo "${MONITORING_ADDR:-}"
    deps:
      - build
    cmds:
      - |
        echo "Running receiver in development mode (NATS mode: core by default)..."
      - |
        cmd="GO_ENV=dev {{.binary}} listen"
        if [ -n "${MONITORING_ADDR:-}" ]; then
          echo "Monitoring address: ${MONITORING_ADDR}"
          cmd="$cmd --monitoring-addr ${MONITORING_ADDR}"
        fi
        eval "$cmd"

  run-prod:
    desc: Run the receiver in production mode (requires config.prod.toml and JetStream mode)
    deps:
      - build
    cmds:
      - |
        echo "Running receiver in production mode..."
        echo "Note: Production mode requires:"
        echo "  - configs/config.prod.toml file (or CAATSM_* environment variables)"
        echo "  - NATS JetStream enabled (nats.mode = jetstream)"
        echo "  - Stream and Consumer must exist (not auto-created in prod)"
        echo "  - PostgreSQL connection configured"
      - GO_ENV=prod {{.binary}} listen

  run-test:
    desc: Run the receiver in test mode
    deps:
      - build
    cmds:
      - echo "Running receiver in test mode..."
      - GO_ENV=test {{.binary}} listen

  run-local:
    desc: 'Run receiver via go run (default GO_ENV=dev, uses core NATS mode by default). Use MONITORING_ADDR=ip:port to set monitoring address'
    vars:
      MONITORING_ADDR:
        sh: echo "${MONITORING_ADDR:-}"
    cmds:
      - |
        echo "Running receiver via go run (GO_ENV=${GO_ENV:-dev}, NATS mode: core by default in dev)..."
      - |
        cmd="GO_ENV=${GO_ENV:-dev} go run {{.cmd}} listen"
        if [ -n "${MONITORING_ADDR:-}" ]; then
          echo "Monitoring address: ${MONITORING_ADDR}"
          cmd="$cmd --monitoring-addr ${MONITORING_ADDR}"
        fi
        eval "$cmd"

  test:
    desc: Run Ginkgo unit test suites (verbose)
    cmds:
      - |
        if ! command -v ginkgo >/dev/null; then
          echo "Install ginkgo (go install github.com/onsi/ginkgo/v2/ginkgo@latest)"
          exit 1
        fi
      - echo "Running Ginkgo unit test suites (verbose)..."
      - ginkgo -r -v ./cmd ./internal

  test-int:
    desc: Run integration tests (requires Docker)
    cmds:
      - |
        echo "Running integration tests (Docker required)..."
        GO_ENV=${GO_ENV:-test} go test -tags=integration ./test/integration/...

  test-ginkgo:
    desc: Alias for Ginkgo unit test suites
    cmds:
      - task: test

  test-all:
    desc: Run unit tests (Ginkgo) and integration tests
    cmds:
      - task: test
      - task: test-int

  coverage:
    desc: Generate coverage report (profile + HTML)
    cmds:
      - mkdir -p coverage
      - echo "Generating test coverage report..."
      - go test ./... -coverprofile=coverage/coverage.out
      - go tool cover -html=coverage/coverage.out -o coverage/coverage.html

  fmt:
    desc: Format Go code
    cmds:
      - echo "Formatting code..."
      - go fmt ./...

  lint:
    desc: Run golangci-lint
    cmds:
      - |
        if ! command -v golangci-lint >/dev/null; then
          echo "Install golangci-lint: https://golangci-lint.run/"
          exit 1
        fi
      - echo "Linting code..."
      - golangci-lint run ./...

  wire:
    desc: Generate wire dependency injection code
    cmds:
      - |
        if ! command -v wire >/dev/null; then
          echo "Install wire: go install github.com/google/wire/cmd/wire@latest"
          exit 1
        fi
      - echo "Generating wire code..."
      - wire ./pkg/di

  generate:
    desc: Generate all code (wire, etc.)
    cmds:
      - task: wire
      - echo "Code generation complete"

  deps:
    desc: Sync go.mod / go.sum
    cmds:
      - echo "Tidying go modules..."
      - go mod tidy

  upgrade:
    desc: Upgrade Go dependencies
    cmds:
      - echo "Upgrading go modules..."
      - go get -u -v ./...
      - go mod tidy

  install-test:
    desc: Install ginkgo/gomega tooling
    cmds:
      - echo "Installing ginkgo tooling..."
      - go install github.com/onsi/ginkgo/v2/ginkgo@latest
      - go get github.com/onsi/gomega/...

  clean:
    desc: Clean build + coverage artifacts
    cmds:
      - echo "Cleaning build artifacts..."
      - rm -rf {{.build_dir}} coverage

  up:
    desc: 'Start TimescaleDB + NATS dev stack (docker compose). Use MONITORING_ADDR=ip:port to set Prometheus scrape target'
    vars:
      MONITORING_ADDR:
        sh: echo "${MONITORING_ADDR:-host.docker.internal:2112}"
    cmds:
      - echo "Starting dev infrastructure..."
      - |
        monitoring_addr="${MONITORING_ADDR:-host.docker.internal:2112}"
        echo "Prometheus will scrape caatsm-receiver at: ${monitoring_addr}"
        CAATSM_MONITORING_ADDR="${monitoring_addr}" \
        docker compose -f docker-compose.dev.yml up -d postgres nats nats-box nats-exporter
      - |
        monitoring_addr="${MONITORING_ADDR:-host.docker.internal:2112}"
        CAATSM_MONITORING_ADDR="${monitoring_addr}" \
        docker compose -f docker-compose.dev.yml up -d otel-collector jaeger prometheus grafana

  down:
    desc: Stop dev compose stack and remove containers
    cmds:
      - echo "Stopping dev infrastructure..."
      - docker compose -f docker-compose.dev.yml down -v

  dev-run-compose:
    desc: 'Run receiver inside docker-compose dev stack. Use MONITORING_ADDR=ip:port to set Prometheus scrape target'
    vars:
      MONITORING_ADDR:
        sh: echo "${MONITORING_ADDR:-host.docker.internal:2112}"
    cmds:
      - echo "Starting dev stack including caatsm-receiver..."
      - |
        monitoring_addr="${MONITORING_ADDR:-host.docker.internal:2112}"
        echo "Prometheus will scrape caatsm-receiver at: ${monitoring_addr}"
        CAATSM_MONITORING_ADDR="${monitoring_addr}" \
        docker compose -f docker-compose.dev.yml up -d postgres nats nats-box nats-exporter
      - |
        monitoring_addr="${MONITORING_ADDR:-host.docker.internal:2112}"
        CAATSM_MONITORING_ADDR="${monitoring_addr}" \
        docker compose -f docker-compose.dev.yml up -d otel-collector jaeger prometheus grafana caatsm-receiver

  dev-run:
    desc: 'Run receiver locally against dev stack. Use MONITORING_ADDR=ip:port to set monitoring address (default: 0.0.0.0:2112)'
    vars:
      MONITORING_ADDR:
        sh: echo "${MONITORING_ADDR:-0.0.0.0:2112}"
    deps:
      - up
    env:
      CAATSM_NATS_URL: nats://localhost:4222
      CAATSM_NATS_MODE: core
      CAATSM_POSTGRES_URL: postgres://caatsm:caatsm@localhost:5432/aviation?sslmode=disable
      CAATSM_TELEMETRY_ENABLED: "true"
      CAATSM_TELEMETRY_ENDPOINT: localhost:4318
      CAATSM_TELEMETRY_INSECURE: "true"
      CAATSM_MONITORING_ENABLE_METRICS: "true"
      CAATSM_MONITORING_ENABLE_HEALTH: "true"
      GO_ENV: dev
    cmds:
      - |
        echo "Ensuring observability stack is healthy (Jaeger @ http://localhost:16686)"
        docker compose -f docker-compose.dev.yml ps jaeger otel-collector >/dev/null
        monitoring_addr="${MONITORING_ADDR:-0.0.0.0:2112}"
        echo "Running receiver with telemetry (mode=${CAATSM_NATS_MODE:-core}, monitoring=${monitoring_addr})"
        echo "Note: Ensure Prometheus is configured to scrape ${monitoring_addr}"
        echo "      If using a different IP, restart Prometheus with: MONITORING_ADDR=${monitoring_addr} task up"
        CAATSM_NATS_MODE=${CAATSM_NATS_MODE:-core} \
        go run ./cmd/main listen --monitoring-addr "${monitoring_addr}"

  seed:
    desc: Generate sample telegrams (publishes to Core NATS by default, compatible with dev mode)
    cmds:
      - |
        GO_ENV=dev \
        NATS_URL=${CAATSM_NATS_URL:-nats://localhost:4222} \
        SUBJECT=${CAATSM_NATS_SUBJECT:-telegram.serial} \
        COUNT={{.COUNT | default "10"}} \
        CATEGORY={{.CATEGORY | default "mixed"}} \
        STATUS={{.STATUS | default "random"}} \
        bash -c '
          set -euo pipefail
          cmd=(go run ./cmd/seed-telegrams)
          if [ -n "$NATS_URL" ]; then
            cmd+=("--nats-url" "$NATS_URL")
          fi
          cmd+=(
            --subject "$SUBJECT"
            --count "$COUNT"
            --category "$CATEGORY"
            --status "$STATUS"
          )
          exec "${cmd[@]}"
        '

  seed-slow:
    desc: Continuously send telegrams slowly (until Ctrl-C). Uses JetStream by default. Configurable interval.
    cmds:
      - |
        GO_ENV=dev \
        NATS_URL=${CAATSM_NATS_URL:-nats://localhost:4222} \
        SUBJECT=${CAATSM_NATS_SUBJECT:-telegram.serial} \
        CATEGORY={{.CATEGORY | default "mixed"}} \
        STATUS={{.STATUS | default "random"}} \
        MODE={{.MODE | default "interval"}} \
        INTERVAL_MIN={{.INTERVAL_MIN | default "2s"}} \
        INTERVAL_MAX={{.INTERVAL_MAX | default "5s"}} \
        USE_JS={{.USE_JS | default "true"}} \
        JS_STREAM={{.JS_STREAM | default "TELEGRAM"}} \
        JS_SUBJECT={{.JS_SUBJECT | default ""}} \
        bash -c '
          set -euo pipefail
          echo "Starting slow continuous telegram seeding..."
          echo "  Mode: $MODE"
          echo "  Interval: $INTERVAL_MIN - $INTERVAL_MAX"
          echo "  Category: $CATEGORY"
          echo "  Status: $STATUS"
          echo "  Press Ctrl-C to stop"
          echo ""
          cmd=(go run ./cmd/seed-telegrams)
          if [ -n "$NATS_URL" ]; then
            cmd+=("--nats-url" "$NATS_URL")
          fi
          if [ "$USE_JS" = "true" ]; then
            cmd+=("--jetstream")
            if [ -n "$JS_STREAM" ]; then
              cmd+=("--stream" "$JS_STREAM")
            fi
            if [ -n "$JS_SUBJECT" ]; then
              cmd+=("--js-subject" "$JS_SUBJECT")
            fi
          fi
          cmd+=(
            --subject "$SUBJECT"
            --count 0
            --category "$CATEGORY"
            --status "$STATUS"
            --mode "$MODE"
            --interval-min "$INTERVAL_MIN"
            --interval-max "$INTERVAL_MAX"
          )
          exec "${cmd[@]}"
        '

  help:
    desc: Show this help message
    cmds:
      - |
        printf "Task targets:\n"
        task --list