diff --git a/.github/workflows/build-images-base.yaml b/.github/workflows/build-images-base.yaml index ed900e2c3..14bf5b799 100644 --- a/.github/workflows/build-images-base.yaml +++ b/.github/workflows/build-images-base.yaml @@ -101,7 +101,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Check out code - uses: actions/checkout@v3 + uses: actions/checkout@v4 - name: Set IMG_TAG to lower case id: lower-img-tag run: echo "IMG_TAGS=${IMG_TAGS@L}" >> $GITHUB_ENV @@ -128,6 +128,7 @@ jobs: QUAY_IMAGE_EXPIRY=${{ inputs.quayImageExpiry }} GIT_SHA=${{ github.sha }} DIRTY=false + VERSION=${{ inputs.operatorVersion }} - name: Print Image URL run: echo "Image pushed to ${{ env.IMG_REGISTRY_HOST }}/${{ env.IMG_REGISTRY_ORG }}/${{ env.OPERATOR_NAME }}:${{ env.IMG_TAGS }}" diff --git a/.github/workflows/build-images-for-tag-release.yaml b/.github/workflows/build-images-for-tag-release.yaml new file mode 100644 index 000000000..b69d45ba7 --- /dev/null +++ b/.github/workflows/build-images-for-tag-release.yaml @@ -0,0 +1,196 @@ +name: Build and Publish Images For Tag Release + +on: + push: + tags: + - "v[0-9]+.[0-9]+.[0-9]+" +env: + IMG_REGISTRY_HOST: quay.io + IMG_REGISTRY_ORG: kuadrant + OPERATOR_NAME: kuadrant-operator + +jobs: + build: + name: Build and Push image + runs-on: ubuntu-latest + outputs: + build-tags: ${{ steps.build-image.outputs.tags }} + image: ${{ steps.push-to-quay.outputs.registry-path }} + steps: + - name: Check out code + uses: actions/checkout@v4 + + - name: Read release string version + id: release + run: | + version=`make read-release-version` + echo version=$version >> $GITHUB_OUTPUT + + - name: Print tags + run: echo "Git reference name = ${{ github.ref_name }}, release version = ${{ steps.release.outputs.version }}" + - name: Verify git reference name matches the release version + if: ${{ github.ref_name != steps.release.outputs.version }} + run: exit 1 + + - name: Install qemu dependency + run: | + sudo apt-get update + sudo apt-get install -y qemu-user-static + + - name: Build Image + id: build-image + uses: redhat-actions/buildah-build@v2 + with: + image: ${{ env.OPERATOR_NAME }} + tags: ${{ github.ref_name }} + platforms: linux/amd64,linux/arm64 + build-args: | + GIT_SHA=${{ github.sha }} + DIRTY=false + VERSION=${{ github.ref_name }} + + dockerfiles: | + ./Dockerfile + + - name: Print Build Info + run: echo "Image = ${{ steps.build-image.outputs.image }}, Tags = ${{ steps.build-image.outputs.tags }}" + + - name: Push Image + if: github.repository_owner == 'kuadrant' + id: push-to-quay + uses: redhat-actions/push-to-registry@v2 + with: + image: ${{ steps.build-image.outputs.image }} + tags: ${{ steps.build-image.outputs.tags }} + registry: ${{ env.IMG_REGISTRY_HOST }}/${{ env.IMG_REGISTRY_ORG }} + username: ${{ secrets.IMG_REGISTRY_USERNAME }} + password: ${{ secrets.IMG_REGISTRY_TOKEN }} + + - name: Print Image URL + run: echo "Image pushed to ${{ steps.push-to-quay.outputs.registry-paths }}" + + build-bundle: + name: Build and Push bundle image + needs: [build] + runs-on: ubuntu-latest + outputs: + build-tags: ${{ steps.build-image.outputs.tags }} + image: ${{ steps.push-to-quay.outputs.registry-path }} + steps: + - name: Check out code + uses: actions/checkout@v4 + - name: Install yq tool + run: | + # following sub-shells running make target should have yq already installed + make yq + - name: Read operator image reference URL from the manifest bundle + id: parsed-operator-image + run: | + url=`make bundle-operator-image-url` + echo url=$url >> $GITHUB_OUTPUT + - name: Print tags and references + run: echo "Operator image tag = ${{ needs.build.outputs.image }}, Reference in bundle = ${{ steps.parsed-operator-image.outputs.url }}" + - name: Verify referenced operator image tag matches the tag currently being built + if: ${{ needs.build.outputs.image != steps.parsed-operator-image.outputs.url }} + run: exit 1 + + - name: Install qemu dependency + run: | + sudo apt-get update + sudo apt-get install -y qemu-user-static + + - name: Build Image + id: build-image + uses: redhat-actions/buildah-build@v2 + with: + image: ${{ env.OPERATOR_NAME }}-bundle + tags: ${{ needs.build.outputs.build-tags }} + platforms: linux/amd64,linux/arm64 + dockerfiles: | + ./bundle.Dockerfile + + - name: Print Build Info + run: echo "Image = ${{ steps.build-image.outputs.image }}, Tags = ${{ steps.build-image.outputs.tags }}, Operator IMG = ${{ steps.parsed-operator-image.outputs.url }}" + + - name: Push Image + if: github.repository_owner == 'kuadrant' + id: push-to-quay + uses: redhat-actions/push-to-registry@v2 + with: + image: ${{ steps.build-image.outputs.image }} + tags: ${{ steps.build-image.outputs.tags }} + registry: ${{ env.IMG_REGISTRY_HOST }}/${{ env.IMG_REGISTRY_ORG }} + username: ${{ secrets.IMG_REGISTRY_USERNAME }} + password: ${{ secrets.IMG_REGISTRY_TOKEN }} + + - name: Print Image URL + run: echo "Image pushed to ${{ steps.push-to-quay.outputs.registry-paths }}" + + build-catalog: + name: Build and Push catalog image + needs: [build, build-bundle] + runs-on: ubuntu-latest + outputs: + build-tags: ${{ steps.build-image.outputs.tags }} + image: ${{ steps.push-to-quay.outputs.registry-path }} + steps: + - name: Check out code + uses: actions/checkout@v4 + - name: Install yq tool + run: | + # following sub-shells running make target should have yq already installed + make yq + - name: Read operator bundle image reference + id: parsed-operator-bundle + run: | + image=`make print-bundle-image` + echo image=$image >> $GITHUB_OUTPUT + - name: Print tags and references + run: echo "Operator bundle image tag = ${{ needs.build-bundle.outputs.image }}, Reference in catalog = ${{ steps.parsed-operator-bundle.outputs.image }}" + - name: Verify referenced bundle tag matches the bundle tag currently being built + if: ${{ needs.build-bundle.outputs.image != steps.parsed-operator-bundle.outputs.image }} + run: exit 1 + - name: Generate Catalog Content + run: make catalog + - name: Install qemu dependency + run: | + sudo apt-get update + sudo apt-get install -y qemu-user-static + - name: Build Image + id: build-image + uses: redhat-actions/buildah-build@v2 + with: + image: ${{ env.OPERATOR_NAME }}-catalog + tags: ${{ needs.build.outputs.build-tags }} + platforms: linux/amd64,linux/arm64 + context: ./catalog + dockerfiles: ./catalog/${{ env.OPERATOR_NAME }}-catalog.Dockerfile + + - name: Print Build Info + run: echo "Image = ${{ steps.build-image.outputs.image }}, Tags = ${{ steps.build-image.outputs.tags }}, Bundle IMG = ${{ steps.parsed-operator-bundle.outputs.image }}" + + - name: Push Image + if: github.repository_owner == 'kuadrant' + id: push-to-quay + uses: redhat-actions/push-to-registry@v2 + with: + image: ${{ steps.build-image.outputs.image }} + tags: ${{ steps.build-image.outputs.tags }} + registry: ${{ env.IMG_REGISTRY_HOST }}/${{ env.IMG_REGISTRY_ORG }} + username: ${{ secrets.IMG_REGISTRY_USERNAME }} + password: ${{ secrets.IMG_REGISTRY_TOKEN }} + + - name: Print Image URL + run: echo "Image pushed to ${{ steps.push-to-quay.outputs.registry-paths }}" + + verify-builds: + name: Ensure all image references are equal (operator, bundle, catalog) + needs: [build, build-bundle, build-catalog] + runs-on: ubuntu-latest + steps: + - name: Verify bundle and operator image tags match + if: ${{ needs.build.outputs.build-tags != needs.build-bundle.outputs.build-tags }} + run: exit 1 + - name: Verify catalog and bundle tags match + if: ${{ needs.build-bundle.outputs.build-tags != needs.build-catalog.outputs.build-tags }} + run: exit 1 diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml index b21270c20..cb3082beb 100644 --- a/.github/workflows/release.yaml +++ b/.github/workflows/release.yaml @@ -12,19 +12,19 @@ on: type: string authorinoOperatorVersion: description: Authorino Operator bundle version - default: latest + default: 0.0.0 type: string limitadorOperatorVersion: description: Limitador Operator bundle version - default: latest + default: 0.0.0 type: string dnsOperatorVersion: description: DNS Operator bundle version - default: latest + default: 0.0.0 type: string wasmShimVersion: description: WASM Shim version - default: latest + default: 0.0.0 type: string consolePluginImageURL: description: ConsolePlugin image URL @@ -38,7 +38,7 @@ on: jobs: build: name: Release operator - runs-on: ubuntu-20.04 + runs-on: ubuntu-latest steps: - name: Install gettext-base run: | @@ -50,28 +50,33 @@ jobs: go-version: 1.21.x id: go - name: Checkout code at git ref - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: ref: ${{ inputs.gitRef }} + token: ${{ secrets.KUADRANT_DEV_PAT }} - name: Create release branch if: ${{ !startsWith(inputs.gitRef, 'release-v') }} run: | git checkout -b release-v${{ inputs.kuadrantOperatorVersion }} - name: Prepare release run: | + make prepare-release \ VERSION=${{ inputs.kuadrantOperatorVersion }} \ AUTHORINO_OPERATOR_VERSION=${{ inputs.authorinoOperatorVersion }} \ LIMITADOR_OPERATOR_VERSION=${{ inputs.limitadorOperatorVersion }} \ DNS_OPERATOR_VERSION=${{ inputs.dnsOperatorVersion }} \ WASM_SHIM_VERSION=${{ inputs.wasmShimVersion }} \ - RELATED_IMAGE_CONSOLEPLUGIN=${{ inputs.consolePluginImageURL }} \ - make prepare-release + RELATED_IMAGE_CONSOLEPLUGIN=${{ inputs.consolePluginImageURL }} - name: Commit and push - run: | - git config --global user.name "github-actions[bot]" - git config --global user.email "github-actions[bot]@users.noreply.github.com" - git add -A && git commit -s -m "Prepared release v${{ inputs.kuadrantOperatorVersion }}" - git push origin release-v${{ inputs.kuadrantOperatorVersion }} + uses: stefanzweifel/git-auto-commit-action@v5 + with: + commit_message: "Prepared release v${{ inputs.kuadrantOperatorVersion }}" + commit_user_name: "github-actions[bot]" + commit_user_email: "github-actions[bot]@users.noreply.github.com" + branch: release-v${{ inputs.kuadrantOperatorVersion }} + create_branch: true + tagging_message: v${{ inputs.kuadrantOperatorVersion }} + commit_options: '--signoff' - name: Create release uses: softprops/action-gh-release@v1 with: diff --git a/Dockerfile b/Dockerfile index 40bfd09d4..fecd01092 100644 --- a/Dockerfile +++ b/Dockerfile @@ -14,7 +14,6 @@ COPY main.go main.go COPY api/ api/ COPY controllers/ controllers/ COPY pkg/ pkg/ -COPY version/ version/ # Set environment variables for cross-compilation ARG TARGETARCH @@ -23,10 +22,13 @@ ARG TARGETARCH ARG GIT_SHA ARG DIRTY +ARG VERSION ENV GIT_SHA=${GIT_SHA:-unknown} ENV DIRTY=${DIRTY:-unknown} -RUN CGO_ENABLED=0 GOOS=linux GOARCH=${TARGETARCH} go build -a -ldflags "-X main.gitSHA=${GIT_SHA} -X main.dirty=${DIRTY}" -o manager main.go +ENV VERSION=${VERSION:-unknown} + +RUN CGO_ENABLED=0 GOOS=linux GOARCH=${TARGETARCH} go build -a -ldflags "-X main.version=${VERSION} -X main.gitSHA=${GIT_SHA} -X main.dirty=${DIRTY}" -o manager main.go # Use distroless as minimal base image to package the manager binary # Refer to https://github.com/GoogleContainerTools/distroless for more details diff --git a/Makefile b/Makefile index 8fdabbb7d..897ef1c6d 100644 --- a/Makefile +++ b/Makefile @@ -94,6 +94,8 @@ else GOBIN=$(shell go env GOBIN) endif +RELEASE_FILE = $(PROJECT_PATH)/make/release.mk + # Kuadrant Namespace KUADRANT_NAMESPACE ?= kuadrant-system OPERATOR_NAMESPACE ?= $(KUADRANT_NAMESPACE) @@ -332,7 +334,7 @@ test-unit: clean-cov generate fmt vet ## Run Unit tests. build: GIT_SHA=$(shell git rev-parse HEAD || echo "unknown") build: DIRTY=$(shell $(PROJECT_PATH)/utils/check-git-dirty.sh || echo "unknown") build: generate fmt vet ## Build manager binary. - go build -ldflags "-X main.gitSHA=${GIT_SHA} -X main.dirty=${DIRTY}" -o bin/manager main.go + go build -ldflags "-X main.version=v$(VERSION) -X main.gitSHA=${GIT_SHA} -X main.dirty=${DIRTY}" -o bin/manager main.go run: export LOG_LEVEL = debug run: export LOG_MODE = development @@ -340,7 +342,7 @@ run: export OPERATOR_NAMESPACE := $(OPERATOR_NAMESPACE) run: GIT_SHA=$(shell git rev-parse HEAD || echo "unknown") run: DIRTY=$(shell $(PROJECT_PATH)/utils/check-git-dirty.sh || echo "unknown") run: generate fmt vet ## Run a controller from your host. - go run -ldflags "-X main.gitSHA=${GIT_SHA} -X main.dirty=${DIRTY}" --race ./main.go + go run -ldflags "-X main.version=v$(VERSION) -X main.gitSHA=${GIT_SHA} -X main.dirty=${DIRTY}" --race ./main.go docker-build: GIT_SHA=$(shell git rev-parse HEAD || echo "unknown") docker-build: DIRTY=$(shell $(PROJECT_PATH)/utils/check-git-dirty.sh || echo "unknown") @@ -349,6 +351,7 @@ docker-build: ## Build docker image with the manager. --build-arg QUAY_IMAGE_EXPIRY=$(QUAY_IMAGE_EXPIRY) \ --build-arg GIT_SHA=$(GIT_SHA) \ --build-arg DIRTY=$(DIRTY) \ + --build-arg VERSION=v$(VERSION) \ --build-arg QUAY_IMAGE_EXPIRY=$(QUAY_IMAGE_EXPIRY) \ --load \ -t $(IMG) . @@ -442,6 +445,23 @@ bundle-push: ## Push the bundle image. .PHONY: prepare-release prepare-release: ## Prepare the manifests for OLM and Helm Chart for a release. + echo -e "#Release default values\\n\ +AUTHORINO_OPERATOR_VERSION=$(AUTHORINO_OPERATOR_VERSION)\\n\ +AUTHORINO_OPERATOR_BUNDLE_IMG=$(AUTHORINO_OPERATOR_BUNDLE_IMG)\\n\ +LIMITADOR_OPERATOR_VERSION=$(LIMITADOR_OPERATOR_VERSION)\\n\ +LIMITADOR_OPERATOR_BUNDLE_IMG=$(LIMITADOR_OPERATOR_BUNDLE_IMG)\\n\ +DNS_OPERATOR_VERSION=$(DNS_OPERATOR_VERSION)\\n\ +DNS_OPERATOR_BUNDLE_IMG=$(DNS_OPERATOR_BUNDLE_IMG)\\n\ +WASM_SHIM_VERSION=$(WASM_SHIM_VERSION)\\n\ +RELATED_IMAGE_WASMSHIM=$(RELATED_IMAGE_WASMSHIM)\\n\ +RELATED_IMAGE_CONSOLEPLUGIN=$(RELATED_IMAGE_CONSOLEPLUGIN)\\n\ +IMG=$(IMG)\\n\ +BUNDLE_VERSION=$(BUNDLE_VERSION)\\n\ +BUNDLE_IMG=$(BUNDLE_IMG)\\n\ +CATALOG_IMG=$(CATALOG_IMG)\\n\ +CHANNELS=$(CHANNELS)\\n\ +BUNDLE_CHANNELS=--channels=$(CHANNELS)\\n\ +VERSION=$(VERSION)" > $(RELEASE_FILE) $(MAKE) bundle VERSION=$(VERSION) \ AUTHORINO_OPERATOR_VERSION=$(AUTHORINO_OPERATOR_VERSION) \ LIMITADOR_OPERATOR_VERSION=$(LIMITADOR_OPERATOR_VERSION) \ @@ -454,7 +474,17 @@ prepare-release: ## Prepare the manifests for OLM and Helm Chart for a release. DNS_OPERATOR_VERSION=$(DNS_OPERATOR_VERSION) \ WASM_SHIM_VERSION=$(WASM_SHIM_VERSION) \ RELATED_IMAGE_CONSOLEPLUGIN=$(RELATED_IMAGE_CONSOLEPLUGIN) - sed -i -e 's/Version = ".*"/Version = "$(VERSION)"/' $(PROJECT_PATH)/version/version.go + +.PHONY: bundle-operator-image-url +bundle-operator-image-url: $(YQ) ## Read operator image reference URL from the manifest bundle. + @$(YQ) '.metadata.annotations.containerImage' bundle/manifests/kuadrant-operator.clusterserviceversion.yaml + +.PHONY: read-release-version +read-release-version: ## Reads release version + @echo "v$(VERSION)" + +print-bundle-image: ## Pring bundle images. + @echo $(BUNDLE_IMG) ##@ Code Style diff --git a/RELEASE.md b/RELEASE.md index 1a7acd294..2bc591a9f 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -9,6 +9,7 @@ To release a version _“v0.W.Z”_ of Kuadrant Operator in GitHub and Quay.io, * [Limitador Operator](https://github.com/Kuadrant/limitador-operator/blob/main/RELEASE.md). * [DNS Operator](https://github.com/Kuadrant/dns-operator/blob/main/docs/RELEASE.md). * [WASM Shim](https://github.com/Kuadrant/wasm-shim/). + * [Console Plugin](https://github.com/Kuadrant/kuadrant-console-plugin). 2. Run the GHA [Release operator](https://github.com/Kuadrant/kuadrant-operator/actions/workflows/release.yaml); make sure to fill all the fields: @@ -16,19 +17,61 @@ To release a version _“v0.W.Z”_ of Kuadrant Operator in GitHub and Quay.io, * Branch containing the release workflow file – default: `main` * Commit SHA or branch name of the operator to release – usually: `main` * Operator version to release (without prefix) – i.e. `0.W.Z` - * Kuadrant dependencies (WASM Shim, Authorino, Limitador and DNS operators) versions (without prefix) – i.e. `0.X.Y` - * Operator replaced version (without prefix) – i.e. `0.P.Q` + * Kuadrant dependencies (WASM Shim, Console Plugin, Authorino, Limitador and DNS operators) versions (without prefix) – i.e. `0.X.Y` * If the release is a prerelease -3. Run the GHA [Build and push images](https://github.com/Kuadrant/kuadrant-operator/actions/workflows/build-images-base.yaml) - specifying ‘Kuadrant operator version’ and its dependencies equals to the previously released versions _“0.X.Y”_. This will cause the - new images (bundle and catalog included) to be built and pushed to the corresponding repos in - [quay.io/kuadrant](https://quay.io/organization/kuadrant). +3. Verify that the build [release tag workflow](https://github.com/Kuadrant/kuadrant-operator/actions/workflows/build-images-for-tag-release.yaml) is triggered and completes for the new tag. +4. Verify the new version can be installed from the catalog image, see [Verify OLM Deployment](#verify-olm-deployment) -### Publishing the Operator in OpenShift Community Operators -Open a PR in the [OpenShift Community Operators repo](http://github.com/redhat-openshift-ecosystem/community-operators-prod) -([example](https://github.com/redhat-openshift-ecosystem/community-operators-prod/pull/1595) | +5. Release to the [community operator index catalogs](#community-operator-index-catalogs). + +### Verify OLM Deployment + +1. Deploy the OLM catalog image following the [Deploy kuadrant operator using OLM](/doc/development.md#deploy-kuadrant-operator-using-olm) and providing the generated catalog image. For example: +```sh +make deploy-catalog CATALOG_IMG=quay.io/kuadrant/kuadrant-operator-catalog:v1.0.0-rc4 +``` + +2. Wait for deployment: +```sh +kubectl -n kuadrant-system wait --timeout=60s --for=condition=Available deployments --all +``` + +The output should be: + +``` +deployment.apps/authorino-operator condition met +deployment.apps/dns-operator-controller-manager condition met +deployment.apps/kuadrant-operator-controller-manager condition met +deployment.apps/limitador-operator-controller-manager condition met +deployment.apps/kuadrant-operator-controller-manager condition met +``` + +3. Check the logs: +```sh +kubectl -n kuadrant-system logs -f deployment/kuadrant-operator-controller-manager +``` + +4. Check the version of the components deployed: +```sh +kubectl -n kuadrant-system get deployment -o yaml | grep "image:" +``` +The output should be something like: + +``` +image: quay.io/kuadrant/authorino-operator:v0.14.0 +image: quay.io/kuadrant/dns-operator:v0.8.0 +image: quay.io/kuadrant/kuadrant-operator:v1.0.0-rc4 +image: quay.io/kuadrant/limitador-operator:v0.12.0 +``` + +### Community Operator Index Catalogs + +- [Operatorhub Community Operators](https://github.com/k8s-operatorhub/community-operators) +- [Openshift Community Operators](http://github.com/redhat-openshift-ecosystem/community-operators-prod) + +Open a PR on each index catalog ([example](https://github.com/redhat-openshift-ecosystem/community-operators-prod/pull/1595) | [docs](https://redhat-openshift-ecosystem.github.io/community-operators-prod/operator-release-process/)). The usual steps are: @@ -40,12 +83,3 @@ The usual steps are: * Copy the bundle files from `github.com/kuadrant/kuadrant-operator/tree/v0.W.Z/bundle` * Copy `github.com/kuadrant/kuadrant-operator/tree/v0.W.Z/bundle.Dockerfile` with the proper fix to the COPY commands (i.e. remove /bundle from the paths) - -### Publishing the Operator in Kubernetes Community Operators (OperatorHub.io) - -1. Open a PR in the [Kubernetes Community Operators repo](https://github.com/k8s-operatorhub/community-operators) - ([example](https://github.com/k8s-operatorhub/community-operators/pull/1655) | [docs](https://operatorhub.io/contribute)). - -2. The usual steps are the same as for the - [OpenShift Community Operators](https://docs.google.com/document/d/1tLveyv8Zwe0wKyfUTWOlEnFeMB5aVGqIVDUjVYWax0U/edit#heading=h.b5tapxn4sbk5) - hub. diff --git a/main.go b/main.go index 8c7f6a3e9..5fe6b3e73 100644 --- a/main.go +++ b/main.go @@ -48,7 +48,6 @@ import ( kuadrantv1beta1 "github.com/kuadrant/kuadrant-operator/api/v1beta1" "github.com/kuadrant/kuadrant-operator/controllers" "github.com/kuadrant/kuadrant-operator/pkg/log" - "github.com/kuadrant/kuadrant-operator/version" //+kubebuilder:scaffold:imports ) @@ -58,6 +57,7 @@ var ( logMode = env.GetString("LOG_MODE", "production") gitSHA string // value injected in compilation-time dirty string // value injected in compilation-time + version string // value injected in compilation-time ) func init() { @@ -92,7 +92,7 @@ func printControllerMetaInfo() { setupLog.Info(fmt.Sprintf("go version: %s", runtime.Version())) setupLog.Info(fmt.Sprintf("go os/arch: %s/%s", runtime.GOOS, runtime.GOARCH)) setupLog.Info("base logger", "log level", logLevel, "log mode", logMode) - setupLog.Info("build information", "version", version.Version, "commit", gitSHA, "dirty", dirty) + setupLog.Info("build information", "version", version, "commit", gitSHA, "dirty", dirty) } func main() { diff --git a/make/catalog.mk b/make/catalog.mk index 352df8d48..ca6421416 100644 --- a/make/catalog.mk +++ b/make/catalog.mk @@ -25,8 +25,6 @@ $(CATALOG_DOCKERFILE): $(OPM) cd $(PROJECT_PATH)/catalog && $(OPM) generate dockerfile kuadrant-operator-catalog -l quay.expires-after=$(QUAY_IMAGE_EXPIRY) catalog-dockerfile: $(CATALOG_DOCKERFILE) ## Generate catalog dockerfile. -CHANNELS ?= preview - $(CATALOG_FILE): $(OPM) $(YQ) @echo "************************************************************" @echo Build kuadrant operator catalog diff --git a/version/version.go b/version/version.go deleted file mode 100644 index 91e4f8ca2..000000000 --- a/version/version.go +++ /dev/null @@ -1,20 +0,0 @@ -/* -Copyright 2021 Red Hat, Inc. -Licensed 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. -*/ -package version - -var ( - // This variable is dependent on what the current release is e.g. if it is v0.10.0 then this variable, outside of releases, will be v0.10.1-dev . - Version = "v0.12.0-dev" -)