Taskfile.yml

# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

version: 3

vars:
  RELEASE_FROM_DIR: '{{ if regexMatch "v[0-9][^/]+$" (base .TASKFILE_DIR) }}{{ regexFind "v[0-9][^/]+$" (base .TASKFILE_DIR) }}{{ else }}snapshot{{ end }}'
  RELEASE:
    sh: |
        if test -e .git
        then git -C olaris-op rev-parse --short HEAD
        else
          if test -e RELEASE
          then cat RELEASE
          else echo {{.RELEASE_FROM_DIR}} | tee RELEASE
          fi
        fi

  OPERATOR_TAG: "{{.RELEASE}}"

  OPERATOR_IMG:
    sh: awk -F= '/ARG OPERATOR_IMAGE_DEFAULT=/ { print $2 ; exit }' olaris-op/Dockerfile
  OPERATOR_SRC: "{{.OPERATOR_IMG}}:{{.OPERATOR_TAG}}"

  STREAMER_TAG: "{{.OPERATOR_TAG}}"
  STREAMER_SRC: "docker.io/apache/openserverless-streamer:{{.STREAMER_TAG}}"

  ADMIN_API_TAG: "{{.OPERATOR_TAG}}"
  ADMIN_API_SRC: "docker.io/apache/openserverless-admin-api:{{.ADMIN_API_TAG}}"

  RUNTIMES_TAG: "{{.OPERATOR_TAG}}"

  OPENSERVERLESS_TAG: "{{.OPERATOR_TAG}}"
  CONTROLLER_SRC: "docker.io/apache/openserverless-wsk-controller:{{.OPENSERVERLESS_TAG}}"
  INVOKER_SRC: "docker.io/apache/openserverless-wsk-invoker:{{.OPENSERVERLESS_TAG}}"

  OPS_BRANCH: "{{.OPERATOR_TAG}}"

  CMD: "check"

tasks:

    default:
      -  task -l
      - echo release '{{.RELEASE}}'

    clean:
      desc: clean the intermediate artifacts
      cmds:
      - rm -vf ./ops ~/.ops/{{OS}}-{{ARCH}}/images/kind/*
      - rm -vf ./ops

    image-save:
      desc: save an a SRC image in the TGT file
      requires: { vars: [SRC]}
      env:
        TGT:
          sh: |
              B64="$(echo -n {{.SRC}} | /usr/bin/base64 -w0)"
              echo ~/.ops/{{OS}}-{{ARCH}}/images/kind/$B64
      cmds:
      - echo Saving {{.SRC}} in "$TGT"
      - mkdir -p  "$(dirname $TGT)"
      - docker save {{.SRC}} -o  "$TGT"
      status:
      - ! test -e "$TGT"

    cli:
      desc: build the cli
      dir: cli
      cmds:
      - go build -o ../ops cmd/ops/main.go
      status:
      - ! test -e ../ops


    operator:
      desc: build the operator
      deps:
      - cli
      dir: olaris-op
      cmds:
      - echo Building {{.OPERATOR_SRC}}
      - git tag -d $(git tag) && git tag {{.OPERATOR_TAG}}
      - task b:build
      - task: image-save
        vars:
          SRC: "{{.OPERATOR_SRC}}"

    streamer:
      desc: build the streamer
      deps:
      - cli
      dir: streamer
      cmds:
      - echo Building {{.STREAMER_SRC}}
      - git tag -d $(git tag) && git tag {{.STREAMER_TAG}}
      - echo -e "NAMESPACE=apache\nREGISTRY=dockerhub\n" >.env
      - task buildx
      - task: image-save
        vars:
          SRC: "{{.STREAMER_SRC}}"

    admin-api:
      desc: build the admin-api
      deps:
      - cli
      dir: admin-api
      cmds:
      - echo Building {{.ADMIN_API_SRC}}
      - git tag -d $(git tag) && git tag {{.STREAMER_TAG}}
      - echo -e "NAMESPACE=apache\nREGISTRY=dockerhub\n" >.env
      - task buildx
      - task: image-save
        vars:
          SRC: "{{.ADMIN_API_SRC}}"

    openwhisk:
      desc: build openwhisk
      dir: build
      env:
        PATH: "{{.TASKFILE_DIR}}:$PATH"
        OPS_ROOT: "{{.TASKFILE_DIR}}"
      cmds:
      - echo Building  OpenServerless
      - git tag -d $(git tag) && git tag {{.OPENSERVERLESS_TAG}}
      - |
        export PATH="{{.TASKFILE_DIR}}:$PATH"
        export OPS_ROOT="{{.TASKFILE_DIR}}/olaris"
        task build-all
      - task: image-save
        vars:
          SRC: "{{.CONTROLLER_SRC}}"
      - task: image-save
        vars:
          SRC: "{{.INVOKER_SRC}}"

    runtimes:
      desc: build current runtimes.json
      dir: runtimes
      cmds:
      - git tag -d $(git tag) && git tag {{.RUNTIMES_TAG}}
      - task build-common
      - task build
      - task render-runtimes
      - cp runtimes.json ../olaris/runtimes.json
      - task: runtimes-save

    runtimes-save:
      desc: save runtimes images
      dir: runtimes
      vars:
        IMAGES:
          sh: jq -r '.runtimes[][] | select(.default == true) | "\(.image.prefix)/\(.image.name):\(.image.tag)"'   runtimes.json | grep -v php
      cmds:
      - for: { var: IMAGES, split: "\n", as: IMG }
        task: image-save
        vars:
          SRC: "docker.io/{{.IMG}}"
          TGT:
            sh: echo ~/.ops/{{OS}}-{{ARCH}}/images/kind/$(echo docker.io/{{.IMG}} | /usr/bin/base64 -w0)

    opsroot:
      desc: build current opsroot.json
      dir: olaris
      cmds:
      - test -e opsroot.orig || jq . <opsroot.json >opsroot.orig
      - >
        jq <opsroot.orig >opsroot.json  '
          .config.images.operator   = "{{.OPERATOR_SRC}}"   |
          .config.images.streamer   = "{{.STREAMER_SRC}}"   |
          .config.images.systemapi  = "{{.ADMIN_API_SRC}}"  |
          .config.images.controller = "{{.CONTROLLER_SRC}}" |
          .config.images.invoker    = "{{.INVOKER_SRC}}"
        '
      - diff opsroot.orig opsroot.json || true

    opslink:
      desc: link ops
      cmds:
      - task: cli
      - mkdir -p ~/.local/bin ~/.ops/{{.OPS_BRANCH}}
      - ln -sf $(pwd)/ops ~/.local/bin/ops
      - test -d ~/.ops/{{.OPS_BRANCH}}/olaris || ln -sf $(pwd)/olaris ~/.ops/{{.OPS_BRANCH}}/olaris
      - touch ~/.profile
      - |
        if ! grep -q OPS_BRANCH= ~/.profile
        then echo export OPS_BRANCH={{.OPS_BRANCH}} >>~/.profile
        fi
      - |
        if ! grep -q 'PATH=~/.local/bin' ~/.profile
        then echo 'export PATH=~/.local/bin:"$PATH"' >>~/.profile
        fi


    gitinit:
      desc: initialize git if missing
      cmds:
      - |
        for i in build cli olaris-op runtimes streamer admin-api
        do
          cd "$i"
          if ! test -e .git
          then git init 2>/dev/null
              git commit -m "init" --allow-empty
          fi
          cd ..
        done

    build:
      desc: build all
      cmds:
      - task: gitinit
      - task: opslink
      - task: openwhisk
      - task: operator
      - task: runtimes
      - task: streamer
      - task: admin-api
      - task: opsroot

    test:
      desc: create
      dir: testing/tests
      cmds:
        - |
          export PATH="{{.TASKFILE_DIR}}:$PATH"
          export OPS_ROOT="{{.TASKFILE_DIR}}/olaris"
          export OPS_BRANCH="{{.OPS_BRANCH}}"
          which ops
          ops -info
          ops setup docker delete || true
          touch .secrets
          ./all.sh kind

    license:
      silent: true
      desc: check license headers
      cmds:
      - |
        license-eye header {{.CMD}}
        for i in */.licenserc.yaml
        do
            DIR="$(dirname $i)"
            echo "*** Checking license headers in $DIR"
            cd $DIR
            license-eye header {{.CMD}}
            cd {{.TASKFILE_DIR}}
        done

    release:
      desc: release
      requires:
        vars: [ V ]
      cmds:
      - git tag "v{{.V}}"
      - echo "v{{.V}}" >RELEASE
      - >
          {{if eq OS "darwin"}}gtar{{else}}tar{{end}}
          -C .. --exclude='.git'
          --transform 's,^openserverless,openserverless-v{{.V}},'
          -czvf ../openserverless-v{{.V}}-incubating-src.tar.gz
          openserverless
      - git push --tags