~ knotless Search/
↑↓ move↵ open⇧↵ all results

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
main
160 lines · 5.2 KB Raw History
#!/usr/bin/env bash

# Copyright 2026 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.

set -euo pipefail

# Verifies that kcp's real generic apiserver runs on the in-memory
# storage.Interface backend (memory://main) instead of etcd:
#   * kcp starts and bootstraps without an etcd server
#   * CRDs and custom resources are served through the memory backend
#
# The js/wasm build uses the same factory and backend; this native run
# isolates the storage integration from the wasm runtime.
#
# Usage: scripts/verify-kcp-memory.sh

repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
port="${PORT:-6445}"
workdir="$(mktemp -d "${TMPDIR:-/tmp}/kcp-memory-verify.XXXXXX")"
server_pid=""

cleanup() {
  if [[ -n "${server_pid}" ]] && kill -0 "${server_pid}" 2>/dev/null; then
    kill "${server_pid}" 2>/dev/null || true
    wait "${server_pid}" 2>/dev/null || true
  fi
  if [[ "${KEEP_WORKDIR:-false}" == "true" ]]; then
    echo "artifacts kept in ${workdir}"
  else
    rm -rf "${workdir}"
  fi
}
trap cleanup EXIT

fail() {
  echo "FAIL: $*" >&2
  echo "--- kcp log (tail) ---" >&2
  tail -100 "${workdir}/kcp.log" >&2 2>/dev/null || true
  exit 1
}

assert_contains() {
  local haystack="$1" needle="$2" what="$3"
  if [[ "${haystack}" != *"${needle}"* ]]; then
    fail "${what}: expected '${needle}' in:\n${haystack}"
  fi
}

command -v kubectl >/dev/null || fail "kubectl is required"
command -v go >/dev/null || fail "go is required"

echo "== preparing patched modules and building kcp =="
KCP_PATCH_MODE=native "${repo_root}/scripts/prepare-kcp-patched-modules.sh" >/dev/null
(
  cd "${repo_root}"
  go build -modfile="${repo_root}/.go.memory.mod" -o "${workdir}/kcp" ./cmd/kcp
)

echo "== starting kcp with memory://main storage on port ${port} =="
KCP_MEMORY_STORAGE=main "${workdir}/kcp" start \
  --root-directory="${workdir}/root" \
  --secure-port="${port}" \
  --bind-address=127.0.0.1 \
  >"${workdir}/kcp.log" 2>&1 &
server_pid=$!

for _ in $(seq 1 480); do
  kill -0 "${server_pid}" 2>/dev/null || fail "kcp exited during startup"
  [[ -f "${workdir}/root/admin.kubeconfig" ]] && break
  sleep 0.5
done
[[ -f "${workdir}/root/admin.kubeconfig" ]] || fail "admin.kubeconfig was not written"
export KUBECONFIG="${workdir}/root/admin.kubeconfig"

ready=false
for _ in $(seq 1 480); do
  if kubectl get --raw /readyz >/dev/null 2>&1; then
    ready=true
    break
  fi
  kill -0 "${server_pid}" 2>/dev/null || fail "kcp exited while waiting for readiness"
  sleep 0.5
done
[[ "${ready}" == "true" ]] || fail "kcp did not become ready"

echo "== apiserver is serving from memory =="
kubectl get --raw /version
kubectl get workspaces.kcp.io 2>/dev/null || true

echo "== applying the Go-defined Fetch CRD =="
(
  cd "${repo_root}"
  go run ./contrib/wasm/crdgen
) | kubectl apply -f -

crd="$(kubectl get crds fetches.fetch.kcp.io -o jsonpath='{.metadata.name}')"
[[ "${crd}" == "fetches.fetch.kcp.io" ]] || fail "CRD not found (got '${crd}')"

echo "== creating and reading Fetch custom resources =="
kubectl apply -f - <<'EOF'
apiVersion: fetch.kcp.io/v1alpha1
kind: Fetch
metadata:
  name: demo
spec:
  url: https://example.com/
EOF

url="$(kubectl get fetch demo -o jsonpath='{.spec.url}')"
[[ "${url}" == "https://example.com/" ]] || fail "Fetch spec.url = '${url}'"
list="$(kubectl get fetches)"
assert_contains "${list}" "demo" "Fetch list"
kubectl get fetch demo -o yaml

echo "== deleting through the memory backend =="
kubectl delete fetch demo
if kubectl get fetch demo >/dev/null 2>&1; then
  fail "Fetch still exists after delete"
fi

echo "== creating a Workspace without pre-setting tenancy.kcp.io/phase =="
# The status subresource drops .status.phase on create. The memory backend
# must re-apply the CRD default when it reads the object back, just like the
# etcd3 store's codec does; otherwise the workspace controller's committer
# panics with "spec and status changed in same reconcile iteration".
kubectl apply -f - <<'EOF'
apiVersion: tenancy.kcp.io/v1alpha1
kind: Workspace
metadata:
  name: no-phase-label
spec:
  type:
    name: universal
    path: root
EOF

workspace_state=""
for _ in $(seq 1 240); do
  kill -0 "${server_pid}" 2>/dev/null || fail "kcp exited after creating a Workspace"
  workspace_state="$(kubectl get workspace no-phase-label -o jsonpath='{.status.phase}|{.metadata.labels.tenancy\.kcp\.io/phase}' 2>/dev/null || true)"
  [[ "${workspace_state}" == "Ready|Ready" ]] && break
  sleep 0.5
done
[[ "${workspace_state}" == "Ready|Ready" ]] || fail "Workspace phase|label = '${workspace_state}', want 'Ready|Ready'"
kubectl get workspace no-phase-label -o yaml

echo
echo "PASS: kcp's generic apiserver bootstrapped, served CRDs/CRs from memory://main, and defaulted a Workspace created without tenancy.kcp.io/phase (no etcd)."