install.fairie/.config/taskfiles/release/Taskfile.yml

623 lines
18 KiB
YAML
Raw Normal View History

2022-12-24 12:04:59 -08:00
---
version: '3'
env:
RELEASE_ANSIBLE:
sh: |
if [[ '{{.REPOSITORY_TYPE}}' == 'ansible' ]] && [[ '{{.REPOSITORY_SUBTYPE}}' == 'role' ]]; then
echo 'release'
fi
RELEASE_DOCKER:
sh: |
if [ -f Dockerfile ] && ([[ '{{.REPOSITORY_TYPE}}' == 'docker' ]] || [[ "$(jq -r '.blueprint.dockerPublish' package.json)" == 'true' ]]); then
echo 'release'
fi
RELEASE_GO:
sh: |
if [[ '{{.REPOSITORY_TYPE}}' == 'go' ]] && [[ '{{.REPOSITORY_SUBTYPE}}' == 'cli' ]]; then
echo 'release'
fi
RELEASE_NPM:
sh: |
if [[ '{{.REPOSITORY_TYPE}}' == 'npm' ]] || [[ "$(jq -r '.blueprint.npmPublish' package.json)" == 'true' ]]; then
echo 'release'
fi
RELEASE_PACKER:
sh: |
if [[ '{{.REPOSITORY_TYPE}}' == 'packer' ]]; then
echo 'release'
fi
RELEASE_PYTHON:
sh: |
if [[ '{{.REPOSITORY_TYPE}}' == 'python' ]] || [[ "$(jq -r '.blueprint.pythonPublish' package.json)" == 'true' ]]; then
echo 'release'
fi
SNAP_PACKAGE:
sh: jq -r '.blueprint.snapPackage' package.json
tasks:
add-channel:
deps:
- add-channel:ansible
- add-channel:docker
- add-channel:npm
- add-channel:packer
- add-channel:python
- add-channel:snap
summary: |
Must return a parseable JSON string that resembles the following format:
```json
{
type: 'patch',
channel: 'master',
gitHead: 'c7dbb1e87ebff9b177bdb52a326f5b8373b79442',
version: '1.1.26',
gitTag: 'v1.1.26',
name: 'GitLab release',
notes: '## [1.1.26](https://gitlab.com/megabyte-labs/npm/configs/release/compare/v1.1.25...v1.1.26) (2022-04-07)\n' +
'\n' +
'\n' +
'\n',
url: 'https://gitlab.com/megabyte-labs%2Fnpm%2Fconfigs%2Frelease/-/releases/v1.1.26',
pluginName: '@semantic-release/gitlab'
}
```
add-channel:ansible:
vars:
GALAXY_URL:
sh: |
if [ -n "$RELEASE_ANSIBLE" ]; then
echo "https://galaxy.ansible.com/{{.GALAXY_NAMESPACE}}/{{.GALAXY_ROLE_NAME}}"
fi
cmds:
- |
echo '{"name": "Ansible Galaxy role", "url": "{{.GALAXY_URL}}"}'
status:
- '[ -z "$RELEASE_ANSIBLE" ]'
add-channel:docker:
vars:
DOCKERHUB_URL:
sh: |
if [ -n "$RELEASE_DOCKER" ]; then
echo "https://hub.docker.com/r/{{.DOCKERHUB_PROFILE}}/$(jq -r '.blueprint.slug' package.json)"
fi
cmds:
- |
echo '{"name": "DockerHub", "url": "{{.DOCKERHUB_URL}}"}'
status:
- '[ -z "$RELEASE_DOCKER" ]'
add-channel:npm:
cmds:
- |
echo '{"name": "Testing", "url": "https://megabyte.space"}'
status:
- '[ -z "$RELEASE_NPM" ]'
add-channel:packer:
vars:
VAGRANTUP_URL:
sh: |
if [ -n "$RELEASE_PACKER" ]; then
BASENAME="$(jq -r '.variables.box_basename' template.json)"
VAGRANTUP_USER="$(jq -r '.variables.vagrantup_user' template.json)"
if [ "$BASENAME" != 'null' ] && [ "$BASENAME" != 'null' ]; then
echo "https://app.vagrantup.com/$VAGRANTUP_USER/boxes/$BASENAME"
else
echo "https://megabyte.space"
fi
fi
cmds:
- |
echo '{"name": "VagrantUp box", "url": "{{.VAGRANTUP_URL}}"}'
status:
- '[ -z "$RELEASE_PACKER" ]'
add-channel:python:
vars:
PYPI_URL:
sh: |
if [ -n "$RELEASE_PYTHON" ]; then
PKG_NAME="$(jq -r '.blueprint.customPyPiPackageName' package.json)"
if [ "$PKG_NAME" == 'null' ]; then
PKG_NAME="$(jq -r '.blueprint.customPackageName' package.json)"
fi
if [ "$PKG_NAME" == 'null' ]; then
PKG_NAME="$(jq -r '.name' package.json)"
fi
echo "https://pypi.org/project/$PKG_NAME"
fi
cmds:
- |
echo '{"name": "pip package", "url": "{{.PYPI_URL}}"}'
status:
- '[ -z "$RELEASE_PYTHON" ]'
add-channel:snap:
vars:
SNAP_PACKAGE:
sh: echo "$SNAP_PACKAGE"
cmds:
- |
echo '{"name": "Snap", "url": "https://snapcraft.io/{{.SNAP_PACKAGE}}"}'
status:
- '[ "$SNAP_PACKAGE" == "null" ]'
analyze:
summary: |
| Command property | Description |
|------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `exit code` | Any non `0` code is considered as an unexpected error and will stop the `semantic-release` execution with an error. |
| `stdout` | Only the release type (`major`, `minor` or `patch` etc..) can be written to `stdout`. If no release has to be done the command must not write to `stdout`. |
| `stderr` | Can be used for logging. |
cmds:
- |
if [ "$FORCE_SEMANTIC_RELEASE" == 'true' ]; then
echo 'patch'
fi
build:
deps:
- build:ansible
- build:docker
- build:go
- build:npm
- build:packer
- build:python
build:ansible:
cmds:
- task: :build
status:
- '[ -z "$RELEASE_ANSIBLE" ]'
build:docker:
cmds:
- task: :build
status:
- '[ -z "$RELEASE_DOCKER" ]'
build:go:
cmds:
- task: build:go:continue
status:
- '[ -z "$RELEASE_GO" ]'
build:go:continue:
deps:
- build:go:deps
cmds:
- task: :build
build:go:deps:
deps:
- :docker:login
- :install:go:goreleaser
- :install:go:nfpm
- :install:software:go
- :install:software:snapcraft
build:npm:
deps:
- build:npm:deps
cmds:
- task: :build
status:
- '[ -z "$RELEASE_NPM" ]'
build:npm:deps:
deps:
- build:npm:deps:go
build:npm:deps:go:
cmds:
- task: build:go:deps
status:
- '[ "{{.REPOSITORY_SUBTYPE}}" != "cli" ]'
build:packer:
cmds:
- task: :build
status:
- '[ -z "$RELEASE_PACKER" ]'
build:python:
cmds:
- task: :build
status:
- '[ -z "$RELEASE_PYTHON" ]'
fail:
deps:
- :install:software:jq
env:
ARTIFACTS_JSON:
sh: jq -r '.' build/artifacts.json || echo null
METADATA_JSON:
sh: jq -r '.' build/metadata.json || echo null
PACKAGE_JSON:
sh: jq -r '.' package.json
RELEASE_JSON:
sh: jq -r '.' .release.json || echo null
TMP:
sh: mktemp
VARIABLES_JSON:
sh: jq -r '.' .variables.json
cmds:
- jq -n --arg artifacts "$ARTIFACTS_JSON" --arg metadata "$METADATA_JSON" --arg pkg "$PACKAGE_JSON" --arg release "$RELEASE_JSON" --arg vars "$VARIABLES_JSON" --arg job "$CI_JOB_ID"
'.["package.json"] = $pkg | .[".release.json"] = $release | .["build/artifacts.json"] = $artifacts | .["build/metadata.json"] = $metadata | .[".variables.json"] = $vars | .CI_JOB_ID = $job' > "$TMP"
- >
curl -X POST -H "Content-Type: application/json" -d "$(cat "$TMP")"
"https://maker.ifttt.com/trigger/SemanticReleaseFail/json/with/key/$IFTTT_WEBHOOK_TOKEN"
status:
- '[ -z "$IFTTT_WEBHOOK_TOKEN" ]'
notes:
cmds:
- task: notes:introduction
- task: notes:project-specific
notes:ansible:
vars:
PKG_NAME:
sh: |
if [ -n "$RELEASE_ANSIBLE" ]; then
echo "{{.GALAXY_NAMESPACE}}.{{.GALAXY_ROLE_NAME}}"
fi
VERSION:
sh: jq -r '.version' package.json
cmds:
- echo -e '```shell\nansible-galaxy install {{.PKG_NAME}},v{{.VERSION}}\n```\n'
status:
- '[ -z "$RELEASE_ANSIBLE" ]'
notes:docker:
vars:
IMAGE:
sh: |
if [ -n "$RELEASE_DOCKER" ]; then
echo "{{.DOCKERHUB_PROFILE}}/$(jq -r '.blueprint.slug' package.json)"
fi
VERSION:
sh: jq -r '.version' package.json
cmds:
- echo -e '```shell\ndocker pull {{.IMAGE}}:{{.VERSION}}\n```\n'
status:
- '[ -z "$RELEASE_DOCKER" ]'
notes:go:
vars:
GITHUB_GO_URL:
sh: jq -r '.blueprint.repository.github' package.json | sed 's/https:\/\///'
VERSION:
sh: jq -r '.version' package.json
cmds:
- echo -e '```shell\ngo install {{.GITHUB_GO_URL}}@v{{.VERSION}}\n```\n'
status:
- '[ -z "$RELEASE_GO" ]'
notes:introduction:
cmds:
- echo -e 'Grab this version by running:\n\n'
notes:npm:
vars:
FLAG:
sh: |
if [ '{{.REPOSITORY_SUBTYPE}}' == 'cli' ]; then
echo ' -g'
elif [ '{{.REPOSITORY_SUBTYPE}}' == 'config' ] || [ '{{.REPOSITORY_SUBTYPE}}' == 'plugin' ]; then
echo ' --save-dev'
else
echo ' --save'
fi
PKG_NAME:
sh: jq -r '.name' package.json
VERSION:
sh: jq -r '.version' package.json
cmds:
- echo -e '```shell\nnpm i{{.FLAG}} {{.PKG_NAME}}@{{.VERSION}}\n```\n'
status:
- '[ -z "$RELEASE_NPM" ]'
notes:packer:
vars:
VAGRANTUP_BOX:
sh: |
if [ -n "$RELEASE_PACKER" ]; then
BASENAME="$(jq -r '.variables.box_basename' template.json)"
VAGRANTUP_USER="$(jq -r '.variables.vagrantup_user' template.json)"
if [ "$BASENAME" != 'null' ] && [ "$BASENAME" != 'null' ]; then
echo "$VAGRANTUP_USER/$BASENAME"
fi
fi
VERSION:
sh: jq -r '.version' package.json
cmds:
- echo -e '```shell\nvagrant init --box-version '{{.VERSION}}' {{.VAGRANTUP_BOX}} && vagrant up\n```\n'
status:
- '[ -z "$RELEASE_PACKER" ]'
notes:project-specific:
deps:
- notes:ansible
- notes:docker
- notes:go
- notes:npm
- notes:packer
- notes:python
notes:python:
vars:
PKG_NAME:
sh: |
if [ -n "$RELEASE_PYTHON" ]; then
PKG_NAME="$(jq -r '.blueprint.customPyPiPackageName' package.json)"
if [ "$PKG_NAME" == 'null' ]; then
PKG_NAME="$(jq -r '.blueprint.customPackageName' package.json)"
fi
if [ "$PKG_NAME" == 'null' ]; then
PKG_NAME="$(jq -r '.name' package.json)"
fi
echo "$PKG_NAME"
fi
VERSION:
sh: jq -r '.version' package.json
cmds:
- echo -e '```shell\npip3 install {{.PKG_NAME}}=={{.VERSION}}\n```\n'
status:
- '[ -z "$RELEASE_PYTHON" ]'
prepare:
deps:
- prepare:ansible
- prepare:docker
- prepare:go
- prepare:npm
- prepare:packer
- prepare:python
summary: |
| Command property | Description |
|------------------|---------------------------------------------------------------------------------------------------------------------|
| `exit code` | Any non `0` code is considered as an unexpected error and will stop the `semantic-release` execution with an error. |
| `stdout` | Can be used for logging. |
| `stderr` | Can be used for logging. |
prepare:ansible:
cmds:
- task: :ansible:prepare
status:
- '[ -z "$RELEASE_ANSIBLE" ]'
prepare:docker:
cmds:
- task: :docker:prepare
status:
- '[ -z "$RELEASE_DOCKER" ]'
prepare:go:
cmds:
- task: :go:prepare
status:
- '[ -z "$RELEASE_GO" ]'
prepare:npm:
cmds:
- task: :npm:prepare
status:
- '[ -z "$RELEASE_NPM" ]'
prepare:packer:
cmds:
- task: :packer:prepare
status:
- '[ -z "$RELEASE_PACKER" ]'
prepare:python:
cmds:
- task: :python:prepare
status:
- '[ -z "$RELEASE_PYTHON" ]'
publish:
deps:
- publish:ansible
- publish:docker
- publish:go
- publish:npm
- publish:packer
- publish:python
publish:ansible:
cmds:
- task: :ansible:publish
status:
- '[ -z "$RELEASE_ANSIBLE" ]'
publish:docker:
cmds:
- task: :docker:publish
status:
- '[ -z "$RELEASE_DOCKER" ]'
publish:go:
cmds:
- task: :go:publish
status:
- '[ -z "$RELEASE_GO" ]'
publish:npm:
summary: |
Modify the dist tag used (shown in release notes) by modifying `package.json` with the following:
```
{
"publishConfig": {
"registry": "https://registry.npmjs.org/",
"tag": "latest"
}
```
cmds:
- task: publish:npm:tasks
status:
- '[ -z "$RELEASE_NPM" ]'
publish:npm:latest:
vars:
PKG_NAME:
sh: jq -r '.name' package.json
VERSION:
sh: jq -r '.version' package.json
cmds:
- npm config set -- 'https://registry.npmjs.org/:_authToken' '${NPM_TOKEN}'
- npm dist-tag add {{.PKG_NAME}}@{{.VERSION}} latest &> /dev/null
publish:npm:tasks:
deps:
- publish:npm:latest
- :npm:publish:gitlab
publish:packer:
cmds:
- task: :packer:publish
status:
- '[ -z "$RELEASE_PACKER" ]'
publish:python:
cmds:
- task: :python:publish
status:
- '[ -z "$RELEASE_PYTHON" ]'
success:
deps:
- :install:software:jq
summary: |
| Command property | Description |
|------------------|---------------------------------------------------------------------------------------------------------------------|
| `exit code` | Any non `0` code is considered as an unexpected error and will stop the `semantic-release` execution with an error. |
| `stdout` | Can be used for logging. |
| `stderr` | Can be used for logging. |
env:
PACKAGE_JSON:
sh: jq -r '.' package.json
RELEASE_JSON:
sh: jq -r '.' .release.json
TMP:
sh: mktemp
VARIABLES_JSON:
sh: jq -r '.' .variables.json
cmds:
- jq -n --arg pkg "$PACKAGE_JSON" --arg release "$RELEASE_JSON" --arg vars "$VARIABLES_JSON"
'.["package.json"] = $pkg | .[".release.json"] = $release | .[".variables.json"] = $vars' > "$TMP"
- >
curl -X POST -H "Content-Type: application/json" -d "$(cat "$TMP")"
"https://maker.ifttt.com/trigger/SemanticRelease/json/with/key/$IFTTT_WEBHOOK_TOKEN"
status:
- '[ -z "$IFTTT_WEBHOOK_TOKEN" ]'
verify:conditions:
deps:
- verify:conditions:ansible
- verify:conditions:docker
- verify:conditions:go
- verify:conditions:npm
- verify:conditions:packer
- verify:conditions:python
summary: |
| Command property | Description |
|------------------|--------------------------------------------------------------------------|
| `exit code` | `0` if the verification is successful, or any other exit code otherwise. |
| `stdout` | Write only the reason for the verification to fail. |
| `stderr` | Can be used for logging. |
verify:conditions:ansible:
cmds:
- task: :ansible:verify
status:
- '[ -z "$RELEASE_ANSIBLE" ]'
verify:conditions:docker:
cmds:
- task: :docker:verify
status:
- '[ -z "$RELEASE_DOCKER" ]'
verify:conditions:go:
cmds:
- task: :go:verify
status:
- '[ -z "$RELEASE_GO" ]'
verify:conditions:npm:
cmds:
- task: :npm:verify
status:
- '[ -z "$RELEASE_NPM" ]'
verify:conditions:packer:
cmds:
- task: :packer:verify
status:
- '[ -z "$RELEASE_PACKER" ]'
verify:conditions:python:
cmds:
- task: :python:verify
status:
- '[ -z "$RELEASE_PYTHON" ]'
verify:release:
deps:
- verify:release:ansible
- verify:release:docker
- verify:release:go
- verify:release:npm
- verify:release:packer
- verify:release:python
summary: |
| Command property | Description |
|------------------|--------------------------------------------------------------------------|
| `exit code` | `0` if the verification is successful, or any other exit code otherwise. |
| `stdout` | Only the reason for the verification to fail can be written to `stdout`. |
| `stderr` | Can be used for logging. |
verify:release:ansible:
cmds:
- 'true'
status:
- '[ -z "$RELEASE_ANSIBLE" ]'
verify:release:docker:
cmds:
- 'true'
status:
- '[ -z "$RELEASE_DOCKER" ]'
verify:release:go:
cmds:
- 'true'
status:
- '[ -z "$RELEASE_GO" ]'
verify:release:npm:
cmds:
- 'true'
status:
- '[ -z "$RELEASE_NPM" ]'
verify:release:packer:
cmds:
- 'true'
status:
- '[ -z "$RELEASE_PACKER" ]'
verify:release:python:
cmds:
- 'true'
status:
- '[ -z "$RELEASE_PYTHON" ]'