build.yml

default: "help"
expose: [
    "help",
    "info",
    "promote",
    "refresh",
    "compile",
    "lint",
    "test",
    "release",
    "test-int",
    # We don't expose this target to contributors, it is only used by GitHub Action "Release".
    # "publish",
    "docker",
    "docker-tag",
    "docker-push",
    # Doesn't work yet with CGO binaries
    # "license",
  ]
configuration: ["~/.dockerhub.yml", "~/.github.yml"] # DO NOT COMMIT THESE FILES
# ~/.dockerhub.yml should contains:
# DOCKERHUB_USER: <your dockerhub user>
# DOCKERHUB_PASS: <your dockerhub password or a dockerhub token>
# ~/.github.yml should contains:
# GITHUB_TOKEN: <your github token>

properties:
  # Build Configuration (edit this section to override default values)
  BY: "" # Leave empty to default to the user.email property in git configuration
  MODULE: "github.com/cgi-fr/lino" # Leave empty to default to the git remote url (e.g. "github.com/<usename>/<reponame>")
  PROJECT: "" # Leave empty to default to the git repository name (e.g. "<reponame>")
  LDFLAGS: "" # Add custom standard ldflags, will be applied everywhere everytime
  BUILD_DIR: "bin" # Subfolder where the build will output, should be ignored by .gitignore
  TEST_WS_DIR: "tests/workspace" # Workspace for integration tests
  DOCKERHUB_ORGANIZATION: "cgifr" # Image tag : cgi-fr/lino

  # Build parameters (use the -props flag or change these default values)
  tag: "" # Default to the current branch or tag, can be overriden
  latest: false # Do not tag the Docker image with latest, specify othewise with `-props "{latest: true}"`
  ldflags: "" # Specify a additional ldflags with `-props "{ldflags: '<flags>'}"`
  tags: [] # Specify additional tags with `-props "{tags: ['tag']}"`
  buildpaths: [] # By default, all paths under the cmd/ folder are built, specify a different folder list with `-props "{buildpaths: ["other/path", "to/build"]}"`
  testmod: "table" # Test only one venom module
  testfile: "*" # Test only one venom file
  # List of linters to run on the lint target, if left empty : run all linters
  linters: [
      # TODO: review these linters, and consider using more
      "misspell",
      "gocyclo",
      "gosec",
      "unparam",
      #"goimports",
      "nakedret",
      "gocritic",
      "whitespace",
    ]
  lintersno: ["forbidigo", "gci"] # List of linters to exclude on running the lint target

  # If true, do not upload release when publish target is used
  snapshot: false

  # List of Dockerfiles to build, defined by a map of {key=Dockerfile name ; value=path to build context}, the image name will be determined by the extension of the Dockerfile
  dockerfiles:
    Dockerfile: .
    Dockerfile.debian: .
    Dockerfile.oracle: .
    Dockerfile.db2: .

  # Path and name of the file generated by the license target.
  noticefile: "NOTICE.md"
  license: # License scanning parameters, see https://github.com/mitchellh/golicense#configuration-file for more info
    allow: [] # example: ["MIT", "Apache-2.0"]
    deny: [] # example: ["LGPL-2.1"]
    override: {} # example:  github.com/rs/zerolog: LGPL-2.1
    translate: {} # example: gopkg.in/foo/bar.v2: github.com/foo/bar

shell: ["zsh", "-c"]

targets:
  help:
    doc: "Print this message"
    steps:
      # - $: 'neon -info' => incorrect order, issue to open
      - $: |
          print -P "%BAvailable targets%b"
          print
          print -P "%B%F{blue}help%f%b         Print this message"
          print -P "%B%F{blue}info%f%b         Print build informations"
          print -P "%B%F{blue}promote%f%b      Promote the project with a new tag based on git log history"
          print -P "%B%F{blue}refresh%f%b      Refresh go modules (add missing and remove unused modules) [info]"
          print -P "%B%F{blue}compile%f%b      Compile binary files locally [info->refresh]"
          print -P "%B%F{blue}lint%f%b         Examine source code and report suspicious constructs [info->refresh]"
          print -P "%B%F{blue}test%f%b         Run all tests with coverage [info->refresh->lint]"
          print -P "%B%F{blue}release%f%b      Compile binary files for production [info->refresh->lint->test]"
          print -P "%B%F{blue}test-int%f%b     Run all integration tests [info->refresh->lint->test->release]"
          # print -P "%B%F{blue}publish%f%b      Publish tagged binary to Github [info->refresh->lint->test->release->test-int]"
          print -P "%B%F{blue}docker%f%b       Build docker images [info]"
          print -P "%B%F{blue}docker-tag%f%b   Tag docker images [info->docker]"
          print -P "%B%F{blue}docker-push%f%b  Publish docker images to Dockerhub [info->docker->docker-tag]"
          # print -P "%B%F{blue}license%f%b      Scan licenses from binaries and generate notice file [info->refresh->compile]"
          print
          print -P "%BExample:%b neon promote release"
          print
          print -P "%BTarget dependencies%b"
          print
          print -P "→ help"
          print -P "→ promote"
          print -P "→ info ┰ docker → docker-tag → docker-push"
          print -P "       ┖ refresh ┰ compile"
          print -P "                 ┖ lint → test → release → test-int"

  info:
    doc: "Print build informations"
    steps:
      - $: mkdir -p ={BUILD_DIR}
      - if: tag == ""
        then:
          - $: "git describe --tags --exact-match 2>/dev/null || git symbolic-ref -q --short HEAD"
            1=: "tag"
            3x: true
        else:
          - $: "echo -n ={tag}"
            1=: "tag"
            3x: true
      - $: 'echo -n "={tag}" | sed -e s/^v//'
        1=: "version"
        3x: true
      - $: "git rev-parse HEAD 2>/dev/null"
        1=: "commit"
        3x: true
      - "date = now()[0:10]"
      - if: BY == ""
        then:
          - $: "git config user.email"
            1=: "by"
            3x: true
        else:
          - $: "echo -n ={BY}"
            1=: "by"
            3x: true
      - $: 'if expr match "={version}" "v\?[0-9]\+\.[0-9]\+\.[0-9]\+" 1>/dev/null 2>&1; then echo -n "yes"; else echo -n "no"; fi'
        1=: "is_release"
        3x: true
      - $: "cut -f1 -d."
        <: "=version"
        1=: "version_major"
        3x: true
      - $: "cut -f2 -d."
        <: "=version"
        1=: "version_minor"
        3x: true
      - $: "cut -f3 -d."
        <: "=version"
        1=: "version_patch"
        3x: true
      - if: MODULE == ""
        then:
          - $: "git config --local remote.origin.url | sed -n 's#^.*//\\(.*\\)\\.git$#\\1#p' | tr '[:upper:]' '[:lower:]'" # .*//(.*)\.git => https://github.com/<user>/<repo>.git => github.com/<user>/<repo>
            1=: "mod"
            3x: true
        else:
          - $: "echo -n ={MODULE}"
            1=: "mod"
            3x: true
      - if: PROJECT == ""
        then:
          - $: "cut -f3 -d/"
            <: "=mod"
            1=: "project"
            3x: true
        else:
          - $: "echo -n ={PROJECT}"
            1=: "project"
            3x: true
      - print: |-
          MODULE  = ={mod}
          PROJECT = ={project}
          TAG     = ={tag}
          COMMIT  = ={commit}
          DATE    = ={date}
          BY      = ={by}
          RELEASE = ={is_release}
      - if: 'is_release == "yes"'
        then:
          - print: |-
              VERSION = ={version_major}.={version_minor}.={version_patch}

  promote:
    doc: "Promote the project with a new tag based on git log history"
    steps:
      - if: tag==""
        then:
          - $: svu next || echo -n v0.1.0
            3x: true
            1=: tag
      - $: "git tag ={tag}"
        2x: true
      - $: "echo Promoted to ={tag}"

  refresh:
    doc: "Refresh go modules (add missing and remove unused modules)"
    depends: "info"
    steps:
      # - $: "rm -f go.mod go.sum"
      # - $: "go mod init ={mod}"
      - $: "go mod tidy"

  # run "neon -props '{buildpaths: ["path/to/main/package1","path/to/main/package2"]}' compile" to compile specific targets
  # example : neon -props '{buildpaths: ["cmd/cli"]}' compile
  compile:
    doc: "Compile binary files locally"
    depends: ["info", "refresh"]
    steps:
      - ldflags = ldflags + " -X main.version=" + tag + " -X main.commit=" + commit + " -X main.buildDate=" + date + " -X main.builtBy=" + by
      - if: len(buildpaths) == 0
        then:
          - buildpaths = appendpath("cmd", find("cmd", "*"))
      - for: path
        in: buildpaths
        do:
          - print: Building ={path}
          - |
            pathcomponents = split(unixpath(path), "/")
            name = pathcomponents[len(pathcomponents)-1]
            alltags = join(tags,',')
          - $: go build -tags "={alltags}" -ldflags "-X main.name=={name} ={ldflags} ={LDFLAGS}" -o ./={BUILD_DIR}/={name} ./={path}

  lint:
    doc: "Examine source code and report suspicious constructs"
    depends: ["info", "refresh"]
    steps:
      - $: 'killall golangci-lint || :'
      - if: len(linters) == 0
        then:
          - $: golangci-lint run --enable-all ={replace(join(appendpath("--disable", lintersno), " "), "/", " ")}
            :: true
        else:
          - $: golangci-lint run ={replace(join(appendpath("--enable", linters), " "), "/", " ")} ={replace(join(appendpath("--disable", lintersno), " "), "/", " ")}
            :: true

  test:
    doc: "Run all tests with coverage"
    depends: ["info", "refresh", "lint"]
    steps:
      - $: go test -coverprofile=./={BUILD_DIR}/coverage.txt -covermode=atomic ./...

  # run "neon -props '{buildpaths: ["path/to/main/package1","path/to/main/package2"]}' release" to release specific targets
  # example : neon -props '{buildpaths: ["cmd/cli"]}' release
  release:
    doc: "Compile binary files for production"
    depends: ["info", "refresh", "lint", "test"]
    steps:
      - ldflags = ldflags + " -s -w" # Omit the DWARF symbol table. Omit the symbol table and debug information.
      - call: compile

  docker-clean:
    doc: "Clean docker container"
    steps:
      - $: |
          sudo docker compose -p lino stop source
          sudo docker compose -p lino stop dest
          sudo docker compose -p lino rm -f source
          sudo docker compose -p lino rm -f dest
          sudo docker compose -p lino up -d source dest
          sudo docker compose -p lino up -d --build lino
          mkdir -p ={TEST_WS_DIR}
          sudo chown vscode:vscode ={TEST_WS_DIR}
          sleep 60

  test-int:
    doc: "Run all integration tests"
    depends: ["info", "refresh", "lint", "test", "release", "docker-clean"]
    steps:
      - delete: venom*.log
      - delete: ={TEST_WS_DIR}/**
      - mkdir: =TEST_WS_DIR
      - copy: "**/*.yml"
        dir: "tests/suites"
        todir: =TEST_WS_DIR
      - $: export COMPOSE_PROJECT_NAME=lino; venom run --stop-on-failure ={TEST_WS_DIR}/*/*.yml

  # run "neon -props '{testmod: table, testfile: config}' test-int-dev
  test-int-dev:
    doc: "Run all integration tests"
    # depends: ["info", "refresh", "lint", "test"]
    depends: ["compile", "docker-clean"]
    steps:
      - delete: ={TEST_WS_DIR}/**
      - mkdir: ={TEST_WS_DIR}/={testmod}/
      - copy: ={testfile}.yml
        dir: "tests/suites/={testmod}/"
        todir: ={TEST_WS_DIR}/={testmod}
      - $: export COMPOSE_PROJECT_NAME=lino; venom run  ={TEST_WS_DIR}/={testmod}/={testfile}.yml

  # run "neon -props '{buildpaths: ["path/to/main/package1","path/to/main/package2"]}' publish" to publish specific targets
  # example : neon -props '{buildpaths: ["cmd/cli"]}' publish
  publish:
    doc: "Publish tagged binaries to Github"
    depends: ["info", "refresh", "lint", "test", "release", "test-int"]
    steps:
      # - $: git clean -f -d
      - if: len(buildpaths) == 0
        then:
          - buildpaths = ['cmd/lino']
      - print: 'Publishing build paths ={buildpaths}'
      - ldflags = ldflags + " -s -w" # Omit the DWARF symbol table. Omit the symbol table and debug information.
      - ldflags = ldflags + " -X main.version=" + tag + " -X main.commit=" + commit + " -X main.buildDate=" + date + " -X main.builtBy=" + by
      - $: (export LDFLAGS="={ldflags}"; export BUILDPATHS="={buildpaths}"; cat .goreleaser.template.yml | gomplate)
        1>: ={BUILD_DIR}/.goreleaser.yml
        1x: true
      - if: snapshot
        then:
          - $: goreleaser release -f ={BUILD_DIR}/.goreleaser.yml --clean --snapshot
        else:
          - $: (export GITHUB_TOKEN=={GITHUB_TOKEN}; goreleaser release -f ={BUILD_DIR}/.goreleaser.yml --clean)
      - $: go mod tidy

  # run "neon -props '{dockerfiles: {"path/to/Dockerfile1": "path/to/root/build/context"}}' docker" to build specific Dockerfiles
  # example : neon -props '{dockerfiles: {"Dockerfile": "."}}' docker
  docker:
    doc: "Build docker images"
    depends: ["info"]
    steps:
      - try:
          - $: "# ={DOCKERHUB_ORGANIZATION}"
            3x: true
        catch:
          - print: |
              To use this target, make sure your DOCKERHUB_ORGANIZATION is set.
          - $: return 1
      - $: "date -u +'%Y-%m-%dT%H:%M:%SZ'"
        1=: "daterfc3339"
        3x: true
      - |
        build_args  = " --build-arg BUILD_DATE=" + daterfc3339
        build_args += " --build-arg VERSION=" + version
        build_args += " --build-arg REVISION=" + commit
      - for: key
        in: keys(dockerfiles)
        do:
          - |
            keycomponents = split(key, ".")
            suffix = ""
            if len(keycomponents) > 1 {
              suffix = "-" + keycomponents[len(keycomponents)-1]
            }
          - $: "sudo docker build -q --iidfile ={BUILD_DIR}/last-={key} -t ={DOCKERHUB_ORGANIZATION}/={project}:={tag}={suffix} -f ={key} ={dockerfiles[key]}"
            1x: true
          - $: "sudo docker images --no-trunc | grep $(cat ={BUILD_DIR}/last-={key})"

  # run "neon -props '{latest: true}' docker-tag" to include latest tag
  docker-tag:
    doc: "Tag docker images"
    # unless: 'is_release != "yes"' => is_release unknown variable, issue to open
    depends: ["info", "docker"]
    steps:
      - if: 'is_release == "yes"'
        then:
          - try:
              - $: "# ={DOCKERHUB_ORGANIZATION}"
                3x: true
            catch:
              - print: |
                  To use this target, make sure your DOCKERHUB_ORGANIZATION is set.
              - $: return 1
          - for: key
            in: keys(dockerfiles)
            do:
              - |
                keycomponents = split(key, ".")
                suffix = ""
                if len(keycomponents) > 1 {
                  suffix = "-" + keycomponents[len(keycomponents)-1]
                }
              - $: "sudo docker tag ={DOCKERHUB_ORGANIZATION}/={project}:={tag}={suffix} ={DOCKERHUB_ORGANIZATION}/={project}:v={version_major}={suffix}"
              - $: "sudo docker tag ={DOCKERHUB_ORGANIZATION}/={project}:={tag}={suffix} ={DOCKERHUB_ORGANIZATION}/={project}:v={version_major}.={version_minor}={suffix}"
              - if: "latest"
                then:
                  - $: "sudo docker tag ={DOCKERHUB_ORGANIZATION}/={project}:={tag}={suffix} ={DOCKERHUB_ORGANIZATION}/={project}:latest={suffix}"
              - $: "sudo docker images --no-trunc | grep $(cat ={BUILD_DIR}/last-={key})"
        else:
          - print: "Skipping release target (not a release)"
            color: red

  docker-login:
    steps:
      - try:
          - $: "sudo docker login -u ={DOCKERHUB_USER} -p ={DOCKERHUB_PASS}"
            2x: true
        catch:
          - print: |
              To use this target, make sure your credentials are valid in the file ~/.dockerhub.yml
              The content of the file should be :
                DOCKERHUB_USER: <your dockerhub user>
                DOCKERHUB_PASS: <your dockerhub password or a dockerhub token>
          - $: return 1

  # run "neon -props '{latest: true}' docker-push" to include latest tag
  docker-push:
    doc: "Push docker images to Dockerhub"
    # unless: 'is_release != "yes"' => is_release unknown variable, issue to open
    depends: ["docker", "docker-tag", "docker-login"]
    steps:
      - if: 'is_release == "yes"'
        then:
          - for: key
            in: keys(dockerfiles)
            do:
              - |
                keycomponents = split(key, ".")
                suffix = ""
                if len(keycomponents) > 1 {
                  suffix = "-" + keycomponents[len(keycomponents)-1]
                }
              - $: "sudo docker push ={DOCKERHUB_ORGANIZATION}/={project}:v={version_major}={suffix}"
              - $: "sudo docker push ={DOCKERHUB_ORGANIZATION}/={project}:v={version_major}.={version_minor}={suffix}"
              - $: "sudo docker push ={DOCKERHUB_ORGANIZATION}/={project}:v={version_major}.={version_minor}.={version_patch}={suffix}"
              - if: "latest"
                then:
                  - $: "sudo docker push ={DOCKERHUB_ORGANIZATION}/={project}:latest={suffix}"
        else:
          - print: "Skipping release target (not a release)"
            color: red

  license:
    doc: "Scan licenses from binaries and generate notice file"
    depends: ["info", "refresh", "compile"]
    steps:
      - $: echo -e "# 3rd-Party Software Licenses\n" > ={noticefile}
      - $: echo "The following 3rd-party software components may be used by or distributed with this project. Any information relevant to third-party vendors listed below are collected using common, reasonable means." >> ={noticefile}
      - try:
          - $: echo -n "={GITHUB_TOKEN}"
            1=: token
            3x: true
        catch:
          - print: |
              This target works better if a valid GITHUB_TOKEN is defined in the file ~/.github.yml (without it you might reach the maximum call/hour limit of the GitHub API)
              The content of the file should be :
                GITHUB_TOKEN: <your github token>
          - token=""
      - write: ={BUILD_DIR}/license.json
        text: ={jsonencode(license)}
      - for: path
        in: buildpaths
        do:
          - |
            pathcomponents = split(unixpath(path), "/")
            name = pathcomponents[len(pathcomponents)-1]
          - print: Scanning ={name}
          - $: |
              echo -e "\n## ={name}\n" >> ={noticefile}
              set -o pipefail errexit
              (export GITHUB_TOKEN=={token}; golicense -plain ={BUILD_DIR}/license.json ={BUILD_DIR}/={name} | awk '{ printf "{\"module\":\"%s\"", $1; $1=""; gsub("\"","\\\"",$0); printf ",\"license\":\"%s\"}\n", substr($0,2) }' | mlr --ijson --omd sort -f module then cat >> ={noticefile})