Add Makefile scale test targets; drop demo worker sample

scale-load, scale-observe, and scale-load-clear drive Redis backlog via
kubectl exec into deploy/redis

Author: alesr

.custom-gcl.yml

@@ -0,0 +1,5 @@
+version: v2.11.4
+plugins:
+  - module: "sigs.k8s.io/logtools"
+    import: "sigs.k8s.io/logtools/logcheck/gclplugin"
+    version: v0.10.1

Makefile

@@ -1,23 +1,15 @@
-# Image URL to use all building/pushing image targets
 IMG ?= controller:latest
-# YEAR defines the year value used for substituting the YEAR placeholder in the boilerplate header.
+
 YEAR ?= $(shell date +%Y)
 
-# Get the currently used golang install path (in GOPATH/bin, unless GOBIN is set)
 ifeq (,$(shell go env GOBIN))
 GOBIN=$(shell go env GOPATH)/bin
 else
 GOBIN=$(shell go env GOBIN)
 endif
 
-# CONTAINER_TOOL defines the container tool to be used for building images.
-# Be aware that the target commands are only tested with Docker which is
-# scaffolded by default. However, you might want to replace it to use other
-# tools. (i.e. podman)
 CONTAINER_TOOL ?= docker
 
-# Setting SHELL to bash allows bash commands to be executed by recipes.
-# Options are set to exit when a recipe line exits non-zero or a piped command fails.
 SHELL = /usr/bin/env bash -o pipefail
 .SHELLFLAGS = -ec
 
@@ -48,7 +40,7 @@ vet: ## Run go vet against code.
 
 .PHONY: test
 test: manifests generate fmt vet setup-envtest ## Run tests.
-	KUBEBUILDER_ASSETS="$(shell "$(ENVTEST)" use $(ENVTEST_K8S_VERSION) --bin-dir "$(LOCALBIN)" -p path)" go test ./... -coverprofile cover.out
+	KUBEBUILDER_ASSETS="$(shell "$(ENVTEST)" use $(ENVTEST_K8S_VERSION) --bin-dir "$(LOCALBIN)" -p path)" go test ./... -v -race -coverprofile cover.out
 
 .PHONY: lint
 lint: golangci-lint ## Run golangci-lint linter
@@ -153,6 +145,38 @@ deploy-rbpi: ## Build arm64 image, import on rbpi, deploy (set KUBECONFIG).
 	$(MAKE) rbpi-verify
 	@echo "Revert image pin: git checkout -- config/manager/kustomization.yaml"
 
+##@ scale test
+
+LOAD_NS ?= default
+LOAD_REDIS_DEPLOY ?= redis
+LOAD_STREAM ?= events
+LOAD_GROUP ?= workers
+LOAD_COUNT ?= 80
+LOAD_DEPLOY ?= worker-deployment
+LOAD_SCALER ?= redisstreamscaler-sample
+
+LOAD_REDIS_EXEC = $(KUBECTL) exec -n $(LOAD_NS) deploy/$(LOAD_REDIS_DEPLOY) -- redis-cli
+
+.PHONY: scale-load
+scale-load: ## XADD messages on LOAD_STREAM (Redis deploy + RedisStreamScaler required).
+	$(LOAD_REDIS_EXEC) XGROUP CREATE $(LOAD_STREAM) $(LOAD_GROUP) $$ MKSTREAM 2>/dev/null || true
+	@for i in $$(seq 1 $(LOAD_COUNT)); do \
+		$(LOAD_REDIS_EXEC) XADD $(LOAD_STREAM) '*' payload $$i >/dev/null; \
+	done
+	@echo "Added $(LOAD_COUNT) messages to $(LOAD_STREAM). Run: make scale-observe"
+
+.PHONY: scale-observe
+scale-observe: ## Watch deployment replicas and RedisStreamScaler status (Ctrl+C to stop).
+	watch -n 2 -- \
+		"$(KUBECTL) get deploy $(LOAD_DEPLOY) -n $(LOAD_NS); \
+		echo; \
+		$(KUBECTL) get redisstreamscaler $(LOAD_SCALER) -n $(LOAD_NS) -o custom-columns=NAME:.metadata.name,BACKLOG:.status.currentBacklog,REPLICAS:.status.currentReplicas,READY:.status.conditions[?(@.type==\"Available\")].status"
+
+.PHONY: scale-load-clear
+scale-load-clear: ## XTRIM stream empty; scale-down may wait for cooldownPeriod.
+	$(LOAD_REDIS_EXEC) XTRIM $(LOAD_STREAM) MAXLEN 0
+	@echo "Cleared $(LOAD_STREAM). Scale-down may wait for cooldownPeriod on the CR."
+
 ##@ Dependencies
 
 ## Location to install dependencies to
@@ -207,13 +231,11 @@ $(ENVTEST): $(LOCALBIN)
 
 .PHONY: golangci-lint
 golangci-lint: $(GOLANGCI_LINT) ## Download golangci-lint locally if necessary.
-$(GOLANGCI_LINT): $(LOCALBIN)
+$(GOLANGCI_LINT): $(LOCALBIN) .custom-gcl.yml
 	$(call go-install-tool,$(GOLANGCI_LINT),github.com/golangci/golangci-lint/v2/cmd/golangci-lint,$(GOLANGCI_LINT_VERSION))
-	@test -f .custom-gcl.yml && { \
-		echo "Building custom golangci-lint with plugins..." && \
-		$(GOLANGCI_LINT) custom --destination $(LOCALBIN) --name golangci-lint-custom && \
-		mv -f $(LOCALBIN)/golangci-lint-custom $(GOLANGCI_LINT); \
-	} || true
+	@echo "Building custom golangci-lint with plugins..."
+	$(GOLANGCI_LINT) custom --destination $(LOCALBIN) --name golangci-lint-custom
+	mv -f $(LOCALBIN)/golangci-lint-custom $(GOLANGCI_LINT)
 
 # go-install-tool will 'go install' any package with custom target and name of binary, if it doesn't exist
 # $1 - target path with name of binary

README.md

@@ -49,6 +49,16 @@ make deploy-rbpi
 
 Details: [docs/deploy.md](docs/deploy.md).
 
+## Scale test
+
+With operator, Redis, worker Deployment, and the sample CR applied:
+
+```bash
+make scale-load
+make scale-observe
+make scale-load-clear
+```
+
 ## RedisStreamScaler example
 
 ```yaml

cmd/main.go

@@ -181,7 +181,7 @@ func main() {
 	if err := (&controller.RedisStreamScalerReconciler{
 		Client:   mgr.GetClient(),
 		Scheme:   mgr.GetScheme(),
-		Recorder: mgr.GetEventRecorderFor("redisstreamscaler-controller"),
+		Recorder: mgr.GetEventRecorderFor("redisstreamscaler-controller"), //nolint:staticcheck,lll
 	}).SetupWithManager(mgr); err != nil {
 		setupLog.Error(err, "Failed to create controller", "controller", "redisstreamscaler")
 		os.Exit(1)

config/samples/kustomization.yaml

@@ -1,4 +1,3 @@
 ## Example manifests (not installed by make deploy)
 resources:
 - autoscaling_v1alpha1_redisstreamscaler.yaml
-# - worker-deployment.yaml

config/samples/worker-deployment.yaml

@@ -54,16 +54,23 @@ git checkout -- config/manager/kustomization.yaml
 make undeploy
 ```
 
-## Demo workload
+## Scale test
 
-Use the Redis FQDN when the operator runs in `k8s-redis-workload-scaler-system`:
+Apply the sample CR and your worker Deployment (name must match `scaleTargetRef` in the CR, default `worker-deployment`):
 
 ```bash
-kubectl apply -f config/samples/worker-deployment.yaml
 kubectl apply -f config/samples/autoscaling_v1alpha1_redisstreamscaler.yaml
 ```
 
-Load: `XADD` on stream `events` (group `workers`). Trim: `XTRIM events MAXLEN 0` to scale down after cooldown.
+Redis must be reachable at the address in the CR (e.g. `redis.default.svc.cluster.local:6379`). Makefile targets exec into `deploy/redis` in `default`:
+
+```bash
+make scale-load          # XADD backlog on stream events / group workers
+make scale-observe       # watch replicas + scaler status (Ctrl+C to stop)
+make scale-load-clear    # XTRIM stream; scale-down waits for cooldownPeriod
+```
+
+Override defaults if needed: `LOAD_NS`, `LOAD_REDIS_DEPLOY`, `LOAD_STREAM`, `LOAD_GROUP`, `LOAD_COUNT`, `LOAD_DEPLOY`, `LOAD_SCALER`.
 
 ## GitHub Actions
 
@@ -75,5 +82,5 @@ Push to `main` builds an arm64 image on GHCR and runs `make deploy` on rbpi via
 |---------|-----|
 | `Degraded` / `no such host` for `redis` | `redis.<namespace>.svc.cluster.local:6379` |
 | Manager `ImagePullBackOff` | Image must be arm64 and present on rbpi (local import or GHCR pull) |
-| Worker `ImagePullBackOff` | Use a real image (sample: `busybox:1.36`) |
+| Worker `ImagePullBackOff` | Fix your worker Deployment image |
 | SSH import fails | Check `Host rbpi` in `~/.ssh/config` or set `RBPI_SSH_KEY` |

docs/deploy.md

@@ -99,15 +99,15 @@ func (p *redisClientPool) get(cfg redisConnConfig) *redis.Client {
 	p.mu.Lock()
 	defer p.mu.Unlock()
 
-	if client, ok := p.clients[key]; ok {
-		return client
+	if c, ok := p.clients[key]; ok {
+		return c
 	}
 
 	opts := &redis.Options{Addr: cfg.addr}
 	if cfg.password != "" {
 		opts.Password = cfg.password
 	}
-	client := redis.NewClient(opts)
-	p.clients[key] = client
-	return client
+	rdb := redis.NewClient(opts)
+	p.clients[key] = rdb
+	return rdb
 }

internal/controller/redis.go

@@ -61,7 +61,9 @@ var _ = Describe("RedisStreamScaler Controller", func() {
 			Expect(err).NotTo(HaveOccurred())
 
 			rdb := redis.NewClient(&redis.Options{Addr: mr.Addr()})
-			defer rdb.Close()
+			defer func() {
+				Expect(rdb.Close()).To(Succeed())
+			}()
 
 			Expect(rdb.XGroupCreateMkStream(ctx, streamName, groupName, "0").Err()).NotTo(HaveOccurred())
 
@@ -96,10 +98,10 @@ var _ = Describe("RedisStreamScaler Controller", func() {
 				Expect(k8sClient.Create(ctx, deploy)).To(Succeed())
 			}
 
-			var scaler *autoscalingv1alpha1.RedisStreamScaler
+			scaler := &autoscalingv1alpha1.RedisStreamScaler{}
 
 			err = k8sClient.Get(ctx, typeNamespacedName, scaler)
-			if err != nil && errors.IsNotFound(err) {
+			if errors.IsNotFound(err) {
 				resource := &autoscalingv1alpha1.RedisStreamScaler{
 					ObjectMeta: metav1.ObjectMeta{
 						Name:      resourceName,
@@ -116,18 +118,20 @@ var _ = Describe("RedisStreamScaler Controller", func() {
 					},
 				}
 				Expect(k8sClient.Create(ctx, resource)).To(Succeed())
+			} else {
+				Expect(err).NotTo(HaveOccurred())
 			}
 		})
 
 		AfterEach(func() {
-			var resource *autoscalingv1alpha1.RedisStreamScaler
+			resource := &autoscalingv1alpha1.RedisStreamScaler{}
 
 			err := k8sClient.Get(ctx, typeNamespacedName, resource)
 			if err == nil {
 				Expect(k8sClient.Delete(ctx, resource)).To(Succeed())
 			}
 
-			var deploy *appsv1.Deployment
+			deploy := &appsv1.Deployment{}
 
 			err = k8sClient.Get(ctx, types.NamespacedName{Name: deploymentName, Namespace: "default"}, deploy)
 			if err == nil {