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'

dotenv:
  - .env

vars:
  BASETAG: 2.0.0-incubating
  TAG:
    sh: |
      if test -n "${TAG:-}"; then
        echo "$TAG"
      else
        git describe --tags --abbrev=0 2>/dev/null || git rev-parse --short HEAD
      fi
  GHUSER:
    sh: echo "${GITHUB_USER:-apache}"
  BUN:
    sh: |
      if command -v bun >/dev/null 2>&1; then
        command -v bun
        exit 0
      fi
      os="$(uname -s | tr A-Z a-z)"
      arch="$(uname -m)"
      case "$arch" in
        x86_64) arch=amd64 ;;
        aarch64|arm64) arch=arm64 ;;
      esac
      if test -x "$HOME/.ops/${os}-${arch}/bin/bun"; then
        echo "$HOME/.ops/${os}-${arch}/bin/bun"
      else
        echo bun
      fi
  OPSROOT_JSON:
    sh: echo "$HOME/.ops/0.1.0/olaris/opsroot.json"
  KIND_NODE: nuvolaris-control-plane
  KUBE_NAMESPACE: nuvolaris
  DOCKER_REGISTRY: docker.io/apache
  LOCAL_DOCKER_REGISTRY:
    sh: echo "${LOCAL_DOCKER_REGISTRY:-localhost:5000/apache}"
  LOCAL_REGISTRY_CONTAINER:
    sh: echo "${LOCAL_REGISTRY_CONTAINER:-openserverless-registry}"
  BUILDX_BUILDER: openserverless-buildx
  DIST_DOCKER_REGISTRY: ""
  DIST_DOCKER_REGISTRY_ARG:
    sh: |
      if test -n "{{.DIST_DOCKER_REGISTRY}}"; then
        echo "-PdockerRegistry={{.DIST_DOCKER_REGISTRY}}"
      fi
  CONTROLLER_IMAGE: openserverless-wsk-controller
  INVOKER_IMAGE: openserverless-wsk-invoker
  SCHEDULER_IMAGE: openserverless-wsk-scheduler
  STANDALONE_IMAGE: openserverless-wsk-standalone
  COMMON_IMAGE: openserverless-wsk-scala
  ACT: "nothing"
  S: ""

tasks:

  default:
    - task --list-all

  setup:
    silent: true

  ensure-openwhisk:
    silent: true
    cmds:
      - |
        if ! test -d openwhisk/common/scala; then
          echo "ERROR: openwhisk directory is missing or incomplete."
          echo "This branch vendors openwhisk as a regular directory, not as a submodule."
          echo "Refresh the build checkout and make sure the build-local branch includes openwhisk/common/scala."
          exit 1
        fi

  image-tag:
    - git tag -d $(git tag)
    - git tag -f {{.BASETAG}}.$(date +%y%m%d%H%M){{.S}}
    - task show

  show:
    silent: true
    cmds:
      - echo "tag:" {{.TAG}}
      - echo "scala:" {{.COMMON_IMAGE}}:{{.TAG}}
      - echo "controller:" ${MY_CONTROLLER_IMAGE:-{{.CONTROLLER_IMAGE}}}:{{.TAG}}
      - echo "invoker:" ${MY_INVOKER_IMAGE:-{{.INVOKER_IMAGE}}}:{{.TAG}}
      - echo "scheduler:" ${MY_SCHEDULER_IMAGE:-{{.INVOKER_IMAGE}}}:{{.TAG}}
      - echo "standalone:" ${MY_STANDALONE_IMAGE:-{{.STANDALONE_IMAGE}}}:{{.TAG}}

  compile:controller:
    dir: openwhisk
    cmds:
      - ./gradlew  :core:controller:distTar
    status:
      - test -f core/controller/build/distributions/controller.tar

  compile:invoker:
    dir: openwhisk
    cmds:
      - ./gradlew  :core:invoker:distTar
    status:
      - test -f core/invoker/build/distributions/invoker.tar

  compile:scheduler:
    dir: openwhisk
    cmds:
      - ./gradlew  :core:scheduler:distTar
    status:
      - test -f core/scheduler/build/distributions/scheduler.tar

  compile:standalone:
    dir: openwhisk
    cmds:
      - ./gradlew :core:standalone:build
      - mkdir -p ../standalone/lib
      - cp bin/openwhisk-standalone.jar ../standalone/lib/
    status:
      - test -f ../standalone/lib/openwhisk-standalone.jar

  native:standalone-libs:
    deps:
    - compile:standalone
    dir: openwhisk
    cmds:
      - ./gradlew core:standalone:copyRuntimeLibs

  native:standalone-build:
    deps:
    - native:standalone-libs
    dir: openwhisk/core/standalone
    cmds:
    - native-image
      --initialize-at-run-time=io.netty,akka.protobufv3.internal.UnsafeUtil
      --no-fallback --report-unsupported-elements-at-runtime
      --trace-object-instantiation=ch.qos.logback.classic.Logger
      --enable-url-protocols=http,https
      -march=native
      -cp build/classes/scala/main:build/resources/main:build/dependency-libs/*
      -H:ConfigurationFileDirectories=$PWD/../../../standalone/graal-config
      -o $PWD/../../../standalone/dist/{{.EXEC_NAME}}
      org.apache.openwhisk.standalone.StandaloneOpenWhisk
    vars:
      EXEC_NAME: "${NATIVE_IMAGE_NAME:-openwhisk-standalone}"

  native:standalone-run:
    dir: standalone/dist
    cmds:
    - ./openwhisk-standalone -Xmx2g -Dwhisk.standalone.host.name="0.0.0.0" -Dwhisk.standalone.host.internal="$(hostname -f)" -Dkamon.auto-start=no --no-browser
    env:
      KAMON_ENABLED: false

  native:standalone-config:
    deps:
    - compile:standalone
    dir: openwhisk/core/standalone
    cmds:
    - java -agentlib:native-image-agent=config-output-dir=../../../standalone/graal-config
      -cp build/classes/scala/main:build/resources/main:build/dependency-libs/*
      -Dwhisk.standalone.host.name="0.0.0.0"
      -Dwhisk.standalone.host.internal="$(hostname -f)"
      org.apache.openwhisk.standalone.StandaloneOpenWhisk

  clean:
    ignore_error: true
    cmds:
    - rm standalone/lib/openwhisk-standalone.jar
    - rm openwhisk/core/invoker/build/distributions/invoker.tar
    - rm openwhisk/core/controller/build/distributions/controller.tar
    - rm openwhisk/core/scheduler/build/distributions/scheduler.tar
    - docker buildx rm {{.BUILDX_BUILDER}}

  compile:
    - task: compile:controller
    - task: compile:invoker
    - task: compile:scheduler
    - task: compile:standalone

  docker-setup:
    - docker run --rm --privileged tonistiigi/binfmt --install all
    - docker buildx inspect {{.BUILDX_BUILDER}} >/dev/null 2>&1 || docker buildx create --name {{.BUILDX_BUILDER}} --driver docker-container --driver-opt network=host
    - docker buildx use {{.BUILDX_BUILDER}}
    - docker buildx inspect --bootstrap

  docker-local-registry:
    silent: true
    cmds:
    - |
      if docker container inspect {{.LOCAL_REGISTRY_CONTAINER}} >/dev/null 2>&1; then
        docker start {{.LOCAL_REGISTRY_CONTAINER}} >/dev/null
      else
        docker run -d --restart=always -p 5000:5000 --name {{.LOCAL_REGISTRY_CONTAINER}} registry:2 >/dev/null
      fi

  docker-login: >
    echo $GITHUB_TOKEN | docker login ghcr.io -u $GITHUB_USER --password-stdin

  # this requires ACT IMG and DIR parameters to be passed
  docker-build:
    silent: true
    cmds:
    - |-
      echo "***" {{.ACT}} for {{.IMG}} in {{.DIR}}
      case "{{.ACT}}" in
      (build)
      docker build {{.DIR}} -t {{.IMG}} --build-arg BASE={{.BASE}}
      ;;
      (buildx)
      docker buildx build --platform linux/amd64,linux/arm64 --build-arg BASE={{.BASE}} -t {{.IMG}} {{.DIR}}
      ;;
      (buildx-local)
      docker buildx build --platform linux/amd64,linux/arm64 --build-arg BASE={{.BASE}} -t {{.IMG}} {{.DIR}} --push
      ;;
      (buildx-push)
      docker buildx build --platform linux/amd64,linux/arm64 --build-arg BASE={{.BASE}} -t {{.IMG}} {{.DIR}} --push
      ;;
      (*) echo ACT must be "build|buildx|buildx-local|buildx-push"
      esac

  # this requires ACT IMG OPENWHISK_JAR and DIR parameters to be passed
  docker-build-standalone:
    silent: true
    cmds:
    - |-
      echo "***" {{.ACT}} for {{.IMG}} in {{.DIR}}
      case "{{.ACT}}" in
      (build)
      docker build {{.DIR}} -t {{.IMG}} --build-arg BASE={{.BASE}} --build-arg OPENWHISK_JAR={{.OPENWHISK_JAR}}
      ;;
      (buildx)
      docker buildx build --platform linux/amd64,linux/arm64 --build-arg BASE={{.BASE}} --build-arg OPENWHISK_JAR={{.OPENWHISK_JAR}} -t {{.IMG}} {{.DIR}}
      ;;
      (buildx-local)
      docker buildx build --platform linux/amd64,linux/arm64 --build-arg BASE={{.BASE}} --build-arg OPENWHISK_JAR={{.OPENWHISK_JAR}} -t {{.IMG}} {{.DIR}} --push
      ;;
      (buildx-push)
      docker buildx build --platform linux/amd64,linux/arm64 --build-arg BASE={{.BASE}} --build-arg OPENWHISK_JAR={{.OPENWHISK_JAR}} -t {{.IMG}} {{.DIR}} --push
      ;;
      (*) echo ACT must be "build|buildx|buildx-local|buildx-push"
      esac

  build:scala:
    cmds:
      - task: docker-build
        vars:
          DIR: openwhisk/common/scala
          IMG: "{{.DOCKER_REGISTRY}}/{{.COMMON_IMAGE}}:{{.TAG}}"
          ACT: '{{.ACT}}'

  build:controller:
    deps:
    - compile:controller
    cmds:
      - task: docker-build
        vars:
          DIR: openwhisk/core/controller
          IMG: "{{.DOCKER_REGISTRY}}/${MY_CONTROLLER_IMAGE:-{{.CONTROLLER_IMAGE}}}:{{.TAG}}"
          ACT: '{{.ACT}}'
          BASE: "{{.DOCKER_REGISTRY}}/{{.COMMON_IMAGE}}:{{.TAG}}"

  build:invoker:
    deps:
    - compile:invoker
    cmds:
      - task: docker-build
        vars:
          DIR: openwhisk/core/invoker
          IMG: "{{.DOCKER_REGISTRY}}/${MY_INVOKER_IMAGE:-{{.INVOKER_IMAGE}}}:{{.TAG}}"
          ACT: '{{.ACT}}'
          BASE: "{{.DOCKER_REGISTRY}}/{{.COMMON_IMAGE}}:{{.TAG}}"

  build:scheduler:
    deps:
    - compile:scheduler
    cmds:
      - task: docker-build
        vars:
          DIR: openwhisk/core/scheduler
          IMG: "{{.DOCKER_REGISTRY}}/${MY_SCHEDULER_IMAGE:-{{.SCHEDULER_IMAGE}}}:{{.TAG}}"
          ACT: '{{.ACT}}'
          BASE: "{{.DOCKER_REGISTRY}}/{{.COMMON_IMAGE}}:{{.TAG}}"

  build:standalone:
    deps:
    - compile:standalone
    cmds:
      - task: docker-build-standalone
        vars:
          DIR: openwhisk/core/standalone
          IMG: "{{.DOCKER_REGISTRY}}/${MY_STANDALONE_IMAGE:-{{.STANDALONE_IMAGE}}}:{{.TAG}}"
          ACT: '{{.ACT}}'
          BASE: "{{.DOCKER_REGISTRY}}/{{.COMMON_IMAGE}}:{{.TAG}}"
          OPENWHISK_JAR: "build/libs/openwhisk-standalone-1.0.0-SNAPSHOT.jar"

  build-all:
    cmds:
    - |
      if test "${OPENWHISK_BUILDCONTAINER:-}" = "1"; then
        task build-all:local
      else
        printf '%s\n' 'mkdir -p /tmp/openserverless-docker-config && printf "{}\n" >/tmp/openserverless-docker-config/config.json && OPENWHISK_BUILDCONTAINER=1 DOCKER_CONFIG=/tmp/openserverless-docker-config TAG="{{.TAG}}" task build-all:local' | ops ide devcontainer
      fi

  build-all:local:
    cmds:
    - task: ensure-openwhisk
    - task: build:scala
      vars:
         ACT: "build"
    - task: build:controller
      vars:
         ACT: "build"
    - task: build:invoker
      vars:
         ACT: "build"
    - task: build:scheduler
      vars:
         ACT: "build"
    - task: build:standalone
      vars:
         ACT: "build"

  buildx-all:
    desc: build multi-arch OpenWhisk images into a local registry without pushing to DockerHub
    cmds:
    - |
      if test "${OPENWHISK_BUILDCONTAINER:-}" = "1"; then
        task buildx-all:local
      else
        if docker ps | grep vsc-build
        then docker rm -f $(docker ps | awk '/vsc-build/{print $1}')
        fi
        printf '%s\n' 'mkdir -p /tmp/openserverless-docker-config && printf "{}\n" >/tmp/openserverless-docker-config/config.json && OPENWHISK_BUILDCONTAINER=1 DOCKER_CONFIG=/tmp/openserverless-docker-config TAG="{{.TAG}}" task buildx-all:local' | ops ide devcontainer
      fi

  buildx-all:local:
    cmds:
    - task: docker-setup
    - task: docker-local-registry
    - task: ensure-openwhisk
    - task: build:scala
      vars:
         ACT: "buildx-local"
         DOCKER_REGISTRY: "{{.LOCAL_DOCKER_REGISTRY}}"
    - task: build:controller
      vars:
         ACT: "buildx-local"
         DOCKER_REGISTRY: "{{.LOCAL_DOCKER_REGISTRY}}"
    - task: build:invoker
      vars:
         ACT: "buildx-local"
         DOCKER_REGISTRY: "{{.LOCAL_DOCKER_REGISTRY}}"
    - task: build:scheduler
      vars:
         ACT: "buildx-local"
         DOCKER_REGISTRY: "{{.LOCAL_DOCKER_REGISTRY}}"
    - task: build:standalone
      vars:
         ACT: "buildx-local"
         DOCKER_REGISTRY: "{{.LOCAL_DOCKER_REGISTRY}}"

  build:
    desc: build local OpenWhisk images, update OPS root, load kind, and roll out controller
    cmds:
    - task: deploy-kind-local

  deploy-kind-local:
    desc: build local OpenWhisk images, update OPS root, load kind, and roll out controller
    deps:
    - build-all
    cmds:
    - task: kind:deploy

  opsroot:update:
    desc: update installed OPS root with local OpenWhisk image tags
    silent: true
    cmds:
    - "{{.BUN}} scripts/kind-local.ts update-opsroot"
    env:
      TAG: "{{.TAG}}"
      DOCKER_REGISTRY: "{{.DOCKER_REGISTRY}}"
      CONTROLLER_IMAGE: "{{.CONTROLLER_IMAGE}}"
      INVOKER_IMAGE: "{{.INVOKER_IMAGE}}"
      STANDALONE_IMAGE: "{{.STANDALONE_IMAGE}}"
      OPSROOT_JSON: "{{.OPSROOT_JSON}}"

  kind:load:
    desc: load local OpenWhisk images into the kind node
    silent: true
    cmds:
    - "{{.BUN}} scripts/kind-local.ts load-kind"
    env:
      TAG: "{{.TAG}}"
      DOCKER_REGISTRY: "{{.DOCKER_REGISTRY}}"
      CONTROLLER_IMAGE: "{{.CONTROLLER_IMAGE}}"
      INVOKER_IMAGE: "{{.INVOKER_IMAGE}}"
      STANDALONE_IMAGE: "{{.STANDALONE_IMAGE}}"
      KIND_NODE: "{{.KIND_NODE}}"

  kind:rollout:
    desc: update local kind OpenWhisk workloads to the local images
    silent: true
    cmds:
    - "{{.BUN}} scripts/kind-local.ts rollout"
    env:
      TAG: "{{.TAG}}"
      DOCKER_REGISTRY: "{{.DOCKER_REGISTRY}}"
      CONTROLLER_IMAGE: "{{.CONTROLLER_IMAGE}}"
      INVOKER_IMAGE: "{{.INVOKER_IMAGE}}"
      STANDALONE_IMAGE: "{{.STANDALONE_IMAGE}}"
      KUBE_NAMESPACE: "{{.KUBE_NAMESPACE}}"

  kind:status:
    desc: show local image, kind image, and pod image status
    silent: true
    cmds:
    - "{{.BUN}} scripts/kind-local.ts status"
    env:
      TAG: "{{.TAG}}"
      DOCKER_REGISTRY: "{{.DOCKER_REGISTRY}}"
      CONTROLLER_IMAGE: "{{.CONTROLLER_IMAGE}}"
      INVOKER_IMAGE: "{{.INVOKER_IMAGE}}"
      STANDALONE_IMAGE: "{{.STANDALONE_IMAGE}}"
      KIND_NODE: "{{.KIND_NODE}}"
      KUBE_NAMESPACE: "{{.KUBE_NAMESPACE}}"

  kind:deploy:
    desc: update OPS root, load local images into kind, and roll out OpenWhisk
    silent: true
    cmds:
    - "{{.BUN}} scripts/kind-local.ts deploy-kind"
    env:
      TAG: "{{.TAG}}"
      DOCKER_REGISTRY: "{{.DOCKER_REGISTRY}}"
      CONTROLLER_IMAGE: "{{.CONTROLLER_IMAGE}}"
      INVOKER_IMAGE: "{{.INVOKER_IMAGE}}"
      STANDALONE_IMAGE: "{{.STANDALONE_IMAGE}}"
      OPSROOT_JSON: "{{.OPSROOT_JSON}}"
      KIND_NODE: "{{.KIND_NODE}}"
      KUBE_NAMESPACE: "{{.KUBE_NAMESPACE}}"

  buildx-and-push:
    - task: docker-setup
    - task: build:scala
      vars:
         ACT: "buildx-push"
    - task: build:controller
      vars:
         ACT: "buildx-push"
    - task: build:invoker
      vars:
         ACT: "buildx-push"
    - task: build:scheduler
      vars:
         ACT: "buildx-push"
    - task: build:standalone
      vars:
         ACT: "buildx-push"

  distdocker:
    cmds:
    - |
      if test "${OPENWHISK_BUILDCONTAINER:-}" = "1"; then
        task distdocker:local
      else
        printf '%s\n' 'mkdir -p /tmp/openserverless-docker-config && printf "{}\n" >/tmp/openserverless-docker-config/config.json && OPENWHISK_BUILDCONTAINER=1 DOCKER_CONFIG=/tmp/openserverless-docker-config TAG="{{.TAG}}" task distdocker:local' | ops ide devcontainer
      fi

  distdocker:local:
    deps:
    - ensure-openwhisk
    dir: openwhisk
    cmds:
    - ./gradlew distDocker -PdockerMultiArchBuild=true {{.DIST_DOCKER_REGISTRY_ARG}} -PdockerImagePrefix=openwhisk2 -PdockerImageTag={{.TAG}}

  run:standalone-docker:
    cmds:
      - >
       docker run -ti
       -p 3232:3232 -p 3233:3233
       -v /var/run/docker.sock:/var/run/docker.sock
       {{.DOCKER_REGISTRY}}/openwhisk2/standalone:{{.TAG}}
    interactive: true

  run:standalone:
    deps:
    - native:standalone-libs
    dir: openwhisk/core/standalone
    cmds:
    - java -cp build/classes/scala/main:build/resources/main:build/dependency-libs/*
      -Dwhisk.standalone.host.name="0.0.0.0"
      -Dwhisk.standalone.host.internal="$(hostname -f)"
      org.apache.openwhisk.standalone.StandaloneOpenWhisk --no-browser