johnandersen777.bsky.social/socialweb-computer-console
console.socialweb.computer: kcp, kubectl and ssh compiled to wasm in a browser tab with a terminal; a kcp fork
0
0
# Copyright 2021 The kcp Authors.
#
# 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.
# We need bash for some conditional logic below.
SHELL := /usr/bin/env bash -e
#-----------------------------------------------------------------------------
# Workaround git issues on OpenShift Prow CI, where the user running in the
# job is not guaranteed to own the repo checkout.
#-----------------------------------------------------------------------------
ifeq ($(CI),true)
$(shell git config --global --add safe.directory '*')
endif
TOOLS_DIR = hack/tools
export UGET_DIRECTORY = $(TOOLS_DIR)
export UGET_CHECKSUMS = hack/tools.checksums
export UGET_VERSIONED_BINARIES = true
ROOT_DIR=$(abspath .)
TOOLS_GOBIN_DIR := $(abspath $(TOOLS_DIR))
GOBIN_DIR=$(abspath ./bin)
PATH := $(GOBIN_DIR):$(TOOLS_GOBIN_DIR):$(PATH)
TMPDIR := $(shell mktemp -d)
KIND_CLUSTER_NAME ?= kind
# Detect the path used for the install target
ifeq (,$(shell go env GOBIN))
INSTALL_GOBIN=$(shell go env GOPATH)/bin
else
INSTALL_GOBIN=$(shell go env GOBIN)
endif
CONTROLLER_GEN_VER := v0.17.3
CONTROLLER_GEN_BIN := controller-gen
CONTROLLER_GEN := $(TOOLS_DIR)/$(CONTROLLER_GEN_BIN)-$(CONTROLLER_GEN_VER)
export CONTROLLER_GEN # so hack scripts can use it
YAML_PATCH_VER ?= v0.0.11
YAML_PATCH_BIN := yaml-patch
YAML_PATCH := $(TOOLS_DIR)/$(YAML_PATCH_BIN)-$(YAML_PATCH_VER)
export YAML_PATCH # so hack scripts can use it
GOLANGCI_LINT_VER := 2.12.2
GOLANGCI_LINT_BIN := golangci-lint
GOLANGCI_LINT := $(TOOLS_GOBIN_DIR)/$(GOLANGCI_LINT_BIN)-$(GOLANGCI_LINT_VER)
GOLANGCI_LINT_FLAGS ?=
GOTESTSUM_VER := 1.12.3
GOTESTSUM_BIN := gotestsum
GOTESTSUM := $(abspath $(TOOLS_DIR))/$(GOTESTSUM_BIN)-$(GOTESTSUM_VER)
LOGCHECK_VER := v0.10.0
LOGCHECK_BIN := logcheck
LOGCHECK := $(TOOLS_GOBIN_DIR)/$(LOGCHECK_BIN)-$(LOGCHECK_VER)
export LOGCHECK # so hack scripts can use it
KCP_APIGEN_BIN := apigen
KCP_APIGEN_GEN := $(TOOLS_DIR)/$(KCP_APIGEN_BIN)
export KCP_APIGEN_GEN # so hack scripts can use it
PROMETHEUS_VER := 3.11.0
PROMETHEUS_BIN := prometheus
PROMETHEUS := $(abspath $(TOOLS_DIR))/$(PROMETHEUS_BIN)-$(PROMETHEUS_VER)
ARCH := $(shell go env GOARCH)
OS := $(shell go env GOOS)
KUBE_MAJOR_VERSION := $(shell go mod edit -json | jq '.Require[] | select(.Path == "k8s.io/kubernetes") | .Version' --raw-output | sed 's/v\([0-9]*\).*/\1/')
KUBE_MINOR_VERSION := $(shell go mod edit -json | jq '.Require[] | select(.Path == "k8s.io/kubernetes") | .Version' --raw-output | sed "s/v[0-9]*\.\([0-9]*\).*/\1/")
GIT_COMMIT := $(shell git rev-parse --short HEAD || echo 'local')
GIT_DIRTY := $(shell git diff --quiet && echo 'clean' || echo 'dirty')
GIT_VERSION := $(shell go mod edit -json | jq '.Require[] | select(.Path == "k8s.io/kubernetes") | .Version' --raw-output)+kcp-$(shell git describe --tags --match='v*' --abbrev=14 "$(GIT_COMMIT)^{commit}" 2>/dev/null || echo v0.0.0-$(GIT_COMMIT))
BUILD_DATE := $(shell date -u +'%Y-%m-%dT%H:%M:%SZ')
EXTRA_LDFLAGS ?=
LDFLAGS := \
-X k8s.io/client-go/pkg/version.gitCommit=${GIT_COMMIT} \
-X k8s.io/client-go/pkg/version.gitTreeState=${GIT_DIRTY} \
-X k8s.io/client-go/pkg/version.gitVersion=${GIT_VERSION} \
-X k8s.io/client-go/pkg/version.gitMajor=${KUBE_MAJOR_VERSION} \
-X k8s.io/client-go/pkg/version.gitMinor=${KUBE_MINOR_VERSION} \
-X k8s.io/client-go/pkg/version.buildDate=${BUILD_DATE} \
\
-X k8s.io/component-base/version.gitCommit=${GIT_COMMIT} \
-X k8s.io/component-base/version.gitTreeState=${GIT_DIRTY} \
-X k8s.io/component-base/version.gitVersion=${GIT_VERSION} \
-X k8s.io/component-base/version.gitMajor=${KUBE_MAJOR_VERSION} \
-X k8s.io/component-base/version.gitMinor=${KUBE_MINOR_VERSION} \
-X k8s.io/component-base/version.buildDate=${BUILD_DATE} \
-extldflags '-static' \
${EXTRA_LDFLAGS}
all: build
.PHONY: all
ldflags:
@echo $(LDFLAGS)
.PHONY: require-%
require-%:
@if ! command -v $* 1> /dev/null 2>&1; then echo "$* not found in ${PATH}"; exit 1; fi
build: WHAT ?= ./cmd/... ./staging/src/github.com/kcp-dev/cli/cmd/... ./staging/src/github.com/kcp-dev/sdk/cmd/...
build: require-jq require-go require-git verify-go-versions ## Build the project
set -x; for W in $(WHAT); do \
pushd . && cd $${W%..}; \
GOOS=$(OS) GOARCH=$(ARCH) CGO_ENABLED=0 go build $(BUILDFLAGS) -ldflags="$(LDFLAGS)" -o $(ROOT_DIR)/bin ./...; \
popd; \
done
.PHONY: build
.PHONY: build-kcp-wasm
build-kcp-wasm: ## Build kcp in its js/wasm build mode (./cmd/kcp) and stage wasm_exec.js
./scripts/build-kcp-wasm.sh
.PHONY: verify-kcp-wasm
verify-kcp-wasm: ## Run the WASM kcp and verify the Fetch CRD with kubectl
./scripts/verify-kcp-wasm.sh
.PHONY: build-kubectl-wasm
build-kubectl-wasm: ## Build upstream kubectl for js/wasm and stage wasm_exec.js
./scripts/build-kubectl-wasm.sh
.PHONY: verify-kubectl-wasm
verify-kubectl-wasm: ## Run kubectl and kcp as separate WASM Deno workers and verify the Fetch CRD
./scripts/verify-kubectl-wasm.sh
.PHONY: build-goat-wasm
build-goat-wasm: ## Build bluesky-social/goat for js/wasm (stock sources + indigo shim)
./scripts/build-goat-wasm.sh
.PHONY: build-yq-wasm
build-yq-wasm: ## Build mikefarah/yq for js/wasm (stock sources)
./scripts/build-yq-wasm.sh
.PHONY: build-sshclient-wasm
build-sshclient-wasm: ## Build the browser SSH client (x/crypto/ssh over WebRTC) for js/wasm
./scripts/build-sshclient-wasm.sh
.PHONY: build-kubectl-wasm-web-public
build-kubectl-wasm-web-public: build-kcp-wasm build-kubectl-wasm build-goat-wasm build-yq-wasm build-sshclient-wasm ## Build ./public: static browser demo bundle
./scripts/build-kubectl-wasm-web-public.sh
.PHONY: run-kubectl-wasm-web
run-kubectl-wasm-web: build-kcp-wasm build-kubectl-wasm build-goat-wasm build-yq-wasm ## Serve the browser demo (kcp, kubectl, goat, yq WASM in the tab)
deno run --allow-read --allow-net ./scripts/kubectl_wasm_web.ts --port=$${WEB_PORT:-8090}
.PHONY: serve-public
serve-public: ## Serve ./public with generated OAuth client metadata (WEB_PORT=8090)
deno run --allow-read --allow-net ./scripts/serve-public.ts --dir=public --port=$${WEB_PORT:-8090}
.PHONY: verify-kubectl-wasm-web
verify-kubectl-wasm-web: ## Verify the kubectl-wasm terminal UI and live Pele diagram
./scripts/verify-kubectl-wasm-web.sh
.PHONY: verify-kcp-memory
verify-kcp-memory: ## Run real kcp on the in-memory storage backend and verify CRDs/CRs
./scripts/verify-kcp-memory.sh
.PHONY: build-kcp-real-wasm
build-kcp-real-wasm: ## Build the real kcp server for js/wasm (experimental)
./scripts/build-kcp-real-wasm.sh
.PHONY: sync-socialweb-manifests
sync-socialweb-manifests: ## Sync the browser-provider deploy manifests into socialweb-wasm/manifests
./scripts/sync-socialweb-manifests.sh
.PHONY: build-socialweb-kcp-wasm
build-socialweb-kcp-wasm: ## Build the combined real-kcp + socialweb js/wasm module
./scripts/build-socialweb-kcp-wasm.sh
.PHONY: dev-socialweb
dev-socialweb: ## Boot the combined module under Deno with warm state (PORT=18080)
./scripts/dev-socialweb.sh
.PHONY: build-e2e
build-e2e:
@$(MAKE) build WHAT='./cmd/... ./staging/src/github.com/kcp-dev/cli/cmd/...'
install: WHAT ?= ./cmd/... ./staging/src/github.com/kcp-dev/cli/cmd/... ./staging/src/github.com/kcp-dev/sdk/cmd/...
install: require-jq require-go require-git verify-go-versions ## Install the project
set -x; for W in $(WHAT); do \
pushd . && cd $${W%..}; \
GOOS=$(OS) GOARCH=$(ARCH) CGO_ENABLED=0 go install -ldflags="$(LDFLAGS)" ./...; \
popd; \
done
.PHONY: install
$(GOLANGCI_LINT):
@hack/uget.sh \
https://github.com/golangci/golangci-lint/releases/download/v{VERSION}/golangci-lint-{VERSION}-{GOOS}-{GOARCH}.tar.gz \
${GOLANGCI_LINT_BIN} \
${GOLANGCI_LINT_VER}
# help staging modules to install the same linter version
golangci-lint-version:
@echo $(GOLANGCI_LINT_VER)
.PHONY: golangci-lint-version
.PHONY: prometheus
prometheus: $(PROMETHEUS)
$(PROMETHEUS):
@hack/uget.sh \
https://github.com/prometheus/prometheus/releases/download/v{VERSION}/prometheus-{VERSION}.{GOOS}-{GOARCH}.tar.gz \
${PROMETHEUS_BIN} \
${PROMETHEUS_VER}
$(LOGCHECK):
@GO_MODULE=true hack/uget.sh \
sigs.k8s.io/logtools/logcheck \
${LOGCHECK_BIN} \
$(LOGCHECK_VER)
.PHONY: $(KCP_APIGEN_GEN)
$(KCP_APIGEN_GEN):
pushd . && cd staging/src/github.com/kcp-dev/sdk && GOBIN=$(TOOLS_GOBIN_DIR) go install ./cmd/apigen && popd
lint: $(GOLANGCI_LINT) $(LOGCHECK) ## Verify lint
echo "Linting root module..."; \
$(GOLANGCI_LINT) run $(GOLANGCI_LINT_FLAGS) -c $(ROOT_DIR)/.golangci.yaml --timeout 20m
for MOD in $$(git ls-files '**/go.mod' | sed 's,/go.mod,,'); do \
if [ "$$MOD" != "." ]; then \
echo "Linting $$MOD module..."; \
(cd $$MOD && $(GOLANGCI_LINT) run $(GOLANGCI_LINT_FLAGS) -c $(ROOT_DIR)/.golangci.yaml --timeout 20m); \
fi; \
done
./hack/verify-contextual-logging.sh
.PHONY: lint
fix-lint: $(GOLANGCI_LINT)
GOLANGCI_LINT_FLAGS="--fix" $(MAKE) lint
.PHONY: fix-lint
update-contextual-logging: $(LOGCHECK) ## Update contextual logging
UPDATE=true ./hack/verify-contextual-logging.sh
.PHONY: update-contextual-logging
.PHONY: generate-cli-docs
generate-cli-docs: ## Generate cli docs
git clean -fdX docs/content/reference/cli
cd ./docs/generators/cli-doc && go run . -output ../../content/reference/cli
.PHONY: generate-api-docs
generate-api-docs: ## Generate api docs
git clean -fdX docs/content/reference/crd
docs/generators/crd-ref/run-crd-ref-gen.sh
VENVDIR=$(abspath docs/venv)
REQUIREMENTS_TXT=docs/requirements.txt
.PHONY: local-docs
local-docs: venv ## Run mkdocs serve
. $(VENV)/activate; \
VENV=$(VENV) cd docs && mkdocs serve
.PHONY: serve-docs
serve-docs: venv ## Serve docs
. $(VENV)/activate; \
VENV=$(VENV) REMOTE=$(REMOTE) BRANCH=$(BRANCH) docs/scripts/serve-docs.sh
.PHONY: deploy-docs
deploy-docs: venv ## Deploy docs
. $(VENV)/activate; \
REMOTE=$(REMOTE) BRANCH=$(BRANCH) docs/scripts/deploy-docs.sh
vendor: ## Vendor the dependencies
go mod tidy
go mod vendor
.PHONY: vendor
tools: $(GOLANGCI_LINT) $(CONTROLLER_GEN) $(KCP_APIGEN_GEN) $(YAML_PATCH) $(GOTESTSUM) ## Install tools
.PHONY: tools
$(CONTROLLER_GEN):
@UNCOMPRESSED=true hack/uget.sh https://github.com/kubernetes-sigs/controller-tools/releases/download/{VERSION}/controller-gen-{GOOS}-{GOARCH} ${CONTROLLER_GEN_BIN} $(CONTROLLER_GEN_VER) controller-gen*
$(YAML_PATCH):
@GO_MODULE=true hack/uget.sh github.com/pivotal-cf/yaml-patch/cmd/yaml-patch $(YAML_PATCH_BIN) $(YAML_PATCH_VER)
$(GOTESTSUM):
@hack/uget.sh \
https://github.com/gotestyourself/gotestsum/releases/download/v{VERSION}/gotestsum_{VERSION}_{GOOS}_{GOARCH}.tar.gz \
${GOTESTSUM_BIN} \
${GOTESTSUM_VER} \
${GOTESTSUM_BIN}
crds: $(CONTROLLER_GEN) $(YAML_PATCH) ## Generate crds
./hack/update-codegen-crds.sh
.PHONY: crds
.PHONY: client-go-codegen
client-go-codegen: ## Generate client-go code
$(MAKE) -C staging/src/github.com/kcp-dev/client-go codegen
.PHONY: client-go-verify-codegen
client-go-verify-codegen: ## Verify client-go generated code
$(MAKE) -C staging/src/github.com/kcp-dev/client-go verify-codegen
.PHONY: code-generator-codegen
code-generator-codegen: ## Generate code-generator code
$(MAKE) -C staging/src/github.com/kcp-dev/code-generator codegen
.PHONY: code-generator-verify-codegen
code-generator-verify-codegen: ## Verify code-generator generated code
$(MAKE) -C staging/src/github.com/kcp-dev/code-generator verify-codegen
codegen: $(KCP_APIGEN_GEN) client-go-codegen code-generator-codegen crds ## Generate all
go mod download
./hack/update-codegen-clients.sh
./hack/gen-patch-defaultrestmapper.sh
$(MAKE) imports
.PHONY: codegen
# Note, running this locally if you have any modified files, even those that are not generated,
# will result in an error. This target is mostly for CI jobs.
.PHONY: verify-codegen
verify-codegen: client-go-verify-codegen code-generator-verify-codegen ## Verify codegen
if [[ -n "${GITHUB_WORKSPACE}" ]]; then \
mkdir -p $$(go env GOPATH)/src/github.com/kcp-dev; \
ln -s ${GITHUB_WORKSPACE} $$(go env GOPATH)/src/github.com/kcp-dev/kcp; \
fi
$(MAKE) codegen
if ! git diff --quiet HEAD; then \
git diff; \
echo "You need to run 'make codegen' to update generated files and commit them"; \
exit 1; \
fi
./hack/verify-apiresourceschemas.sh
.PHONY: imports
imports: WHAT ?=
imports: $(GOLANGCI_LINT) verify-go-versions
if [ -n "$(WHAT)" ]; then \
$(GOLANGCI_LINT) fmt --enable gci -c $(ROOT_DIR)/.golangci.yaml $(WHAT); \
else \
for MOD in . $$(git ls-files '**/go.mod' | sed 's,/go.mod,,'); do \
(set -x; cd $$MOD; $(GOLANGCI_LINT) fmt --enable gci -c $(ROOT_DIR)/.golangci.yaml); \
done; \
fi
BOILERPLATE_MODIFIED_FILES ?= $(abspath ./hack/boilerplate/boilerplate_modified/files.txt)
BOILERPLATE_KUBERNETES_FILES := $(abspath ./hack/boilerplate/boilerplate_kubernetes/files.txt)
.PHONY: verify-boilerplate
verify-boilerplate: ## Verify boilerplate
hack/verify_boilerplate.py --boilerplate-dir=hack/boilerplate --skip hack/uget.sh --skip docs/venv --skip pkg/network/dialer --skip-files-list $(BOILERPLATE_MODIFIED_FILES) --skip-files-list $(BOILERPLATE_KUBERNETES_FILES)
hack/verify_boilerplate.py --boilerplate-dir=hack/boilerplate/boilerplate_modified --filenames-list $(BOILERPLATE_MODIFIED_FILES)
hack/verify_boilerplate.py --boilerplate-dir=hack/boilerplate/boilerplate_kubernetes --filenames-list $(BOILERPLATE_KUBERNETES_FILES)
ifdef ARTIFACT_DIR
GOTESTSUM_ARGS += --junitfile=$(ARTIFACT_DIR)/junit.xml
endif
GO_TEST = go test
ifdef USE_GOTESTSUM
GO_TEST = $(GOTESTSUM) $(GOTESTSUM_ARGS) --
endif
COUNT ?=
COUNT_ARG =
ifdef COUNT
COUNT_ARG = -count $(COUNT)
endif
E2E_PARALLELISM ?=
ifdef E2E_PARALLELISM
PARALLELISM_ARG = -p $(E2E_PARALLELISM) -parallel $(E2E_PARALLELISM)
endif
SUITES ?=
SUITES_ARG =
COMPLETE_SUITES_ARG =
ifdef SUITES
SUITES_ARG = --suites $(SUITES)
COMPLETE_SUITES_ARG = -args $(SUITES_ARG)
endif
TEST_FEATURE_GATES ?= WorkspaceMounts=true,CacheAPIs=true,WorkspaceAuthentication=true,LogicalClusterMigration=true
PROXY_FEATURE_GATES ?= $(TEST_FEATURE_GATES)
.PHONY: test-e2e
ifdef USE_GOTESTSUM
test-e2e: $(GOTESTSUM)
endif
test-e2e: TEST_ARGS ?=
test-e2e: WHAT ?= ./test/e2e...
test-e2e: build-e2e ## Run e2e tests
UNSAFE_E2E_HACK_DISABLE_ETCD_FSYNC=true NO_GORUN=1 GOOS=$(OS) GOARCH=$(ARCH) \
$(GO_TEST) -race $(COUNT_ARG) $(PARALLELISM_ARG) $(WHAT) $(TEST_ARGS) $(COMPLETE_SUITES_ARG)
.PHONY: test-e2e-shared-minimal
ifdef USE_GOTESTSUM
test-e2e-shared-minimal: $(GOTESTSUM)
endif
test-e2e-shared-minimal: TEST_ARGS ?=
test-e2e-shared-minimal: WHAT ?= ./test/e2e...
test-e2e-shared-minimal: WORK_DIR ?= $(PWD)
ifdef ARTIFACT_DIR
test-e2e-shared-minimal: LOG_DIR ?= $(ARTIFACT_DIR)/kcp
else
test-e2e-shared-minimal: LOG_DIR ?= $(WORK_DIR)/.kcp
endif
test-e2e-shared-minimal: build-e2e
mkdir -p "$(LOG_DIR)" "$(WORK_DIR)/.kcp"
rm -f "$(WORK_DIR)/.kcp/ready-to-test"
UNSAFE_E2E_HACK_DISABLE_ETCD_FSYNC=true NO_GORUN=1 \
./bin/test-server --quiet --work-dir-path="$(WORK_DIR)" --log-dir-path="$(LOG_DIR)" $(TEST_SERVER_ARGS) -- --feature-gates=$(TEST_FEATURE_GATES) 2>&1 & PID=$$! && echo "PID $$PID" && \
trap 'kill -TERM $$PID && wait $$PID' TERM INT EXIT && \
while [ ! -f "$(WORK_DIR)/.kcp/ready-to-test" ]; do sleep 1; done && \
echo 'Starting test(s)' && \
NO_GORUN=1 GOOS=$(OS) GOARCH=$(ARCH) \
$(GO_TEST) -race $(COUNT_ARG) $(PARALLELISM_ARG) $(WHAT) $(TEST_ARGS) \
-args --kcp-kubeconfig=$(WORK_DIR)/.kcp/admin.kubeconfig $(SUITES_ARG) \
$(if $(value WAIT),|| { echo "Terminated with $$?"; wait "$$PID"; },)
.PHONY: test-e2e-sharded-minimal
ifdef USE_GOTESTSUM
test-e2e-sharded-minimal: $(GOTESTSUM)
endif
test-e2e-sharded-minimal: TEST_ARGS ?=
test-e2e-sharded-minimal: WHAT ?= ./test/e2e...
test-e2e-sharded-minimal: WORK_DIR ?= $(PWD)
test-e2e-sharded-minimal: SHARDS ?= 2
ifdef ARTIFACT_DIR
test-e2e-sharded-minimal: LOG_DIR ?= $(ARTIFACT_DIR)/kcp
else
test-e2e-sharded-minimal: LOG_DIR ?= $(WORK_DIR)/.kcp
endif
test-e2e-sharded-minimal: build-e2e
mkdir -p "$(LOG_DIR)" "$(WORK_DIR)/.kcp"
rm -f "$(WORK_DIR)/.kcp/ready-to-test"
UNSAFE_E2E_HACK_DISABLE_ETCD_FSYNC=true NO_GORUN=1 ./bin/sharded-test-server --quiet --v=2 --log-dir-path="$(LOG_DIR)" --work-dir-path="$(WORK_DIR)" --shard-run-virtual-workspaces=false --shard-feature-gates=$(TEST_FEATURE_GATES) --proxy-feature-gates=$(PROXY_FEATURE_GATES) $(TEST_SERVER_ARGS) --number-of-shards=$(SHARDS) 2>&1 & PID=$$!; echo "PID $$PID" && \
trap 'kill -TERM $$PID && wait $$PID' TERM INT EXIT && \
while [ ! -f "$(WORK_DIR)/.kcp/ready-to-test" ]; do sleep 1; done && \
echo 'Starting test(s)' && \
NO_GORUN=1 GOOS=$(OS) GOARCH=$(ARCH) $(GO_TEST) -race $(COUNT_ARG) $(PARALLELISM_ARG) $(WHAT) $(TEST_ARGS) \
-args --kcp-kubeconfig=$(WORK_DIR)/.kcp/admin.kubeconfig --shard-kubeconfigs=root=$(WORK_DIR)/.kcp-0/admin.kubeconfig$(shell if [ $(SHARDS) -gt 1 ]; then seq 1 $$[$(SHARDS) - 1]; fi | while read n; do echo -n ",shard-$$n=$(WORK_DIR)/.kcp-$$n/admin.kubeconfig"; done) \
$(SUITES_ARG) \
$(if $(value WAIT),|| { echo "Terminated with $$?"; wait "$$PID"; },)
# Runs the controller-runtime test module (test/controller-runtime, a separate Go
# module so sigs.k8s.io/controller-runtime stays out of the root go.mod) against a
# freshly brought-up 2-shard server. Mirrors test-e2e-sharded-minimal; only the
# final `go test` differs (it runs inside the submodule). WORK_DIR is absolute
# ($(PWD)), so the kubeconfig paths remain valid after cd-ing into the module.
.PHONY: test-e2e-sharded-controller-runtime
ifdef USE_GOTESTSUM
test-e2e-sharded-controller-runtime: $(GOTESTSUM)
endif
test-e2e-sharded-controller-runtime: TEST_ARGS ?=
test-e2e-sharded-controller-runtime: WORK_DIR ?= $(PWD)
test-e2e-sharded-controller-runtime: SHARDS ?= 2
ifdef ARTIFACT_DIR
test-e2e-sharded-controller-runtime: LOG_DIR ?= $(ARTIFACT_DIR)/kcp
else
test-e2e-sharded-controller-runtime: LOG_DIR ?= $(WORK_DIR)/.kcp
endif
test-e2e-sharded-controller-runtime: build-e2e
mkdir -p "$(LOG_DIR)" "$(WORK_DIR)/.kcp"
rm -f "$(WORK_DIR)/.kcp/ready-to-test"
UNSAFE_E2E_HACK_DISABLE_ETCD_FSYNC=true NO_GORUN=1 ./bin/sharded-test-server --quiet --v=2 --log-dir-path="$(LOG_DIR)" --work-dir-path="$(WORK_DIR)" --shard-run-virtual-workspaces=false --shard-feature-gates=$(TEST_FEATURE_GATES) --proxy-feature-gates=$(PROXY_FEATURE_GATES) $(TEST_SERVER_ARGS) --number-of-shards=$(SHARDS) 2>&1 & PID=$$!; echo "PID $$PID" && \
trap 'kill -TERM $$PID && wait $$PID' TERM INT EXIT && \
while [ ! -f "$(WORK_DIR)/.kcp/ready-to-test" ]; do sleep 1; done && \
echo 'Starting test(s)' && \
cd $(ROOT_DIR)/test/controller-runtime && NO_GORUN=1 GOOS=$(OS) GOARCH=$(ARCH) $(GO_TEST) -race $(COUNT_ARG) $(PARALLELISM_ARG) ./... $(TEST_ARGS) \
-args --kcp-kubeconfig=$(WORK_DIR)/.kcp/admin.kubeconfig --shard-kubeconfigs=root=$(WORK_DIR)/.kcp-0/admin.kubeconfig$(shell if [ $(SHARDS) -gt 1 ]; then seq 1 $$[$(SHARDS) - 1]; fi | while read n; do echo -n ",shard-$$n=$(WORK_DIR)/.kcp-$$n/admin.kubeconfig"; done) \
$(SUITES_ARG) \
$(if $(value WAIT),|| { echo "Terminated with $$?"; wait "$$PID"; },)
# Same as test-e2e-sharded-minimal, but each shard runs its own embedded virtual
# workspace server (--shard-run-virtual-workspaces=true) instead of a single
# standalone VW server in front of all shards. This matches deployments where the
# APIExport virtual workspaces are served per-shard, and exercises cross-shard
# behaviour (e.g. permission-claimed resources whose objects live on a different
# shard than the consuming APIExport).
.PHONY: test-e2e-sharded-embedded-vw
ifdef USE_GOTESTSUM
test-e2e-sharded-embedded-vw: $(GOTESTSUM)
endif
test-e2e-sharded-embedded-vw: TEST_ARGS ?=
test-e2e-sharded-embedded-vw: WHAT ?= ./test/e2e...
test-e2e-sharded-embedded-vw: WORK_DIR ?= $(PWD)
test-e2e-sharded-embedded-vw: SHARDS ?= 2
ifdef ARTIFACT_DIR
test-e2e-sharded-embedded-vw: LOG_DIR ?= $(ARTIFACT_DIR)/kcp
else
test-e2e-sharded-embedded-vw: LOG_DIR ?= $(WORK_DIR)/.kcp
endif
test-e2e-sharded-embedded-vw: build-e2e
mkdir -p "$(LOG_DIR)" "$(WORK_DIR)/.kcp"
rm -f "$(WORK_DIR)/.kcp/ready-to-test"
UNSAFE_E2E_HACK_DISABLE_ETCD_FSYNC=true NO_GORUN=1 ./bin/sharded-test-server --quiet --v=2 --log-dir-path="$(LOG_DIR)" --work-dir-path="$(WORK_DIR)" --shard-run-virtual-workspaces=true --shard-feature-gates=$(TEST_FEATURE_GATES) --proxy-feature-gates=$(PROXY_FEATURE_GATES) $(TEST_SERVER_ARGS) --number-of-shards=$(SHARDS) 2>&1 & PID=$$!; echo "PID $$PID" && \
trap 'kill -TERM $$PID && wait $$PID' TERM INT EXIT && \
while [ ! -f "$(WORK_DIR)/.kcp/ready-to-test" ]; do sleep 1; done && \
echo 'Starting test(s)' && \
NO_GORUN=1 GOOS=$(OS) GOARCH=$(ARCH) $(GO_TEST) -race $(COUNT_ARG) $(PARALLELISM_ARG) $(WHAT) $(TEST_ARGS) \
-args --kcp-kubeconfig=$(WORK_DIR)/.kcp/admin.kubeconfig --shard-kubeconfigs=root=$(WORK_DIR)/.kcp-0/admin.kubeconfig$(shell if [ $(SHARDS) -gt 1 ]; then seq 1 $$[$(SHARDS) - 1]; fi | while read n; do echo -n ",shard-$$n=$(WORK_DIR)/.kcp-$$n/admin.kubeconfig"; done) \
$(SUITES_ARG) \
$(if $(value WAIT),|| { echo "Terminated with $$?"; wait "$$PID"; },)
# This is just easy target to run 2 shard test server locally until manually killed.
# You can target test to it by running:
# go test ./test/e2e/apibinding/... --kcp-kubeconfig=$(pwd)/.kcp/admin.kubeconfig --shard-kubeconfigs=root=$(pwd)/.kcp-0/admin.kubeconfig --shard-kubeconfigs=shard-1=$(pwd)/.kcp-1/admin.kubeconfig -run=^TestAPIBinding$
test-run-sharded-server: WORK_DIR ?= $(PWD)
test-run-sharded-server: LOG_DIR ?= $(WORK_DIR)/.kcp
test-run-sharded-server:
mkdir -p "$(LOG_DIR)" "$(WORK_DIR)/.kcp"
rm -f "$(WORK_DIR)/.kcp/ready-to-test"
UNSAFE_E2E_HACK_DISABLE_ETCD_FSYNC=true NO_GORUN=1 ./bin/sharded-test-server --quiet --v=2 --log-dir-path="$(LOG_DIR)" --work-dir-path="$(WORK_DIR)" --shard-run-virtual-workspaces=false --shard-feature-gates=$(TEST_FEATURE_GATES) --proxy-feature-gates=$(PROXY_FEATURE_GATES) $(TEST_SERVER_ARGS) --number-of-shards=2 2>&1 & PID=$$!; echo "PID $$PID" && \
trap 'kill -TERM $$PID && wait $$PID' TERM INT EXIT && \
while [ ! -f "$(WORK_DIR)/.kcp/ready-to-test" ]; do sleep 1; done && \
echo 'Server started' && \
wait $$PID
# Verifies the upgrade path: starts the previous kcp release, seeds it with
# data, restarts the same root directory with the current tree's binary and
# asserts the data survived and the server is functional. Set
# UPGRADE_FROM_VERSION to test a specific release (default: latest), and
# KCP_UPGRADE_E2E_PACKAGES to additionally run e2e packages against the
# upgraded server, e.g. KCP_UPGRADE_E2E_PACKAGES="./test/e2e/apibinding/...".
.PHONY: test-upgrade
ifdef USE_GOTESTSUM
test-upgrade: $(GOTESTSUM)
endif
test-upgrade: TEST_ARGS ?=
test-upgrade: UPGRADE_FROM_VERSION ?= latest
test-upgrade: WHAT ?= ./test/upgrade/...
test-upgrade: build ## Run upgrade tests (previous release -> current tree)
hack/download-kcp-release.sh $(UPGRADE_FROM_VERSION) bin/upgrade-from
UNSAFE_E2E_HACK_DISABLE_ETCD_FSYNC=true \
KCP_UPGRADE_FROM_BINARY=$(ROOT_DIR)/bin/upgrade-from/current/kcp \
KCP_UPGRADE_TO_BINARY=$(ROOT_DIR)/bin/kcp \
$(GO_TEST) -race $(COUNT_ARG) $(WHAT) -timeout 30m $(TEST_ARGS)
.PHONY: test
ifdef USE_GOTESTSUM
test: $(GOTESTSUM)
endif
test: WHAT ?= ./...
# We will need to move into the sub package, of sdk to run those tests.
test: ## Run tests
$(GO_TEST) -race $(COUNT_ARG) -coverprofile=coverage.txt -covermode=atomic $(TEST_ARGS) $$(go list "$(WHAT)" | grep -v -e 'test/e2e' -e 'test/integration')
for MOD in $$(git ls-files '**/go.mod' | sed 's,/go.mod,,'); do \
if [ "$$MOD" != "." ] && [ "$$MOD" != "test/controller-runtime" ]; then \
echo "Testing $$MOD module..."; \
(cd $$MOD && $(GO_TEST) -race $(COUNT_ARG) -coverprofile=coverage.txt -covermode=atomic $(TEST_ARGS) $$(go list "$(WHAT)" | grep -v 'test/load/testing')); \
fi; \
done
.PHONY: test-integration
ifdef USE_GOTESTSUM
test-integration: $(GOTESTSUM)
endif
test-integration: WHAT ?= ./test/integration...
test-integration: ## Run integration tests
$(GO_TEST) $(COUNT_ARG) $(PARALLELISM_ARG) $(WHAT) $(TEST_ARGS)
.PHONY: verify-k8s-deps
verify-k8s-deps: ## Verify kubernetes deps
hack/validate-k8s.sh
.PHONY: verify-imports
verify-imports: ## Verify imports
hack/verify-imports.sh
.PHONY: verify-go-versions
verify-go-versions: ## Verify go versions
hack/verify-go-versions.sh
.PHONY: modules
modules: ## Run go mod tidy to ensure modules are up to date
hack/update-go-modules.sh
.PHONY: verify-modules
verify-modules: modules ## Verify go modules are up to date
hack/verify-go-modules.sh
.PHONY: verify
verify: verify-boilerplate verify-codegen verify-imports verify-go-versions verify-modules verify-k8s-deps ## Run all verify checks
.PHONY: clean
clean: clean-workdir ## Clean all
rm -fr $(TOOLS_DIR)
rm -f $(GOBIN_DIR)/*
.PHONY: clean-workdir
clean-workdir: WORK_DIR ?= $(PWD)
clean-workdir: ## Clean workdir
rm -fr $(WORK_DIR)/.kcp*
.PHONY: download-e2e-logs
download-e2e-logs: ## Download e2e logs from a given URL
OUT=$(OUT) URL=$(URL) hack/download-e2e-logs.sh
.PHONY: tilt-kind-up
tilt-kind-up:
./contrib/tilt/kind.sh
.PHONY: tilt-kind-up-static
tilt-kind-up-static:
./contrib/tilt/kind-static.sh
.PHONY: help
help: ## Show this help
@grep -hE '^[a-zA-Z0-9_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
include Makefile.venv