activestate.yaml

project: https://platform.activestate.com/ActiveState/cli?branch=main&commitID=7a2fb89c-4bf0-4bb8-b45e-88b0d8af10e4
constants:
  - name: CLI_BUILDFLAGS
    value: -ldflags="-s -w"
  - name: CLI_PKGS
    value: ./cmd/state
  - name: DAEMON_PKGS
    value: ./cmd/state-svc
  - name: INSTALLER_PKGS
    value: ./cmd/state-installer
  - name: EXECUTOR_PKGS
    value: ./cmd/state-exec
  - name: BUILD_TARGET_PREFIX_DIR
    value: ./build
  - name: BUILD_TARGET
    if: ne .OS.Name "Windows"
    value: state
  - name: SVC_BUILDFLAGS
    if: ne .OS.Name "Windows"
    value: $constants.CLI_BUILDFLAGS
  - name: BUILD_DAEMON_TARGET
    if: ne .OS.Name "Windows"
    value: state-svc
  - name: BUILD_EXEC_TARGET
    if: ne .OS.Name "Windows"
    value: state-exec
  - name: BUILD_INSTALLER_TARGET
    if: ne .OS.Name "Windows"
    value: state-installer
  - name: BUILD_REMOTE_INSTALLER_TARGET
    value: state-remote-installer
  - name: INTEGRATION_TEST_REGEX
    value: 'integration\|automation'
  - name: SET_ENV
    description: The environment settings used throughout our project
    value: |
      GOFLAGS='-mod=vendor'
      GOPATH="${GOPATH:=`go env GOPATH`}"
      GOROOT="${GOROOT:=`go env GOROOT`}"
      export CGO_ENABLED=0
      PATH="${GOROOT}/bin:${GOPATH}/bin:${PATH}"
      BUILD_EXEC_TARGET=$constants.BUILD_EXEC_TARGET

      # add the GOARCH as infix to BUILD_TARGET_DIR if not amd64
      BUILD_TARGET_DIR=$constants.BUILD_TARGET_PREFIX_DIR/${GOARCH#amd64}
  - name: SCRIPT_EXT
    if: ne .OS.Name "Windows"
    value: .sh
scripts:
  - name: install-deps
    language: bash
    value: |
      export GO111MODULE=on
      goflags="${GOFLAGS}"; unset GOFLAGS
      GOFLAGS="${goflags}"
      pushd ~
      go install github.com/ActiveState/gozip/cmd/gozip@e455986
      popd
      $scripts.install-deps-os
  - name: install-deps-os
    language: bash
    if: ne .OS.Name "Linux"
    description: Install OS specific deps
    value: ""
  - name: preprocess
    language: bash
    description: Generates assets required by the project that aren't just specific to the build
    value: |
      set -e
      $constants.SET_ENV
      go run scripts/constants-generator/main.go -- internal/constants/generated.go
      mkdir -p build/msi
  - name: build
    language: bash
    description: Builds the project with the host OS as the target OS.
    value: |
      set -e
      $constants.SET_ENV

      go build -tags "$GO_BUILD_TAGS" -o $BUILD_TARGET_DIR/$constants.BUILD_TARGET $constants.CLI_BUILDFLAGS $constants.CLI_PKGS
  - name: build-for
    language: bash
    description: Builds the project with the specified OS as the target OS. (valid values darwin, linux, windows)
    value: |
      set -e
      $constants.SET_ENV
      export GOOS=${1}
      export GOARCH=amd64
      [ -z "${2}" ] && >&2 echo "must provide output file as 2nd arg" && exit 1
      go build -tags "internal $GO_BUILD_TAGS" -o ${2} $constants.CLI_BUILDFLAGS $constants.CLI_PKGS
  - name: build-svc
    language: bash
    description: Builds the state-svc daemon
    value: |
      set -e
      $constants.SET_ENV

      go build -tags "$GO_BUILD_TAGS" -o $BUILD_TARGET_DIR/$constants.BUILD_DAEMON_TARGET $constants.SVC_BUILDFLAGS $constants.DAEMON_PKGS
  - name: build-exec
    description: Builds the State Executor application
    language: bash
    value: |
      set -e
      $constants.SET_ENV

      go build -tags "$GO_BUILD_TAGS" -o $BUILD_TARGET_DIR/$constants.BUILD_EXEC_TARGET $constants.CLI_BUILDFLAGS $constants.EXECUTOR_PKGS
  - name: build-all
    description: Builds all our tools
    standalone: true
    language: bash
    value: |
      set -e
      echo "Building State Tool"
      $scripts.build.path()
      echo "Building State Installer"
      $scripts.build-installer.path()
      echo "Building State Remote Installer"
      $scripts.build-remote-installer.path()
      echo "Building State Service"
      $scripts.build-svc.path()
      echo "Building State Executor"
      $scripts.build-exec.path()
  - name: build-installer
    language: bash
    description: Builds the state-installer
    value: |
      set -e
      $constants.SET_ENV

      go build -tags "$GO_BUILD_TAGS" -o $BUILD_TARGET_DIR/$constants.BUILD_INSTALLER_TARGET $constants.INSTALLER_PKGS
  - name: build-remote-installer
    language: bash
    description: Builds the state-remote-installer
    value: |
      set -e
      $constants.SET_ENV
      TARGET=$BUILD_REMOTE_INSTALLER_TARGET
      if [[ "$GOOS" == "windows" || "$OS" == "Windows_NT" ]]; then
        TARGET="${BUILD_REMOTE_INSTALLER_TARGET}.exe"
      fi
      GOFLAGS="" go install github.com/josephspurrier/goversioninfo/cmd/goversioninfo@latest
      cd cmd/state-remote-installer
      go generate
      go build -tags "$GO_BUILD_TAGS" -o ../../$BUILD_TARGET_DIR/$TARGET .
  - name: install
    language: bash
    description: Installs the current HEAD version into GOBIN
    value: |
      $constants.SET_ENV
      go install $constants.CLI_BUILDFLAGS $CLI_PKGS
  - name: deploy-updates
    language: bash
    description: Deploys update files to S3. This steps is automated by CI and should never be ran manually unless you KNOW WHAT YOU'RE DOING.
    value: |
      set -e
      $constants.SET_ENV

      echo "If using tokens make sure to run 'go run extras/aws-mfa-auth/main.go' on TheHomeRepot first."

      go run scripts/ci/s3-deployer/main.go ${constants.BUILD_TARGET_PREFIX_DIR}/update us-east-1 state-tool update/state
  - name: build-install-scripts
    language: bash
    standalone: true
    description: Replaces installer channel with branch and copies install scripts to build dir
    value: |
      set -e
      if [ "$GITHUB_HEAD_REF" != "" ]; then
        BRANCH=${GITHUB_HEAD_REF}
      elif [ "$GITHUB_REF" != "" ]; then
        BRANCH=$(echo $GITHUB_REF | awk -F'/' '{print $NF}')
      else
        BRANCH=$(git rev-parse --abbrev-ref HEAD)
      fi

      if [ "$BRANCH" == "" ]; then
        echo "Branch cannot be empty"
        exit 1
      fi
      if [ "$BRANCH" == "release" ]; then
        BRANCH=""
      fi

      INSTALLERS_DIR=build/installers/$BRANCH
      mkdir -p $INSTALLERS_DIR

      echo "Copying to $INSTALLERS_DIR"

      cp installers/legacy-install.sh $INSTALLERS_DIR/legacy-install${constants.SCRIPT_EXT}

      if [ "$BRANCH" != "" ]; then
        sed "s/\(CHANNEL[[:space:]]*=[[:space:]]*\)\"release\"/\\1\"${BRANCH/\//\\/}\"/" installers/install${constants.SCRIPT_EXT} > $INSTALLERS_DIR/install${constants.SCRIPT_EXT}
      else
        cp installers/install${constants.SCRIPT_EXT} $INSTALLERS_DIR/install${constants.SCRIPT_EXT}
      fi
      cp installers/stop${constants.SCRIPT_EXT} $INSTALLERS_DIR/stop${constants.SCRIPT_EXT}
  - name: deploy-installers
    language: bash
    description: Deploys update files to S3. This steps is automated by CI and should never be ran manually unless you KNOW WHAT YOU'RE DOING.
    value: |
      go run scripts/ci/s3-deployer/main.go build/installers us-east-1 state-tool update/state
  - name: deploy-remote-installer
    language: bash
    value: |
      set -e
      $constants.SET_ENV
      go run scripts/ci/s3-deployer/main.go $BUILD_TARGET_DIR/remote-installer us-east-1 state-tool remote-installer
  - name: deploy-msi
    language: bash
    value: |
      go run scripts/ci/s3-deployer/main.go build/msi us-east-1 cli-msi /
  - name: build-workflow-assets
    language: bash
    description: Generates our github workflows
    value: |
      $scripts.build-for.path() "windows" ./.github/deps/Windows/bin/state.exe
      $scripts.build-for.path() "linux" ./.github/deps/Linux/bin/state
      $scripts.build-for.path() "darwin" ./.github/deps/macOS/bin/state

      GOOS=windows go build -o .github/deps/Windows/bin/parallelize.exe github.com/ActiveState/cli/scripts/ci/parallelize/
      GOOS=linux go build -o .github/deps/Linux/bin/parallelize github.com/ActiveState/cli/scripts/ci/parallelize/
      GOOS=darwin go build -o .github/deps/macOS/bin/parallelize github.com/ActiveState/cli/scripts/ci/parallelize/
  - name: update-workflow-assets
    language: bash
    description: Generates our github workflows
    value: |
      [ -z "${2}" ] && >&2 echo "Usage: update-workflow-assets [branch] [version]" && exit 1

      tmpDir=$(mktemp -d)
      pushd $tmpDir
      wget https://state-tool.s3.amazonaws.com/update/state/${1}/${2}/darwin-amd64/state-darwin-amd64-${2}.tar.gz
      tar xzf state-darwin-amd64-${2}.tar.gz
      cp -Rfv state-install/bin/state $project.path()/.github/deps/macOS/bin
      cp -Rfv state-install/bin/state-svc $project.path()/.github/deps/macOS/bin
      popd
      rm -Rf $tmpDir

      tmpDir=$(mktemp -d)
      pushd $tmpDir
      wget https://state-tool.s3.amazonaws.com/update/state/${1}/${2}/linux-amd64/state-linux-amd64-${2}.tar.gz
      tar xzf state-linux-amd64-${2}.tar.gz
      cp -Rfv state-install/bin/state $project.path()/.github/deps/Linux/bin
      cp -Rfv state-install/bin/state-svc $project.path()/.github/deps/Linux/bin
      popd
      rm -Rf $tmpDir

      tmpDir=$(mktemp -d)
      pushd $tmpDir
      wget https://state-tool.s3.amazonaws.com/update/state/${1}/${2}/windows-amd64/state-windows-amd64-${2}.zip
      unzip state-windows-amd64-${2}.zip
      cp -Rfv state-install/bin/state.exe $project.path()/.github/deps/Windows/bin
      cp -Rfv state-install/bin/state-svc.exe $project.path()/.github/deps/Windows/bin
      popd
      rm -Rf $tmpDir
  - name: test
    language: bash
    description: Runs unit tests (not integration tests)
    value: |
      ACTIVESTATE_PROJECT="" go test -v `go list ./... | grep -v api | grep -v integration | grep -v automation | grep -v expect | grep -v state-svc | grep -v state-offline`
    standalone: true
  - name: integration-tests
    language: bash
    description: Runs integration tests.
    value: |
      unset ACTIVESTATE_ACTIVATED
      export INTEGRATION_TEST_USERNAME=$secrets.project.INTEGRATION_TEST_USERNAME
      export INTEGRATION_TEST_PASSWORD=$secrets.project.INTEGRATION_TEST_PASSWORD
      go test `go list ./... | grep "${INTEGRATION_TEST_REGEX}"` -v "${@:1}" -timeout 20m
  - name: integration-tests-build-check
    language: bash
    description: Builds integration tests and removes the executable artifact(s).
    value: |
      out="x.test"
      go list ./... | grep "${INTEGRATION_TEST_REGEX}" | xargs -L 1 go test -o $out -c
      [ -f $out ] && rm $out
  - name: clean
    language: bash
    description: Cleans out the build dir.
    value: |
      go clean
      rm -Rf build
  - name: run
    language: bash
    description: Builds the State Tool and runs it with `--help`
    value: |
      $scripts.build
      build/state --help
  - name: debug
    language: bash
    description: "Runs a remote debugger, that can be hooked into from your IDE, example usage: `state run debug activate` (will debug `state activate`)"
    standalone: true
    value: dlv debug --headless --listen=:2346 --api-version=2 github.com/ActiveState/cli/cmd/state -- $@
  - name: scripted
    language: bash
    description: "Runs a command via 'go run'"
    standalone: true
    value: go run github.com/ActiveState/cli/cmd/state $@
  - name: story-cleanup
    language: bash
    description: "Runs Python script to move old stories from primary project to storage project"
    value: |
      export PT_API_TOKEN=$secrets.project.PT_API_TOKEN
      export PT_PROJID_PRIMARY=$secrets.project.PT_PROJID_PRIMARY
      export PT_PROJID_STORAGE=$secrets.project.PT_PROJID_STORAGE
      export PT_DAYS_AGED=190 # set this value to control cleanup
      python3 ./scripts/story-cleanup/story-cleanup.py
  - name: lint
    language: bash
    description: "Runs linting for untracked and unstaged changes (if any), or staged changes"
    value: |
      golangci-lint run --new
      actionlint
  - name: lint-staged
    language: bash
    description: "Runs linting for staged changes (skipping untracked and unstaged-only files)"
    value: |
      golangci-lint run \
        --new-from-rev=HEAD~ \
        --skip-files="$(git ls-files --others --exclude-standard -z | xargs -0 -I{} echo "^"{})" \
        --skip-files="$(comm -13 <(git diff --cached --name-only | sort) <(git diff --name-only | sort))"

      actionfiles=$(git diff --cached --name-only --diff-filter=ACM | grep '^.github/workflows/' | grep '.yml$')
      [ -z "$actionfiles" ] && exit 0
      actionlint $actionfiles
  - name: lint-all
    language: bash
    description: "Runs linting for all files"
    value: |
      golangci-lint run --no-config
      actionlint
  - name: grab-mergecommits
    language: bash
    value: |
      export JIRA_USERNAME=${secrets.user.JIRA_USERNAME}
      export JIRA_TOKEN=${secrets.user.JIRA_TOKEN}
      export GITHUB_TOKEN=${secrets.user.GITHUB_TOKEN}
      go run $project.path()/scripts/grab-mergecommits/main.go $1
  - name: target-version-pr
    language: bash
    value: |
      export JIRA_USERNAME=${secrets.user.JIRA_USERNAME}
      export JIRA_TOKEN=${secrets.user.JIRA_TOKEN}
      export GITHUB_TOKEN=${secrets.user.GITHUB_TOKEN}
      go run $project.path()/scripts/ci/target-version-pr/main.go $1
  - name: create-version-pr
    language: bash
    value: |
      export JIRA_USERNAME=${secrets.user.JIRA_USERNAME}
      export JIRA_TOKEN=${secrets.user.JIRA_TOKEN}
      export GITHUB_TOKEN=${secrets.user.GITHUB_TOKEN}
      go run $project.path()/scripts/create-version-pr/main.go $1
  - name: propagate-pr
    language: bash
    value: |
      export JIRA_USERNAME=${secrets.user.JIRA_USERNAME}
      export JIRA_TOKEN=${secrets.user.JIRA_TOKEN}
      export GITHUB_TOKEN=${secrets.user.GITHUB_TOKEN}
      go run $project.path()/scripts/ci/propagate-pr/main.go $1
  - name: verify-pr
    language: bash
    value: |
      export JIRA_USERNAME=${secrets.user.JIRA_USERNAME}
      export JIRA_TOKEN=${secrets.user.JIRA_TOKEN}
      export GITHUB_TOKEN=${secrets.user.GITHUB_TOKEN}
      go run $project.path()/scripts/ci/verify-pr/main.go $1
  - name: start-story
    language: bash
    value: |
      export JIRA_USERNAME=${secrets.user.JIRA_USERNAME}
      export JIRA_TOKEN=${secrets.user.JIRA_TOKEN}
      export GITHUB_TOKEN=${secrets.user.GITHUB_TOKEN}
      go run $project.path()/scripts/start-story/main.go "$@"
  - name: ghapi
    language: bash
    value: |
      curl \
        -H "Accept: application/vnd.github+json" \
        -H "Authorization: token ${secrets.user.GITHUB_TOKEN}" \
        https://api.github.com/repos/ActiveState/cli/${1}
  - name: benchmark-exec
    if: eq .OS.Name "Linux"
    language: bash
    description: "Benchmarks executable leveraging highly sensitive/accurate tooling"
    value: |
      # example usage:
      # state run benchmark-exec -- state-exec /tmp/state-ipc/my.sock /home/me/.cache/abcd1234/bin/python3 -c "print('123');"
      paranoid="$(cat /proc/sys/kernel/perf_event_paranoid)"
      updated=false
      if [[ "${paranoid}" != "-1" ]]; then
          sudo sh -c 'echo -1 >/proc/sys/kernel/perf_event_paranoid'
          updated=true
      fi
      perf stat -d -r 8 -e task-clock,page-faults,cycles,instructions -- ${@} >/dev/null
      ${updated} && sudo sh -c 'echo '${paranoid}' >/proc/sys/kernel/perf_event_paranoid'

events:
  - name: activate
    if: ne .Shell "cmd"
    value: |
      if ! type "go" &> /dev/null; then
        echo "go is not installed. Please install Go version 1.11 or above."
        exit 1
      fi
      if ! type "golangci-lint" &> /dev/null; then
        echo "golangci-lint was not found on your PATH, installing .."
        go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.43.0
      fi
      git config core.hooksPath .githooks
      if ! type "swagger" &> /dev/null; then
        echo "swagger was not found on your PATH, installing .."
        go install github.com/go-swagger/go-swagger/cmd/swagger@v0.27.0
      fi
      if ! type "actionlint" &> /dev/null; then
        echo "actionlint was not found on your PATH, installing .."
        go install github.com/rhysd/actionlint/cmd/actionlint@v1.6.22
      fi
  - name: file-changed
    scope: ["internal/locale/locales"]
    value: build