Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
9.9 KB
Raw Blame
#!/usr/bin/env bash
# Atomic Kubernetes Secret transitions for resumable GFSC credential rotation.
# Candidate connection material is accepted only on stdin.
# Snapshot globals are consumed by the provisioning script that sources this file.
# shellcheck disable=SC2034
GFS_ROLLOUT_PROOF_KIND=""
GFS_ROLLOUT_PROOF_RESOURCE_VERSION=""
GFS_ROLLOUT_PROOF_TEMPLATE_REVISION=""
GFS_ROLLOUT_PROOF_POD_COUNT=""
GFS_ROLLOUT_PROOF_AT=""

gfs_secret_state() {
  kc -n "$GFS_NS" get secret "$1" -o 'jsonpath={.metadata.annotations.clerum\.io/gfs-dsn-state}'
}

gfs_secret_rotated_at() {
  kc -n "$GFS_NS" get secret "$1" -o 'jsonpath={.metadata.annotations.clerum\.io/gfs-dsn-rotated-at}'
}

ensure_secret_state() {
  local secret="$1" state rv
  state="$(gfs_secret_state "$secret")"
  [ -n "$state" ] && return 0
  rv="$(secret_resource_version "$secret")"
  python3 -c 'import json, sys
print(json.dumps({"metadata": {"resourceVersion": sys.argv[1], "annotations": {"clerum.io/gfs-dsn-state": "ready"}}}))' "$rv" \
    | kc -n "$GFS_NS" patch secret "$secret" --type=merge --patch-file=/dev/stdin >/dev/null \
    || [ -n "$(gfs_secret_state "$secret")" ]
}

load_secret_snapshot() {
  local secret="$1" encoded rv annotations state rotated active pending
  encoded="$(kc -n "$GFS_NS" get secret "$secret" -o json | python3 -c 'import base64, json, sys
obj = json.load(sys.stdin)
metadata = obj.get("metadata") or {}
annotations = metadata.get("annotations") or {}
data = obj.get("data") or {}
def decode_data(key):
    value = data.get(key, "")
    return base64.b64decode(value, validate=True) if value else b""
values = [
    str(metadata.get("resourceVersion", "")).encode(),
    (b"yes" if annotations else b"no"),
    str(annotations.get("clerum.io/gfs-dsn-state", "")).encode(),
    str(annotations.get("clerum.io/gfs-dsn-rotated-at", "")).encode(),
    decode_data("connection-string"),
    decode_data("pending-connection-string"),
]
print("|".join(base64.b64encode(value).decode() for value in values))')" || return 1
  IFS='|' read -r rv annotations state rotated active pending <<<"$encoded"
  GFS_SNAPSHOT_RV="$(printf '%s' "$rv" | base64 -d)" || return 1
  GFS_SNAPSHOT_ANNOTATIONS="$(printf '%s' "$annotations" | base64 -d)" || return 1
  GFS_SNAPSHOT_STATE="$(printf '%s' "$state" | base64 -d)" || return 1
  GFS_SNAPSHOT_ROTATED_AT="$(printf '%s' "$rotated" | base64 -d)" || return 1
  GFS_SNAPSHOT_ACTIVE="$(printf '%s' "$active" | base64 -d)" || return 1
  GFS_SNAPSHOT_PENDING="$(printf '%s' "$pending" | base64 -d)" || return 1
  [ -n "$GFS_SNAPSHOT_RV" ]
}

adopt_legacy_secret_state() {
  local secret="$1" expected_rv="$2" annotations_exist="$3" existing_stamp="$4" adopted_at="$5"
  python3 -c 'import json, sys
rv, annotations_exist, existing_stamp, adopted_at = sys.argv[1:]
state = {"clerum.io/gfs-dsn-state": "ready"}
if not existing_stamp:
    state["clerum.io/gfs-dsn-rotated-at"] = adopted_at
op = {"op": "add", "path": "/metadata/annotations", "value": state}
if annotations_exist == "yes":
    op = {"op": "add", "path": "/metadata/annotations/clerum.io~1gfs-dsn-state", "value": "ready"}
ops = [{"op": "test", "path": "/metadata/resourceVersion", "value": rv}, op]
if annotations_exist == "yes" and not existing_stamp:
    ops.append({"op": "add", "path": "/metadata/annotations/clerum.io~1gfs-dsn-rotated-at", "value": adopted_at})
print(json.dumps(ops))' "$expected_rv" "$annotations_exist" "$existing_stamp" "$adopted_at" \
    | kc -n "$GFS_NS" patch secret "$secret" --type=json --patch-file=/dev/stdin >/dev/null 2>&1
}

gfs_candidate_patch() {
  local transition="$1"
  python3 -c 'import base64, datetime, json, sys
transition = sys.argv[1]
candidate = base64.b64encode(sys.stdin.buffer.read()).decode()
state_path = "/metadata/annotations/clerum.io~1gfs-dsn-state"
pending_path = "/data/pending-connection-string"
ops = []
if transition == "claim":
    ops = [
        {"op": "test", "path": state_path, "value": "pending"},
        {"op": "test", "path": pending_path, "value": candidate},
        {"op": "replace", "path": state_path, "value": "applying"},
    ]
elif transition == "promote":
    stamp = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
    ops = [
        {"op": "test", "path": state_path, "value": "applying"},
        {"op": "test", "path": pending_path, "value": candidate},
        {"op": "add", "path": "/data/connection-string", "value": candidate},
        {"op": "remove", "path": pending_path},
        {"op": "replace", "path": state_path, "value": "rollout-pending"},
        {"op": "add", "path": "/metadata/annotations/clerum.io~1gfs-dsn-rotated-at", "value": stamp},
    ]
elif transition == "rollback":
    ops = [
        {"op": "test", "path": state_path, "value": "applying"},
        {"op": "test", "path": pending_path, "value": candidate},
        {"op": "remove", "path": pending_path},
        {"op": "replace", "path": state_path, "value": "ready"},
    ]
elif transition == "release":
    ops = [
        {"op": "test", "path": state_path, "value": "applying"},
        {"op": "test", "path": pending_path, "value": candidate},
        {"op": "replace", "path": state_path, "value": "pending"},
    ]
else:
    raise SystemExit(2)
print(json.dumps(ops))' "$transition"
}

stage_secret_candidate() {
  local secret="$1" candidate rv data_exists staging_err
  staging_err="$(mktemp)"
  candidate="$(cat)"
  rv="$(secret_resource_version "$secret")" || { rm -f "$staging_err"; return 1; }
  data_exists="$(kc -n "$GFS_NS" get secret "$secret" \
    -o 'go-template={{if .data}}yes{{else}}no{{end}}')" || { rm -f "$staging_err"; return 1; }
  if printf '%s' "$candidate" | python3 -c 'import base64, json, sys
rv, data_exists = sys.argv[1:]
candidate = base64.b64encode(sys.stdin.buffer.read()).decode()
state_path = "/metadata/annotations/clerum.io~1gfs-dsn-state"
data_op = {"op": "add", "path": "/data/pending-connection-string", "value": candidate}
if data_exists == "no":
    data_op = {"op": "add", "path": "/data", "value": {"pending-connection-string": candidate}}
print(json.dumps([
  {"op": "test", "path": "/metadata/resourceVersion", "value": rv},
  {"op": "test", "path": state_path, "value": "ready"},
  data_op,
  {"op": "replace", "path": state_path, "value": "pending"},
]))' "$rv" "$data_exists" \
    | kc -n "$GFS_NS" patch secret "$secret" --type=json --patch-file=/dev/stdin 2>"$staging_err" >/dev/null; then
    rm -f "$staging_err"
    unset candidate
    return 0
  fi
  if [ -s "$staging_err" ]; then
    printf '[gfs-credential-secret] staging candidate on %s/%s failed: %s\n' \
      "$GFS_NS" "$secret" "$(cat "$staging_err")" >&2
  fi
  rm -f "$staging_err"
  unset candidate
  return 1
}

# The CAS patches lose races by design, but a non-CAS failure (RBAC, API
# server) must not read as contention: surface the captured error text so
# callers' "another operation won" diagnostics stay truthful.
candidate_patch_apply() {
  local op="$1" secret="$2" out
  if out="$(gfs_candidate_patch "$op" \
    | kc -n "$GFS_NS" patch secret "$secret" --type=json --patch-file=/dev/stdin 2>&1 >/dev/null)"; then
    return 0
  fi
  printf '[gfs-credential-secret] %s candidate patch on %s/%s failed: %s\n' \
    "$op" "$GFS_NS" "$secret" "$out" >&2
  return 1
}

claim_secret_candidate() {
  candidate_patch_apply claim "$1"
}

promote_secret_candidate() {
  candidate_patch_apply promote "$1"
}

clear_secret_candidate() {
  candidate_patch_apply rollback "$1"
}

release_abandoned_candidate() {
  candidate_patch_apply release "$1"
}

claim_secret_rollout() {
  local secret="$1" expected_rotated_at="$2" expected_state="$3"
  python3 -c 'import json, sys
state, stamp = sys.argv[1:]
print(json.dumps([
  {"op": "test", "path": "/metadata/annotations/clerum.io~1gfs-dsn-state", "value": state},
  {"op": "test", "path": "/metadata/annotations/clerum.io~1gfs-dsn-rotated-at", "value": stamp},
  {"op": "replace", "path": "/metadata/annotations/clerum.io~1gfs-dsn-state", "value": "rollout-running"},
]))' "$expected_state" "$expected_rotated_at" \
    | kc -n "$GFS_NS" patch secret "$secret" --type=json --patch-file=/dev/stdin >/dev/null
}

mark_secret_rollout_ready() {
  local secret="$1" expected_rotated_at="$2" expected_state="$3"
  local proof_kind proof_resource_version proof_template_revision proof_pod_count proof_at
  proof_kind="$GFS_ROLLOUT_PROOF_KIND"
  proof_resource_version="$GFS_ROLLOUT_PROOF_RESOURCE_VERSION"
  proof_template_revision="$GFS_ROLLOUT_PROOF_TEMPLATE_REVISION"
  proof_pod_count="$GFS_ROLLOUT_PROOF_POD_COUNT"
  proof_at="$GFS_ROLLOUT_PROOF_AT"
  python3 -c 'import json, sys
state, stamp, proof_kind, proof_resource_version, proof_template_revision, proof_pod_count, proof_at = sys.argv[1:]
ops = [
  {"op": "test", "path": "/metadata/annotations/clerum.io~1gfs-dsn-state", "value": state},
  {"op": "test", "path": "/metadata/annotations/clerum.io~1gfs-dsn-rotated-at", "value": stamp},
  {"op": "replace", "path": "/metadata/annotations/clerum.io~1gfs-dsn-state", "value": "ready"},
]
if proof_kind:
    if proof_resource_version:
        ops.insert(2, {"op": "test", "path": "/metadata/resourceVersion", "value": proof_resource_version})
    values = {
        "clerum.io/gfs-dsn-proof-kind": proof_kind,
        "clerum.io/gfs-dsn-proof-resource-version": proof_resource_version,
        "clerum.io/gfs-dsn-proof-template-revision": proof_template_revision,
        "clerum.io/gfs-dsn-proof-pod-count": proof_pod_count,
        "clerum.io/gfs-dsn-proof-at": proof_at,
    }
    for key, value in values.items():
        ops.append({"op": "add", "path": "/metadata/annotations/" + key.replace("/", "~1"), "value": value})
print(json.dumps(ops))' "$expected_state" "$expected_rotated_at" \
    "$proof_kind" "$proof_resource_version" "$proof_template_revision" "$proof_pod_count" "$proof_at" \
    | kc -n "$GFS_NS" patch secret "$secret" --type=json --patch-file=/dev/stdin >/dev/null
  GFS_ROLLOUT_PROOF_KIND=""
  GFS_ROLLOUT_PROOF_RESOURCE_VERSION=""
  GFS_ROLLOUT_PROOF_TEMPLATE_REVISION=""
  GFS_ROLLOUT_PROOF_POD_COUNT=""
  GFS_ROLLOUT_PROOF_AT=""
}