Taskfile.yml

---
version: 3

env:
  GORACE: halt_on_error=1,history_size=2

vars:
  BENCHTIME: 5s
  FUZZTIME: 15s
  FUZZCORPUS: ../fuzz-corpus

tasks:
  # invoked when `task` is run without arguments
  default:
    deps: [all]

  all:
    desc: "Generate, format, build, test and lint code and documentation"
    cmds:
      - task: gen
      - task: build-testcover
      - task: test
      - task: lint
      - task: docs

  gen-version:
    run: once
    cmds:
      - go generate -x ./internal/util/version

  init-tools:
    dir: tools
    cmds:
      - go mod tidy
      - go mod verify
      - go generate -x

  init-integration:
    dir: integration
    cmds:
      - go mod tidy
      - go mod verify

  init:
    desc: "Install development tools"
    deps: [gen-version, init-tools, init-integration]
    cmds:
      - go mod tidy
      - go mod verify

  init-clean:
    desc: "Clean ALL Go and Docker data (caches, images, volumes), and re-init"
    cmds:
      - cmd: docker buildx prune --all
        ignore_error: true # build container may not exist
      - docker system prune --all --volumes
      - bin/golangci-lint{{exeExt}} cache clean
      - go clean -cache -testcache -modcache -fuzzcache
      - task: init

  env-setup:
    deps: [gen-version]
    cmds:
      - go run {{if ne OS "windows"}}-race{{end}} ./cmd/envtool/main.go

  env-up-detach:
    cmds:
      - >
        docker-compose up --always-recreate-deps --build --force-recreate --remove-orphans --renew-anon-volumes --timeout=0 --detach
        postgres tigris mongodb

  env-up:
    desc: "Start development environment"
    deps: [env-up-detach, env-setup]
    cmds:
      - docker-compose logs --follow

  env-pull:
    desc: "Pull development environment's Docker images"
    cmds:
      - docker-compose build --pull

  env-down:
    desc: "Stop development environment"
    cmds:
      - docker-compose down --remove-orphans --timeout=0 --volumes

  env-data:
    desc: "Fill `test` database with data for experiments"
    cmds:
      - bin/task{{exeExt}} -d integration env-data

  gen:
    desc: "Generate (and format) code"
    cmds:
      - go generate -x ./...
      - bin/task{{exeExt}} -d integration gen
      - task: fmt

  fmt:
    desc: "Format code"
    cmds:
      - bin/goimports{{exeExt}} -format-only -local=github.com/FerretDB/FerretDB -w .
      - bin/gofumpt{{exeExt}} -w .

  test:
    desc: "Run all unit and integration tests in parallel"
    deps: [test-unit, test-integration]

  test-unit-short:
    desc: "Run short unit tests (with caching)"
    cmds:
      - go test -short {{if ne OS "windows"}}-race{{end}} -shuffle=on -coverprofile=cover.txt -coverpkg=./... ./...
      - bin/task{{exeExt}} -d tools test-unit-short

  test-unit:
    desc: "Run all unit tests"
    cmds:
      - go test -count=1 {{if ne OS "windows"}}-race{{end}} -shuffle=on -coverprofile=cover.txt -coverpkg=./... ./...
      - go test -count=1 {{if ne OS "windows"}}-race{{end}} -shuffle=on -bench=. -benchtime=1x ./...
      - bin/task{{exeExt}} -d tools test-unit-short

  test-integration:
    desc: "Run all integration tests in parallel"
    deps:
      - test-integration-pg
      - test-integration-tigris
      - test-integration-mongodb

  test-integration-pg:
    desc: "Run integration tests for PostgreSQL handler"
    dir: integration
    cmds:
      - >
        go test -count=1 {{if ne OS "windows"}}-race{{end}} -shuffle=on -coverpkg=../...
        -coverprofile=integration-pg.txt
        . -handler=pg

  test-integration-tigris:
    desc: "Run integration tests for Tigris handler"
    dir: integration
    cmds:
      - >
        go test -count=1 {{if ne OS "windows"}}-race{{end}} -shuffle=on -coverpkg=../...
        -coverprofile=integration-tigris.txt -tags=ferretdb_tigris
        . -handler=tigris

  test-integration-mongodb:
    desc: "Run integration tests for MongoDB"
    dir: integration
    cmds:
      - >
        go test -count=1 {{if ne OS "windows"}}-race{{end}} -shuffle=on -coverpkg=../...
        -coverprofile=integration-mongodb.txt
        . -target-port=37017 -compat-port=0

  bench-short:
    desc: "Benchmark for about 20 seconds (with default BENCHTIME)"
    cmds:
      - go test -list='Benchmark.*' ./...
      - echo 'Running four functions for {{.BENCHTIME}} each...'
      - go test -bench=BenchmarkArray    -benchtime={{.BENCHTIME}} ./internal/bson/  | tee -a new.txt
      - go test -bench=BenchmarkDocument -benchtime={{.BENCHTIME}} ./internal/bson/  | tee -a new.txt
      - go test -bench=BenchmarkArray    -benchtime={{.BENCHTIME}} ./internal/fjson/ | tee -a new.txt
      - go test -bench=BenchmarkDocument -benchtime={{.BENCHTIME}} ./internal/fjson/ | tee -a new.txt
      - bin/benchstat{{exeExt}} old.txt new.txt

  # That's not quite correct: https://github.com/golang/go/issues/15513
  # But good enough for us.
  fuzz-init:
    deps: [gen-version]
    cmds:
      - go test -count=0 ./...

  # Those commands should still run tests (i.e., should not have -run=XXX flags)
  # to fill seed corpus for fuzz tests that use WriteSeedCorpusFile (e.g., FuzzHandler).
  fuzz:
    desc: "Fuzz for about 2 minutes (with default FUZZTIME)"
    cmds:
      - go test -list='Fuzz.*' ./...
      - echo 'Running eight functions for {{.FUZZTIME}} each...'
      - go test -fuzz=FuzzArray -fuzztime={{.FUZZTIME}} ./internal/bson/
      - go test -fuzz=FuzzDocument -fuzztime={{.FUZZTIME}} ./internal/bson/
      - go test -fuzz=FuzzArray -fuzztime={{.FUZZTIME}} ./internal/fjson/
      - go test -fuzz=FuzzDocument -fuzztime={{.FUZZTIME}} ./internal/fjson/
      - go test -fuzz=FuzzMsg -fuzztime={{.FUZZTIME}} ./internal/wire/
      - go test -fuzz=FuzzQuery -fuzztime={{.FUZZTIME}} ./internal/wire/
      - go test -fuzz=FuzzReply -fuzztime={{.FUZZTIME}} ./internal/wire/
      - go test -fuzz=FuzzHandler -fuzztime={{.FUZZTIME}} ./internal/handlers/

  fuzz-corpus:
    desc: "Sync seed and generated fuzz corpora with FUZZCORPUS"
    cmds:
      - go run {{if ne OS "windows"}}-race{{end}} ./cmd/fuzztool/fuzztool.go -dst={{.FUZZCORPUS}} -src=generated
      - go run {{if ne OS "windows"}}-race{{end}} ./cmd/fuzztool/fuzztool.go -dst={{.FUZZCORPUS}} -src=seed
      - go run {{if ne OS "windows"}}-race{{end}} ./cmd/fuzztool/fuzztool.go -src={{.FUZZCORPUS}} -dst=generated

  build-testcover:
    desc: "Build bin/ferretdb-testcover"
    run: once
    deps: [gen-version]
    cmds:
      - go test -c -o=bin/ferretdb-testcover{{exeExt}} -trimpath -tags=ferretdb_testcover,ferretdb_tigris {{if ne OS "windows"}}-race{{end}} -coverpkg=./... ./cmd/ferretdb

  run:
    desc: "Run FerretDB"
    deps: [build-testcover]
    cmds:
      - bin/ferretdb-testcover{{exeExt}} -test.coverprofile=cover.txt -mode=diff-normal -listen-addr=:27017

  run-tigris:
    deps: [build-testcover]
    cmds:
      - bin/ferretdb-testcover{{exeExt}} -test.coverprofile=cover.txt -mode=diff-normal -listen-addr=:27017 -handler=tigris

  run-proxy:
    desc: "Run FerretDB in diff-proxy mode"
    deps: [build-testcover]
    cmds:
      - bin/ferretdb-testcover{{exeExt}} -test.coverprofile=cover.txt -mode=diff-proxy -listen-addr=:27017

  lint:
    desc: "Run linters"
    deps:
      - lint-golangci-lint
      - lint-go-sumtype
      - lint-go-consistent
    cmds:
      - bin/golangci-lint{{exeExt}} run --config=.golangci-new.yml
      - go vet -vettool=./bin/checkswitch{{exeExt}} ./...

  lint-golangci-lint:
    cmds:
      - bin/golangci-lint{{exeExt}} run --config=.golangci.yml

  lint-go-sumtype:
    cmds:
      - bin/go-sumtype{{exeExt}} ./...

  lint-go-consistent:
    cmds:
      - bin/go-consistent{{exeExt}} -pedantic ./cmd/... ./internal/... ./ferretdb/...
      - bin/task{{exeExt}} -d integration lint-go-consistent
      - bin/task{{exeExt}} -d tools lint-go-consistent

  docs:
    desc: "Format and lint documentation"
    cmds:
      - docker-compose run --rm markdownlint --fix --dot --ignore CHANGELOG.md '**/*.md'

  godocs:
    desc: "Serve godoc documentation at http://127.0.0.1:6060/pkg/github.com/FerretDB/FerretDB/?m=all"
    cmds:
      - bin/godoc{{exeExt}} -http=127.0.0.1:6060

  psql:
    desc: "Run psql"
    cmds:
      - docker-compose exec postgres psql -U postgres -d ferretdb

  mongosh:
    desc: "Run MongoDB shell (`mongosh`)"
    cmds:
      - >
        docker-compose exec mongodb mongosh mongodb://host.docker.internal:27017/test?heartbeatFrequencyMS=300000
        --verbose --eval 'disableTelemetry()' --shell

  mongo:
    desc: "Run legacy `mongo` shell"
    cmds:
      - >
        docker-compose exec mongodb mongo mongodb://host.docker.internal:27017/test?heartbeatFrequencyMS=300000
        --verbose

  docker-init:
    cmds:
      - docker buildx create --driver=docker-container --name=ferretdb

  docker-local:
    deps: [gen-version]
    cmds:
      - >
        docker buildx build --builder=ferretdb
        --build-arg VERSION={{.VERSION}}
        --build-arg COMMIT={{.COMMIT}}
        --tag=ferretdb-local
        --load .
    vars:
      VERSION:
        sh: cat internal/util/version/gen/version.txt
      COMMIT:
        sh: cat internal/util/version/gen/commit.txt

  docker-push:
    deps: [gen-version]
    cmds:
      - test {{.DOCKER_IMAGE}}
      - >
        docker buildx build --builder=ferretdb --platform=linux/arm64,linux/amd64
        --build-arg VERSION={{.VERSION}}
        --build-arg COMMIT={{.COMMIT}}
        --tag={{.DOCKER_IMAGE}}
        --push .
    vars:
      VERSION:
        sh: cat internal/util/version/gen/version.txt
      COMMIT:
        sh: cat internal/util/version/gen/commit.txt

  packages:
    cmds:
      - task: packages-deb
      - task: packages-rpm

  packages-deb:
    deps: [build-testcover]
    dir: build
    cmds:
      - ../bin/nfpm{{exeExt}} package --packager=deb --target=deb/ferretdb.deb
      - >
        docker-compose run --rm debian /bin/sh -c
        'dpkg -i /deb/ferretdb.deb && ferretdb -version'
    env:
      VERSION:
        sh: cat ../internal/util/version/gen/version.txt
      GOARCH:
        sh: go env GOARCH

  packages-rpm:
    deps: [build-testcover]
    dir: build
    cmds:
      - ../bin/nfpm{{exeExt}} package --packager=rpm --target=rpm/ferretdb.rpm
      - >
        docker-compose run --rm centos /bin/sh -c
        'rpm -i /rpm/ferretdb.rpm && ferretdb -version'
    env:
      VERSION:
        sh: cat ../internal/util/version/gen/version.txt
      GOARCH:
        sh: go env GOARCH