Compare commits
9
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 panxiao81
|
b5262c932f
|
||
|
panxiao81
|
6e6a89f15a
|
||
|
panxiao81
|
2756803ba4
|
||
|
panxiao81
|
76752c8443
|
||
|
panxiao81
|
36138f835a
|
||
|
panxiao81
|
de8b7f9b04
|
||
|
panxiao81
|
e6b9980b3e
|
||
|
panxiao81
|
641db531a8
|
||
|
panxiao81
|
7b841d7dba
|
@@ -3,21 +3,37 @@
|
||||
- 本仓库是 ddupan.top homelab 的内部基础设施控制平面，不以通用发行版为初期目标。
|
||||
- 提交、文档和代码注释优先使用中文；公共 API 标识符和代码遵循对应语言惯例。
|
||||
- 不要重新实现已有成熟后端的核心能力；新增实现前先确认能否通过稳定 API 进行薄适配。
|
||||
- 不要按传统私有云或公有云产品清单推导 Ayatori 应实现的资源。新增北向 API 前必须证明 homelab
|
||||
存在真实、重复的管理缺口，现有成熟 API/IaC 不能提供足够的生命周期、状态或权限体验；“后端
|
||||
能做到”或“其他云平台提供”本身不是产品需求。
|
||||
- 当前已确认的首要产品方向是 Database、LoadBalancer、Bucket/Object Storage；VirtualMachine
|
||||
也具有明确价值，但南向实现较重。Run/Job 是验证 controller 与 adapter 的内部执行切片，不应
|
||||
自动演化为 FaaS、Cloud Run 或应用托管产品。KaaS 仅在出现真实需求时评估，不是必达终点。
|
||||
- Ayatori 复用 Kubernetes 的核心目标是 API machinery：对象存储与并发控制、list/watch、
|
||||
informer、RBAC、admission、版本化 API 和审计；不要据此推断 Ayatori 是 Kubernetes
|
||||
workload 平台，也不要默认复用 Kubernetes 的调度与数据面语义。
|
||||
- 复用 Kubernetes 内置资源只表示采用其 API contract，不表示必须运行或模拟上游实现组件。
|
||||
例如 Ayatori Compute Agent 可以直接实现 `core/v1 Node` 与 Lease 的状态语义，Ayatori
|
||||
controller 可以自行消费 Node；不得仅因使用 Node 推导必须引入 kubelet、Pod、CRI、
|
||||
kube-scheduler 或 kube-controller-manager。对每个复用资源分别明确 producer、consumer、
|
||||
ownership 与实际采用的字段语义。
|
||||
- kube-apiserver 是 Ayatori 的 API 与状态协调平面，不是领域调度器。资源的调度、生命周期、
|
||||
故障恢复、垃圾回收和后端收敛由 Ayatori controllers 实现；新增能力前应明确其属于 API
|
||||
machinery、Ayatori 领域控制循环还是外部 backend，避免把职责放错层。
|
||||
- Kubernetes、OpenSandbox、Proxmox 等均是 Ayatori 的可替换 backend/executor。除管理组件自身
|
||||
的部署外，不得仅因 controller 运行在 Kubernetes 中，就把原生 Pod、Job、Service、
|
||||
NetworkPolicy、owner reference 或同 namespace 行为作为领域 API 的隐含语义；需要这些能力时
|
||||
必须由 adapter 契约显式表达，并考虑后端位于其他集群或完全不是 Kubernetes 的情况。
|
||||
- 不要以减少自有 controller 数量为目的引入 generic-apiserver、聚合 API Server 或自行实现
|
||||
API Server。只有 CRD/kube-apiserver 在存储、API 语义或扩展能力上形成已验证的阻碍时，才评估
|
||||
接管 watch、RBAC、版本兼容和存储迁移等复杂度；controller 工作本身不会因此消失。
|
||||
- 在自行设计通用控制循环、资源生命周期、调度、回收或故障恢复机制前，先调查 Kubernetes
|
||||
核心及成熟开源 controller/operator 的实现；优先复用经过验证的模式，并记录有意偏离的
|
||||
理由。
|
||||
- 不要引入统一包装所有能力的 Application CRD；应用应直接组合正交的平台资源。
|
||||
- Proxmox VM 的北向管理不能假定单一 API 覆盖完整生命周期。允许按能力组合 Proxmox API、节点
|
||||
上的受限强类型 Agent/CLI 操作和 ManualTask；节点 Agent 不得退化为无版本契约的任意远程 shell。
|
||||
- 所有 controller 必须考虑幂等、observe、finalizer、conditions、删除策略和恢复行为。
|
||||
- Ayatori 会联动 Kubernetes API、虚拟化、存储、网络及其他外部控制面；集成测试是功能完成
|
||||
标准的一部分，不得仅凭 fake client 或 mock 测试宣告 controller、adapter 或生命周期变更完成。
|
||||
- 测试应按风险分层：纯领域规则使用快速单元测试；API schema、CEL、status subresource、
|
||||
watch/cache、owner reference 和 reconcile 事件链使用 envtest；需要 scheduler、kubelet、网络、
|
||||
存储或真实后端行为的路径在 Dev 集群或对应后端环境执行端到端测试。
|
||||
- fake client 适合穷举状态机和错误分支，但它不会完整执行 API server defaulting、validation、
|
||||
resourceVersion、garbage collection 或新版 Kubernetes 约束；涉及这些语义时必须增加真实 API
|
||||
server 测试。跨 adapter 的共同契约应使用同一套 contract tests，避免各实现产生语义漂移。
|
||||
- 集成测试必须覆盖正常路径以及幂等重试、controller 重启、依赖稍后出现、删除/finalizer、
|
||||
后端结果不确定和并发竞态等恢复路径；无法在当前层测试的部分要明确记录由哪一层验证。
|
||||
- Secret、token、kubeconfig 及具体生产凭据不得提交到仓库。
|
||||
- `deploy/dev/` 与 `deploy/prod/` 使用相同制品；生产版本只通过 promotion 更新。
|
||||
- 内部专用不构成降低测试、版本、恢复、安全和可审计要求的理由。
|
||||
|
||||
@@ -28,11 +28,15 @@ Ayatori 是 `ddupan.top` homelab 的内部基础设施控制平面。它以 Kube
|
||||
- [执行模型](docs/concepts/execution-model.md)
|
||||
- [环境与发布](docs/concepts/environments.md)
|
||||
- [路线图](docs/roadmap.md)
|
||||
- [ADR-0001：采用 Kubernetes API 作为资源模型](docs/decisions/0001-kubernetes-api-machinery.md)
|
||||
- [ADR-0001：采用 Kubernetes API machinery 作为状态协调平面](docs/decisions/0001-kubernetes-api-machinery.md)
|
||||
- [ADR-0002：采用 k0s 与可选工作负载运行时](docs/decisions/0002-k0s-optional-workload-runtime.md)
|
||||
- [ADR-0003：直接连接 Dev API 的开发循环](docs/decisions/0003-dev-api-development-loop.md)
|
||||
- [ADR-0006：按实际管理缺口扩展资源 API](docs/decisions/0006-demand-driven-resource-scope.md)
|
||||
- [ADR-0007：复用 Node API 建立按需实现的 Compute 能力](docs/decisions/0007-compute-node-and-vm-boundary.md)
|
||||
- [ADR-0008：将 PostgreSQL Tenant Operator 合并为 Ayatori Database 模块](docs/decisions/0008-merge-postgresql-tenant-operator.md)
|
||||
|
||||
## 当前状态
|
||||
|
||||
Ayatori 处于设计与早期实现阶段。第一个纵向切片计划是统一 Job API 与 Kubernetes
|
||||
Pod executor，随后接入 OpenSandbox executor。
|
||||
Ayatori 处于设计与早期实现阶段。当前使用 Job controller 验证第一个完整控制循环与 adapter
|
||||
边界；它不是通用 Job Service 或 FaaS 产品承诺。首批实际产品方向是 Database、LoadBalancer
|
||||
和 Bucket/Object Storage，具体顺序按纵向价值决定。
|
||||
|
||||
@@ -20,7 +20,6 @@ import (
|
||||
"sigs.k8s.io/controller-runtime/pkg/webhook"
|
||||
|
||||
executionv1alpha1 "git.ddupan.top/panxiao81/ayatori/api/execution/v1alpha1"
|
||||
"git.ddupan.top/panxiao81/ayatori/internal/controller"
|
||||
// +kubebuilder:scaffold:imports
|
||||
)
|
||||
|
||||
@@ -166,13 +165,6 @@ func main() {
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
if err := (&controller.JobReconciler{
|
||||
Client: mgr.GetClient(),
|
||||
}).SetupWithManager(mgr); err != nil {
|
||||
setupLog.Error(err, "Failed to create controller", "controller", "Job")
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// +kubebuilder:scaffold:builder
|
||||
|
||||
if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil {
|
||||
|
||||
+6
-53
@@ -1,58 +1,11 @@
|
||||
---
|
||||
apiVersion: rbac.authorization.k8s.io/v1
|
||||
kind: ClusterRole
|
||||
metadata:
|
||||
labels:
|
||||
app.kubernetes.io/name: ayatori
|
||||
app.kubernetes.io/managed-by: kustomize
|
||||
name: manager-role
|
||||
rules:
|
||||
- apiGroups:
|
||||
- ""
|
||||
resources:
|
||||
- namespaces
|
||||
- serviceaccounts
|
||||
verbs:
|
||||
- get
|
||||
- list
|
||||
- watch
|
||||
- apiGroups:
|
||||
- batch
|
||||
resources:
|
||||
- jobs
|
||||
verbs:
|
||||
- create
|
||||
- delete
|
||||
- get
|
||||
- list
|
||||
- watch
|
||||
- apiGroups:
|
||||
- execution.ayatori.ddupan.top
|
||||
resources:
|
||||
- jobclasses
|
||||
- kubernetesexecutionparameters
|
||||
verbs:
|
||||
- get
|
||||
- list
|
||||
- watch
|
||||
- apiGroups:
|
||||
- execution.ayatori.ddupan.top
|
||||
resources:
|
||||
- jobs
|
||||
verbs:
|
||||
- get
|
||||
- list
|
||||
- patch
|
||||
- update
|
||||
- watch
|
||||
- apiGroups:
|
||||
- execution.ayatori.ddupan.top
|
||||
resources:
|
||||
- jobs/finalizers
|
||||
verbs:
|
||||
- update
|
||||
- apiGroups:
|
||||
- execution.ayatori.ddupan.top
|
||||
resources:
|
||||
- jobs/status
|
||||
verbs:
|
||||
- get
|
||||
- patch
|
||||
- update
|
||||
- apiGroups: [""]
|
||||
resources: ["pods"]
|
||||
verbs: ["get", "list", "watch"]
|
||||
|
||||
@@ -4,9 +4,11 @@
|
||||
Git / CLI / Backstage
|
||||
│
|
||||
▼
|
||||
Kubernetes API + CRD
|
||||
kube-apiserver + etcd + CRD
|
||||
API / state coordination plane
|
||||
│
|
||||
Ayatori controllers
|
||||
Ayatori controller-manager
|
||||
scheduling / lifecycle / recovery / GC
|
||||
│
|
||||
┌──────┼──────────────┐
|
||||
│ │ │
|
||||
@@ -19,6 +21,20 @@ Terraform OpenBao / DNS / KaaS
|
||||
Ansible
|
||||
```
|
||||
|
||||
Ayatori 复用 Kubernetes 的 API machinery，而不是 Kubernetes 的容器编排产品边界。
|
||||
kube-apiserver 提供版本化对象、并发控制、list/watch、RBAC、admission 和审计；Ayatori
|
||||
controller-manager 承担所有领域控制循环。Kubernetes workload 集群只是与 OpenSandbox、
|
||||
Proxmox 等并列的 executor/backend，不默认等于运行 controller 的 management environment。
|
||||
|
||||
因此，领域 API 不得依赖“资源最终一定变成同集群原生对象”的假设。原生 Pod、Job、Service、
|
||||
NetworkPolicy、namespace 共置与 owner reference 只有在 Kubernetes adapter 内才具有原生含义；
|
||||
跨后端所需能力必须由领域模型显式定义。
|
||||
|
||||
内置 API 类型也按相同原则选择性复用。采用 `core/v1 Node` 作为计算节点 API 时，可以由
|
||||
Ayatori Compute Agent 写入状态、由 Ayatori 自有调度 controller 消费；这不会引入 kubelet、
|
||||
Pod 或 kube-scheduler。API contract、负责实现它的 controller/agent 和数据面是三个独立决策，
|
||||
不得从其中一个自动推导另外两个。
|
||||
|
||||
## 控制面
|
||||
|
||||
Dev 与 Prod 使用独立的 Kubernetes API、数据库、身份和 controller 实例。两者可以
|
||||
@@ -34,16 +50,16 @@ Ayatori 不承载或重新实现数据面。控制面故障只应阻止创建与
|
||||
|
||||
## 资源分层
|
||||
|
||||
平台提供正交产品能力，例如：
|
||||
平台只为已经验证的管理缺口提供正交产品能力。当前优先资源为：
|
||||
|
||||
- `Job`、`Sandbox`、`ManualTask`
|
||||
- `VirtualMachine`
|
||||
- `LoadBalancer`
|
||||
- `Database`
|
||||
- `Bucket`
|
||||
- `DNSRecord`
|
||||
- `Credential`
|
||||
- `KubernetesCluster`
|
||||
- `VirtualMachine`
|
||||
|
||||
`Run`/当前实验性的 `Job`、`ManualTask` 等可以作为控制面执行原语，但不是因为底层能运行 OCI
|
||||
image 就自动成为面向使用者的计算产品。`DNSRecord`、`Credential`、`KubernetesCluster` 等只在
|
||||
出现独立生命周期和真实消费者后加入；尤其 KaaS 不是预定终点。
|
||||
|
||||
只有具备独立领域生命周期的能力才应成为高阶资源。应用本身通过 GitOps 组合上述资源，
|
||||
重复组合可通过模板或 Composition 表达，而不是扩展中央 Application API。
|
||||
@@ -56,5 +72,17 @@ Ayatori 不承载或重新实现数据面。控制面故障只应阻止创建与
|
||||
2. 通过固定版本的 Terraform module 或 Ansible playbook 执行。
|
||||
3. 仅在必要时使用 GitOps bridge。
|
||||
|
||||
Proxmox 是已知例外：其远程 API 不能覆盖所需的完整 VM 生命周期。VirtualMachine adapter 可以
|
||||
按操作能力选择 Proxmox API、部署在节点上的受限强类型 Agent/CLI，或生成 `ManualTask`。Agent
|
||||
必须提供版本化操作、幂等查询、operation ID 与审计，不能暴露任意 shell，也不能把 CLI 输出
|
||||
直接当作长期稳定协议。
|
||||
|
||||
Controller 无论采用哪种执行方式，都必须提供一致的 ownership、conditions、删除语义、
|
||||
错误分类和恢复行为。
|
||||
|
||||
## API Server 边界
|
||||
|
||||
首选 kube-apiserver + CRD，持续复用其成熟的 watch、RBAC、版本化存储和 API 生态。
|
||||
generic-apiserver 或聚合 API Server 不会减少领域 controller 的数量，只会把资源服务端、
|
||||
兼容性和存储迁移责任转移给 Ayatori。只有 CRD 的限制已经形成可复现、不可通过合理领域建模
|
||||
解决的阻碍时，才重新评估自建 API Server。
|
||||
|
||||
@@ -0,0 +1,43 @@
|
||||
# Database 模块
|
||||
|
||||
Database 是 Ayatori 首批实际产品领域之一。第一个迁移切片只建立 PostgreSQL Instance 的纯领域
|
||||
模型，不注册 CRD、不启动 controller，也不访问 PostgreSQL、OpenBao 或 Kubernetes Secret。
|
||||
|
||||
## 来源基线
|
||||
|
||||
完整设计合同及首批领域模型与测试提取自原 PostgreSQL Tenant Operator：
|
||||
|
||||
- 仓库：`git.ddupan.top/panxiao81/postgresql-tenant-operator`
|
||||
- source commit：`dae546e58efa1be81e930861c87f7fb13bb12113`
|
||||
- 原路径：`internal/domain/instance/`、`docs/domain-instance.md`
|
||||
- 迁移日期：2026-09-20
|
||||
|
||||
本目录迁入该基线的 specification、architecture、API、领域、部署、安全、开发、迁移与运维
|
||||
文档，并只进行 Ayatori 产品归属、API group、目录和链接适配；其余已批准行为保持不变。
|
||||
|
||||
迁移只使用该 commit 中已提交的文件。源仓库
|
||||
`feature/instance-extension-observations` 工作树中的 `instance.go` 修改与
|
||||
`instance_extensions_test.go` 未进入本切片。
|
||||
|
||||
代码被移动到 Ayatori 的 `internal/database/domain/instance`，测试 import 和文档链接相应更新；
|
||||
首个后续切片按已批准合同增加 Instance extension observation：观测与当前 target 绑定，进入重新
|
||||
验证或删除时失效，且支持判定不授权 Tenant provisioning。其余 Ready/observation 行为仍应先更新
|
||||
合同与测试再实现，不能把旧运行链路接回该模型。
|
||||
|
||||
## 边界
|
||||
|
||||
- 领域层不依赖 Kubernetes types、数据库 driver 或凭据 provider。
|
||||
- CredentialReference 只携带管理 Secret 的名称与字段映射，不包含 Secret 内容或 OpenBao path。
|
||||
- Instance checkpoint 不是外部事实；实际能力必须由 application/adapter 观察后交给领域对象判断。
|
||||
- 当前代码不授权 Tenant provisioning，也不表示 Database API 已经可用。
|
||||
|
||||
## 设计入口
|
||||
|
||||
- [系统规格](specification.md)：规范性行为与验收标准；
|
||||
- [架构](architecture.md)与[API 合同](api-reference.md)；
|
||||
- [领域模型](domain-model.md)与[Instance 领域规格](domain-instance.md)；
|
||||
- [安全](security.md)、[迁移](migration.md)与[运维](operations.md)；
|
||||
- [部署合同](deployment.md)与[开发测试合同](development.md)。
|
||||
|
||||
部署和开发文档描述目标合同，其中旧仓库专属的 Make target、脚手架版本和目录尚未接入 Ayatori；
|
||||
在对应实现切片完成前，不应把其中命令理解为当前仓库已经可执行的入口。
|
||||
@@ -0,0 +1,190 @@
|
||||
# v1alpha1 API 合同
|
||||
|
||||
| 项目 | 内容 |
|
||||
| --- | --- |
|
||||
| 状态 | Review |
|
||||
| API group | `database.ayatori.ddupan.top` |
|
||||
| version | `v1alpha1` |
|
||||
| 最后更新 | 2026-09-10 |
|
||||
|
||||
本文把已批准的系统规格映射为 CRD 字段合同。API types、生成 CRD、sample 和测试必须与本文
|
||||
一致。Ayatori 尚未注册这些 API，本页是后续实现的规范来源。
|
||||
|
||||
## 通用约定
|
||||
|
||||
- PostgreSQL identifier 匹配 `^[a-z][a-z0-9_]{0,62}$`。
|
||||
- 所有引用名称使用 Kubernetes DNS label/name 的相应校验。
|
||||
- Tenant 的 `spec.instanceRef` 与 `metadata.name` 长度合计不超过 241 个字符，确保派生的
|
||||
`<instanceRef>-<metadata.name>-postgresql` 不超过 Kubernetes DNS subdomain 的
|
||||
253 字符限制。
|
||||
- port、TLS mode、deletion policy 等固定默认值由 CRD defaulting 提供。database、
|
||||
loginRole、Secret 名称等依赖其他字段的值是 controller 语义默认值：字段保持省略，
|
||||
controller 计算 effective value 并通过 status/受管资源展示，不引入 mutating webhook。
|
||||
- 需要读取旧值或跨字段的校验由 CEL 或 controller 完成。
|
||||
- `status` 由 controller 独占写入，禁止出现密码、Token、管理用户名或完整连接串。
|
||||
- 两个 Kind 都只承诺一个 `Ready` Condition；调用方不得依赖内部协调阶段。
|
||||
|
||||
## PostgreSQLInstance
|
||||
|
||||
cluster-scoped，short name 为 `pginstance`。
|
||||
|
||||
### Spec
|
||||
|
||||
| JSON path | 类型 | 必填/默认 | 合同 |
|
||||
| --- | --- | --- | --- |
|
||||
| `spec.endpoint.host` | string | 必填 | PostgreSQL DNS 名；必须被服务端证书 DNS SAN 覆盖 |
|
||||
| `spec.endpoint.hostaddr` | string | 必填 | 单个 IPv4/IPv6；必须被服务端证书 IP SAN 覆盖 |
|
||||
| `spec.endpoint.port` | int32 | `5432` | 1–65535 |
|
||||
| `spec.endpoint.database` | string | `postgres` | 管理连接 database；合法 PostgreSQL identifier |
|
||||
| `spec.endpoint.sslMode` | enum | `verify-full` | `disable`、`require`、`verify-ca`、`verify-full` |
|
||||
| `spec.adminCredentialRef.name` | string | 必填 | controller namespace 内的管理 Secret 名称 |
|
||||
| `spec.adminCredentialRef.usernameKey` | string | `username` | Secret data 中的键名 |
|
||||
| `spec.adminCredentialRef.passwordKey` | string | `password` | Secret data 中的键名 |
|
||||
|
||||
`adminCredentialRef` 不接受 namespace 或 Bao path。管理 Secret 固定在 controller
|
||||
namespace，名称须合法，两个字段须存在且非空。管理员维护 ExternalSecret，由 ESO
|
||||
同步；controller 只读管理 Secret，不创建或修改它。此为 2026-09-13 批准的修订，
|
||||
现有 API types、生成 CRD 和 samples 尚未更新。
|
||||
|
||||
Instance endpoint、管理凭据引用可以修改。修改后 controller 重新验证。
|
||||
2026-09-14 修订：v1alpha1 不实现 allowedExtensions；现有 API types、生成 CRD 和
|
||||
samples 中的字段待后续移除，不作为一个可配置但被忽略的策略保留。
|
||||
扩展请求按目标 PostgreSQL 实际可安装列表判断，可用列表由应用层查询。
|
||||
|
||||
endpoint 由管理员负责，不校验变更前后是否同一物理服务器／registry，只重验新配置
|
||||
的连接与管理能力。新 UID 按新 Instance 处理，不授权接管旧 UID 的 Tenant 资源。
|
||||
|
||||
### Status
|
||||
|
||||
| JSON path | 类型 | 含义 |
|
||||
| --- | --- | --- |
|
||||
| `status.observedGeneration` | int64 | 最近完成有结论协调的 generation |
|
||||
| `status.phase` | enum | `Pending`、`Validating`、`InitializingRegistry`、`Ready`、`Deleting` |
|
||||
| `status.postgresqlVersion` | string | 从 server 回读的版本，不用于客户端解析 |
|
||||
| `status.conditions[]` | `metav1.Condition` | 至少包含唯一的 `Ready` |
|
||||
|
||||
print columns：`Endpoint=.spec.endpoint.host`、`Phase`、`Ready`、`Age`。
|
||||
|
||||
Instance `Ready=True` 要求管理凭据可读、TLS/认证成功、server metadata 可读、registry
|
||||
可访问且权限预检成功。它不代表数据库已经备份或高可用。
|
||||
|
||||
管理凭据从 Kubernetes Secret 装配；已有有效凭据可访问 PostgreSQL 时，Bao／ESO
|
||||
暂时不可用不单独撤销 Instance Ready。Tenant 凭据操作仍依赖 Bao。
|
||||
|
||||
## PostgreSQLTenant
|
||||
|
||||
namespaced，short name 为 `pgtenant`。
|
||||
|
||||
### Spec
|
||||
|
||||
| JSON path | 类型 | 必填/默认 | 合同 |
|
||||
| --- | --- | --- | --- |
|
||||
| `spec.instanceRef` | string | 必填 | cluster-scoped Instance 名称 |
|
||||
| `spec.database` | string | `metadata.name` | 合法 PostgreSQL identifier |
|
||||
| `spec.loginRole` | string | `metadata.name` | database owner 兼应用 login |
|
||||
| `spec.extensions` | set[string] | 空集合 | 必须属于目标实例实际可安装的扩展列表；成功创建后只允许追加 |
|
||||
| `spec.credential.secretName` | string | `<instance>-<name>-postgresql` | 合法的同 namespace ESO target Secret 名称 |
|
||||
| `spec.deletionPolicy` | enum | `Retain` | `Retain` 或 `Delete` |
|
||||
|
||||
Tenant 不声明 OpenBao mount 或 path。controller 使用部署级 mount/base path 和
|
||||
`namespace/name` 推导稳定路径，并用 UID metadata 验证所有权。ExternalSecret 固定为
|
||||
`<instanceRef>-<metadata.name>-postgresql`；目标 Secret 可以由用户指定，只需
|
||||
满足 Kubernetes Secret 名称校验，不限制命名内容；省略时使用相同默认名。
|
||||
|
||||
`instanceRef`、`database`、`loginRole` 和 `credential.secretName` 在首次成功创建外部
|
||||
状态后不可变。
|
||||
`extensions` 只允许集合不变或追加；移除返回 `ImmutableField`，不会执行
|
||||
`DROP EXTENSION`。`deletionPolicy` 在对象进入删除前可以修改；删除开始后以 finalizer
|
||||
首次观察到的值为准，避免清理过程中改变授权范围。
|
||||
|
||||
### Status
|
||||
|
||||
| JSON path | 类型 | 含义 |
|
||||
| --- | --- | --- |
|
||||
| `status.observedGeneration` | int64 | 最近完成有结论协调的 generation |
|
||||
| `status.phase` | enum | controller 状态机的权威 checkpoint |
|
||||
| `status.database` | string | 应用语义默认值后的实际 database 名称 |
|
||||
| `status.loginRole` | string | 应用语义默认值后的实际 owner/login role 名称 |
|
||||
| `status.databaseOID` | uint32 | 回读的 database OID，仅供诊断 |
|
||||
| `status.credential.secretRef.name` | string | 同 namespace 目标 Secret 名称 |
|
||||
| `status.credential.openBaoURL` | string | 完整 KV v2 API URL，不含认证信息 |
|
||||
| `status.conditions[]` | `metav1.Condition` | 至少包含唯一的 `Ready` |
|
||||
|
||||
Secret reference 不重复 namespace，因为它必定与 Tenant 同 namespace。OpenBao URL 格式
|
||||
为 `<consumer-address>/v1/<mount>/data/<derived-path>`；不得包含 Token、用户名、密码或
|
||||
query credential。
|
||||
|
||||
Tenant phase 枚举为 `Pending`、`Planned`、`CredentialCreated`、`RoleCreated`、
|
||||
`DatabaseCreated`、`ExternalSecretCreated`、`CredentialProjected`、`Ready`、`Deleting`。
|
||||
它不包含 `Failed` 或 `Retained`；失败类型由 Condition Reason 表达。
|
||||
|
||||
print columns：`Instance`、`Database`、`Phase`、`Secret`、`Ready`、`Age`。完整 OpenBao URL 只在
|
||||
YAML/JSON status 中输出。
|
||||
|
||||
两个 Kind 的 `status.phase` 都是 controller 状态机的权威 checkpoint。controller 用它
|
||||
选择下一候选动作，但必须在动作前后核对外部事实，不能仅凭 phase 跳过幂等检查。status
|
||||
丢失或领先于实际状态时必须保守重建/纠正。自动化就绪判断仍应读取 `Ready` Condition；
|
||||
phase 用于进度展示、恢复和排障。
|
||||
|
||||
## Condition
|
||||
|
||||
每种类型最多一个 Condition；更新必须保留正确的 `lastTransitionTime` 语义。
|
||||
|
||||
| Reason | Kind | 可重试性 |
|
||||
| --- | --- | --- |
|
||||
| `Reconciling` | 两者 | 正常进行中 |
|
||||
| `Ready` | 两者 | 已收敛 |
|
||||
| `InvalidSpec` | 两者 | 修改 spec 前不会恢复 |
|
||||
| `ImmutableField` | Tenant | 恢复原值或重新迁移 |
|
||||
| `DependencyUnavailable` | 两者 | 自动重试 |
|
||||
| `AuthenticationFailed` | Instance | 修复凭据/TLS 后重试 |
|
||||
| `InsufficientPrivileges` | Instance | 修复管理 role 后重试 |
|
||||
| `InstanceNotReady` | Tenant | Instance 恢复后重试 |
|
||||
| `Conflict` | Tenant | 人工解除名称/所有权冲突 |
|
||||
| `ProvisioningFailed` | Tenant | 按错误类别退避重试 |
|
||||
| `CredentialProjectionFailed` | Tenant | ESO/Secret 恢复后重试 |
|
||||
|
||||
`Ready=True` 必须使用 Reason `Ready`。处理中为 `Unknown/Reconciling`；已知未满足合同为
|
||||
`False`。Condition message 可以包含资源名和错误类别，禁止包含凭据值或完整 Secret。
|
||||
|
||||
## 删除语义
|
||||
|
||||
- `Retain` 不需要等待外部依赖；删除 CR 后外部记录保留原 UID 并标记 unmanaged。
|
||||
- `Delete` 添加 finalizer，严格按规格的所有权验证和清理顺序执行；失败保持 finalizer。
|
||||
- Instance 开始受管时即添加并保存 finalizer；删除时停止新供应，存在 Tenant 引用
|
||||
（包括正在删除的 Tenant）就保留 finalizer，无引用才移除。引用查询失败时继续等待。
|
||||
不级联删除 Tenant 或外部资源；管理员可使用运维逃生流程。
|
||||
- finalizer 不禁止创建 Tenant CR；并发创建者遇到删除中或不存在的 Instance 不得
|
||||
开始供应。首版不增加跨对象锁或准入控制，不承诺跨对象原子删除。
|
||||
|
||||
## 示例
|
||||
|
||||
```yaml
|
||||
apiVersion: database.ayatori.ddupan.top/v1alpha1
|
||||
kind: PostgreSQLInstance
|
||||
metadata:
|
||||
name: shared
|
||||
spec:
|
||||
endpoint:
|
||||
host: postgresql.home.arpa
|
||||
hostaddr: 192.0.2.10
|
||||
port: 5432
|
||||
database: postgres
|
||||
sslMode: verify-full
|
||||
adminCredentialRef:
|
||||
name: shared-postgresql-admin
|
||||
---
|
||||
apiVersion: database.ayatori.ddupan.top/v1alpha1
|
||||
kind: PostgreSQLTenant
|
||||
metadata:
|
||||
name: netbox
|
||||
namespace: netbox
|
||||
spec:
|
||||
instanceRef: shared
|
||||
database: netbox
|
||||
loginRole: netbox
|
||||
extensions: [pg_trgm]
|
||||
credential:
|
||||
secretName: shared-netbox-database-credentials
|
||||
deletionPolicy: Retain
|
||||
```
|
||||
@@ -0,0 +1,99 @@
|
||||
# 系统架构
|
||||
|
||||
本文是已批准 [`specification.md`](specification.md) 的架构视图。规范定义外部行为，
|
||||
本文解释组件边界；二者冲突时以规范为准。Ayatori Database 模块目前只有首批领域模型，尚未
|
||||
注册 API 或接入运行链路。
|
||||
|
||||
## 组件与数据流
|
||||
|
||||
```text
|
||||
GitOps / kubectl / Terraform / Backstage
|
||||
|
|
||||
v
|
||||
Kubernetes API (CRD)
|
||||
|
|
||||
v
|
||||
Ayatori Database controller
|
||||
| | |
|
||||
v v v
|
||||
PostgreSQL DBMS OpenBao KV ExternalSecret
|
||||
catalog+registry |
|
||||
v
|
||||
Kubernetes Secret
|
||||
```
|
||||
|
||||
- Kubernetes `spec` 保存期望状态；`status.phase` 保存 controller 状态机 checkpoint，
|
||||
其他 status 字段保存可重建的观察结果。整个 status 都必须能由外部事实保守恢复。
|
||||
- PostgreSQL catalog 保存 database、role、grant 和 extension 的实际状态。
|
||||
- 两个 CR 的 `status.phase` 是 controller 状态机的权威 checkpoint。
|
||||
- PostgreSQL 管理 database 中的 controller registry 只负责所有权、安装身份和保留标记。
|
||||
- OpenBao KV v2 是应用凭据的事实来源。
|
||||
- External Secrets Operator（ESO）读取 OpenBao，并创建应用使用的 Kubernetes Secret。
|
||||
|
||||
controller 不运行 PostgreSQL/OpenBao，不管理 VM、存储、备份或 OpenBao PKI，也不直接
|
||||
把明文凭据写入 Kubernetes API。
|
||||
|
||||
## 资源模型
|
||||
|
||||
`PostgreSQLInstance` 是 cluster-scoped，由平台管理员创建，描述外部 PostgreSQL 的
|
||||
DNS host、IP host address、端口、管理 database、TLS 模式和管理 Secret 引用。
|
||||
实际可安装扩展由应用层查询后交给领域对象判定，v1alpha1 不实现管理员 allowlist。
|
||||
|
||||
管理连接使用管理员维护的 ExternalSecret 经 ESO 同步到 controller namespace 的
|
||||
Secret；Instance 只选择 Secret 名称与字段，controller 只读，不直接从 Bao 获取
|
||||
管理凭据。Tenant 凭据的创建、读取与销毁仍由 controller 直接访问 Bao。
|
||||
|
||||
`PostgreSQLTenant` 是 namespaced。一个 Tenant 对应一个 database、一个同时作为 owner
|
||||
的 login role、一组只允许追加的 extension、一个由 controller 推导的 OpenBao KV
|
||||
记录，以及同 namespace 的 ExternalSecret 和目标 Secret。
|
||||
|
||||
Tenant namespace 只提供 Kubernetes RBAC 和身份边界。database 与 role 名称在一个
|
||||
Instance 内仍然全局唯一。
|
||||
|
||||
## Reconcile 与所有权
|
||||
|
||||
系统采用最终一致性，不在 Kubernetes、PostgreSQL、OpenBao 和 ESO 之间假装存在分布式
|
||||
事务。每个外部写入前在 CR status 记录阶段，执行幂等操作，回读验证，再推进阶段：
|
||||
|
||||
```text
|
||||
Planned -> CredentialCreated -> RoleCreated -> DatabaseCreated
|
||||
-> ExternalSecretCreated -> CredentialProjected -> Ready
|
||||
```
|
||||
|
||||
controller 每轮同时读取 CR、registry、PostgreSQL catalog、OpenBao metadata 和 ESO
|
||||
投射状态。`status.phase` 是状态机 checkpoint，但不能替代外部回读；丢失或与事实冲突
|
||||
时必须保守重建/纠正。`metadata.generation` 只表示 spec 修改；Condition 的
|
||||
`observedGeneration` 表示该版本是否已经完成一次有结论的协调。
|
||||
|
||||
所有权使用 Instance UID、Tenant UID 与 namespace/name 验证。database/role COMMENT
|
||||
可以辅助排障，但不能代替 registry。未知资源只报告 `Conflict`，不得修改、接管或
|
||||
删除。Retain 后用相同名称重建 CR 会获得新 UID，因此仍然冲突。
|
||||
|
||||
## 创建与删除边界
|
||||
|
||||
创建时先校验全部输入和冲突，再生成一次密码并写入 OpenBao，随后创建 role、database、
|
||||
extension 和 ExternalSecret。只有 ESO 已投射 Secret 且应用凭据实际登录成功，Tenant
|
||||
才可 Ready。
|
||||
|
||||
`Retain` 是默认删除策略，只移除 Kubernetes 管理关系并保留外部资源。显式 `Delete`
|
||||
使用 finalizer，在重新验证所有权后依次删除 ExternalSecret/Secret、连接、database、
|
||||
role、OpenBao KV 历史和 registry。详细恢复与逃生步骤见
|
||||
[`operations.md`](operations.md)。
|
||||
|
||||
## 网络与 TLS
|
||||
|
||||
Instance 同时公布 DNS `host` 和 IP `hostaddr`。PostgreSQL server 证书必须包含对应的
|
||||
DNS SAN 和 IP SAN，消费者自行选择可达目标，并可使用 `verify-full` 验证。OpenBao PKI
|
||||
持有 CA 私钥并签发服务端证书；controller 只挂载公开 CA bundle。
|
||||
|
||||
OpenBao 的 controller 内部地址和外部消费者地址可以不同。Tenant status 同时提供目标
|
||||
Kubernetes Secret reference 和不含认证信息的 OpenBao KV v2 API URL。
|
||||
|
||||
## 文档入口
|
||||
|
||||
- API 字段与 Condition：[`api-reference.md`](api-reference.md)
|
||||
- 安装、依赖和配置：[`deployment.md`](deployment.md)
|
||||
- 本地与 CI 测试：[`development.md`](development.md)
|
||||
- 安全模型与最小权限：[`security.md`](security.md)
|
||||
- 现有数据库迁移：[`migration.md`](migration.md)
|
||||
- 日常排障和删除逃生：[`operations.md`](operations.md)
|
||||
@@ -0,0 +1,130 @@
|
||||
# 部署与配置
|
||||
|
||||
> 本页迁入作为 Database 模块的目标部署合同。Ayatori manager flags、manifests 与发布装配尚未
|
||||
> 实现；原设计行为保持有效，但当前仓库不能直接按本页完成部署。
|
||||
|
||||
| 项目 | 内容 |
|
||||
| --- | --- |
|
||||
| 状态 | Review |
|
||||
| 环境 | homelab Kubernetes + 外部 PostgreSQL/OpenBao |
|
||||
| 最后更新 | 2026-09-10 |
|
||||
|
||||
本文定义 v1alpha1 的运行依赖、启动顺序和部署级配置。当前 manifests 尚未实现这些
|
||||
配置，示例是后续实现合同，不可直接用于现有脚手架。
|
||||
|
||||
## 依赖与顺序
|
||||
|
||||
1. 准备 PostgreSQL VM、持久盘、备份和网络入口。
|
||||
2. 用 OpenBao PKI 签发 PostgreSQL server 证书，包含 Instance `host` 的 DNS SAN 与
|
||||
`hostaddr` 的 IP SAN；配置 PostgreSQL 强制 TLS。
|
||||
3. 创建 PostgreSQL controller 管理 role 和管理 database 连接权限。
|
||||
4. 在 OpenBao KV v2 写入管理 role 凭据。
|
||||
5. 配置 OpenBao Kubernetes auth、controller policy 和面向 ESO 的读取 policy。
|
||||
6. 安装 ESO，配置独立的管理凭据同步身份和租户凭据读取身份。管理员在 controller
|
||||
namespace 创建管理 ExternalSecret，确认管理 Secret 已同步；另创建供租户使用的
|
||||
`ClusterSecretStore`。
|
||||
7. 创建公开 CA bundle ConfigMap，并挂载到 controller 和需要直接验证数据库的应用。
|
||||
8. 部署 controller，再创建 Instance；等待 Ready 后才创建 Tenant。
|
||||
|
||||
任何一步都不得把真实密码、Token、kubeconfig 或 CA 私钥提交进 Git。
|
||||
|
||||
## Controller 配置合同
|
||||
|
||||
controller 使用以下 CLI flags。必填项缺失、路径无效或 duration 不为正数时，进程必须
|
||||
在启动 manager 前失败；不得等到 reconcile 时才逐个资源报告配置错误。
|
||||
|
||||
| CLI flag | 必填/默认 | 说明 |
|
||||
| --- | --- | --- |
|
||||
| `--openbao-address` | 必填 | controller 可访问的 OpenBao API address |
|
||||
| `--openbao-consumer-address` | 默认同 `--openbao-address` | 写入 Tenant status，必须能被预期外部消费者解析 |
|
||||
| `--openbao-auth-mount` | `kubernetes` | Kubernetes auth mount 名称 |
|
||||
| `--openbao-auth-role` | 必填 | controller ServiceAccount 对应 role |
|
||||
| `--openbao-kv-mount` | `kv` | KV v2 mount；开发可显式用 `secret` |
|
||||
| `--openbao-service-account-token-path` | `/var/run/secrets/kubernetes.io/serviceaccount/token` | Kubernetes auth 使用的投射 token 文件 |
|
||||
| `--openbao-tenant-base-path` | 默认 `postgresql-tenants` | controller 专属 mount-relative 前缀 |
|
||||
| `--external-secret-store-name` | 必填 | controller 创建的 ExternalSecret 固定引用 |
|
||||
| `--postgresql-ca-bundle-path` | PostgreSQL TLS 模式必填 | 只读 PEM trust bundle，不含私钥 |
|
||||
| `--reconcile-timeout` | `30s` | 单轮 reconcile 中外部操作的总期限，必须大于零 |
|
||||
|
||||
address 必须是绝对 `http` 或 `https` URL，不允许 userinfo、query 或 fragment，末尾 `/`
|
||||
在规范化后移除。mount、auth mount 和 base path 都使用 mount-relative path 语义，不以
|
||||
`/` 开头，不含空段、`.` 或 `..`；base path 还不得编码 KV v2 的 `data`/`metadata`
|
||||
API 层。生产环境的 `--openbao-address` 必须使用 HTTPS；HTTP 只用于明确的开发 fixture。
|
||||
|
||||
Tenant 路径固定推导为 `<base-path>/<namespace>/<metadata.name>`。namespace/name 都已通过
|
||||
Kubernetes 名称校验，因此不再允许 CR 提供任意路径。KV v2 API URL 使用 consumer
|
||||
address 拼为 `<address>/v1/<mount>/data/<base-path>/<namespace>/<metadata.name>`。
|
||||
|
||||
base path 必须是合法 mount-relative path，不以 `/` 开头且不包含空段、`.`、`..`、
|
||||
`data`/`metadata` API 层。ExternalSecret 固定命名为
|
||||
`<instanceRef>-<metadata.name>-postgresql`；目标 Secret 可由 Tenant 指定，但名称必须
|
||||
满足 Kubernetes Secret 名称校验，不限制命名内容，默认与 ExternalSecret 同名。
|
||||
|
||||
配置变化不得隐式迁移既有凭据。修改 KV mount/base path 或 consumer address 前必须
|
||||
停止 controller、评估现有 Tenant，并走明确迁移；实现应把 mount/base path 视为安装
|
||||
身份的一部分并在 registry 留存，以便检测错误配置。
|
||||
|
||||
## PostgreSQL 管理 role
|
||||
|
||||
生产部署禁止使用 superuser。管理 role 至少需要：
|
||||
|
||||
- 连接管理 database、读取必要 catalog；
|
||||
- 创建/修改受管 login role；
|
||||
- 创建 database 并指定 owner；
|
||||
- 撤销 `PUBLIC` CONNECT、授予租户 role CONNECT；
|
||||
- 连接租户 database 并创建实例实际支持、租户申请的 extension；
|
||||
- 创建和维护 controller 专属 registry schema/table；
|
||||
- `Delete` 时禁止连接、终止目标 database session、删除已验证归属的 database/role。
|
||||
|
||||
部分 PostgreSQL 操作天然要求较高权限，尤其终止其他 session 和安装某些 extension。
|
||||
应优先使用 PostgreSQL 预定义角色、受控 SECURITY DEFINER 管理函数或限定数据库的
|
||||
授权；任何不得不使用 superuser 的 extension 都必须按实例单独记录，不得扩大默认
|
||||
controller 权限。最终可执行 SQL grant 将随 PostgreSQL adapter 集成测试固化。
|
||||
|
||||
## OpenBao 与 ESO
|
||||
|
||||
controller policy 仅允许在固定 tenant base path 下 create/read/update/delete KV v2
|
||||
data 和 metadata，Delete 必须能永久删除全部版本及 metadata；不读取管理凭据路径。
|
||||
|
||||
管理凭据由管理员维护的 ExternalSecret 同步到 controller namespace；其 ESO 身份
|
||||
只读对应管理路径，不能供 Tenant 使用。租户 ESO 身份只读 tenant base path，不得
|
||||
读取 PostgreSQL 管理凭据。controller 不创建或修改管理 ExternalSecret／Secret。
|
||||
`ClusterSecretStore` 由平台管理员创建，controller 只引用，不创建或修改 Store。
|
||||
controller 创建的 ExternalSecret 与 Tenant 同 namespace，并设置 ownerReference；目标
|
||||
Secret 包含固定七键：`username`、`password`、`database`、`host`、`hostaddr`、`port`、
|
||||
`sslmode`。
|
||||
|
||||
## Kubernetes RBAC
|
||||
|
||||
- controller 可读/写 Instance、Tenant 的 status/finalizer 和 Event。
|
||||
- controller 可在 Tenant namespace 创建、读取、更新、删除 ExternalSecret，并只读检查
|
||||
对应 Secret 是否完成投射。
|
||||
- namespace 用户可以管理本 namespace Tenant，但不能管理 Instance、Store、controller
|
||||
配置或其他 namespace 的 ExternalSecret。
|
||||
- controller 只在自身 namespace 读取所引用管理 Secret 的 data，不获得跨 namespace
|
||||
的管理 Secret 读取权限。Instance 不允许自选 Secret namespace。
|
||||
- 对应用目标 Secret，controller 无需读取 data；验证登录使用从 OpenBao 读取的应用
|
||||
凭据，只检查 Secret 存在性和 ESO 状态。
|
||||
|
||||
## 升级与回滚
|
||||
|
||||
v1alpha1 尚不承诺跨版本转换。升级前备份 CR、PostgreSQL registry 和 OpenBao metadata，
|
||||
先在隔离 Kind 环境运行 E2E。禁止在同一组 CR 上同时运行两个 controller 版本。若新版本
|
||||
在执行任何破坏性迁移前失败，可回滚镜像；涉及 API/storage 或 registry schema 迁移时，
|
||||
必须先写独立升级规格和回滚步骤。
|
||||
|
||||
## 上线验证
|
||||
|
||||
```text
|
||||
PostgreSQL TLS 与备份验证
|
||||
-> OpenBao auth/policy 验证
|
||||
-> ClusterSecretStore Ready
|
||||
-> controller Ready/leader elected
|
||||
-> Instance Ready
|
||||
-> 测试 Tenant Ready
|
||||
-> DNS host 与 IP hostaddr 分别登录
|
||||
-> 删除测试 Tenant 并验证所选策略
|
||||
```
|
||||
|
||||
生产 homelab 上线前还必须完成 [`security.md`](security.md) 的权限检查和
|
||||
[`operations.md`](operations.md) 的备份/逃生检查。
|
||||
@@ -0,0 +1,205 @@
|
||||
# 开发与测试环境
|
||||
|
||||
> 本页迁入作为 Database 模块的测试分层与 fixture 合同。旧项目的 Make target、devcontainer
|
||||
> 和脚手架版本尚未适配 Ayatori；实现时应复用 Ayatori 现有工具链，并保持这里定义的测试边界。
|
||||
|
||||
本项目同时依赖 Kubernetes API、PostgreSQL、OpenBao 和 ESO。日常开发不连接 homelab
|
||||
中的真实服务：Kubernetes 使用 envtest 或一次性 Kind，另外两个依赖使用一次性
|
||||
容器。这样既避免污染真实数据，也能把启动顺序固化为命令。
|
||||
|
||||
## 是否需要开发 VM
|
||||
|
||||
默认不需要。仓库的 devcontainer 使用独立 Docker-in-Docker daemon，Go 工具链、
|
||||
Kind 节点和依赖容器都与宿主机环境隔离。宿主机只需要能够运行支持 privileged
|
||||
container 的 Docker/Dev Container 环境。
|
||||
|
||||
只有以下情况才建议增加一台可随时重建的开发 VM：
|
||||
|
||||
- 宿主机不允许 privileged devcontainer；
|
||||
- 无法安全使用 Docker socket 或 Docker-in-Docker；
|
||||
- 本机地址段与 Kind/Docker 网络持续冲突；
|
||||
- 需要长期运行、接近 homelab 网络和 TLS 配置的验收环境。
|
||||
|
||||
即使使用 VM，也应在 VM 内继续执行本文相同的容器化流程；不要把 VM 配置成第二套
|
||||
手工维护的开发环境。
|
||||
|
||||
## 环境分层
|
||||
|
||||
| 层次 | Kubernetes | PostgreSQL / OpenBao | 用途 |
|
||||
| --- | --- | --- | --- |
|
||||
| 单元测试 | fake client | fake client | SQL 计划、状态转换和错误分类 |
|
||||
| controller 集成测试 | envtest | fake adapter | CRD、watch、status、finalizer、ExternalSecret 对象 |
|
||||
| adapter 集成测试 | 不需要 | Docker Compose | 真实协议、权限和幂等行为 |
|
||||
| E2E | 一次性 Kind + ESO | Kind 内测试实例 | 凭据投射、TLS、完整网络和删除路径 |
|
||||
|
||||
envtest 只启动 API server 和 etcd，没有 kubelet、scheduler、ESO 或 controller-manager，
|
||||
因此不能用它验证 Deployment、Pod 调度或 Service 网络。此类行为必须留给 Kind
|
||||
E2E。
|
||||
|
||||
## 首次准备
|
||||
|
||||
推荐用支持 Dev Containers 的编辑器打开仓库。devcontainer 会提供 Go、Docker、
|
||||
Kubebuilder、Kind 和 kubectl。脚本固定 Kubebuilder 4.15.0、Kind 0.33.0 和
|
||||
kubectl 1.36.0，与当前脚手架和 Kubernetes Go module 对齐。容器启动后先确认：
|
||||
|
||||
```sh
|
||||
go version
|
||||
docker info
|
||||
kubebuilder version
|
||||
kind version
|
||||
kubectl version --client
|
||||
```
|
||||
|
||||
不要在仓库中保存真实 OpenBao Token、数据库密码或 kubeconfig。Compose 中的
|
||||
`postgres-dev-only` 和 `dev-only-root-token` 是仅绑定回环地址、随容器销毁的公开
|
||||
测试值，不得复制到其他环境。
|
||||
|
||||
## 日常开发的正确顺序
|
||||
|
||||
### 1. 生成并验证纯 Go/Kubernetes 部分
|
||||
|
||||
```sh
|
||||
make manifests generate
|
||||
make test
|
||||
make lint
|
||||
```
|
||||
|
||||
`make test` 会下载与 `go.mod` 中 Kubernetes minor 版本匹配的 envtest 二进制，
|
||||
启动临时 API server/etcd，测试结束后自动关闭。
|
||||
|
||||
规格实现后，快速测试必须覆盖默认值/校验、Condition `observedGeneration`、两个 CR 的
|
||||
status 状态机、不可变字段、extension 只追加、registry 所有权和外部错误分类。envtest 只断言 controller 创建了正确
|
||||
的 ExternalSecret；它不能证明 ESO 已生成 Secret。
|
||||
|
||||
### 2. 启动 PostgreSQL/OpenBao adapter 依赖
|
||||
|
||||
只有开发 PostgreSQL/OpenBao adapter 或完整 reconcile 时才需要：
|
||||
|
||||
```sh
|
||||
make dev-up
|
||||
make dev-smoke
|
||||
```
|
||||
|
||||
启动顺序由 Compose healthcheck 保证：
|
||||
|
||||
1. 创建独立 Compose 网络；
|
||||
2. 启动 PostgreSQL 和 OpenBao；
|
||||
3. 等待 PostgreSQL `pg_isready` 成功；
|
||||
4. 等待 OpenBao `bao status` 成功；
|
||||
5. smoke test 执行 `SELECT 1`；
|
||||
6. smoke test 在 OpenBao dev server 默认的 `secret/` KV v2 mount 写入并读回测试管理
|
||||
凭据。
|
||||
|
||||
本机进程使用以下端点：
|
||||
|
||||
```text
|
||||
PostgreSQL: postgresql://postgres:[email protected]:15432/postgres
|
||||
OpenBao: http://127.0.0.1:18200
|
||||
Token: dev-only-root-token
|
||||
```
|
||||
|
||||
若端口冲突，可以只对当前命令覆盖：
|
||||
|
||||
```sh
|
||||
POSTGRES_DEV_PORT=25432 OPENBAO_DEV_PORT=28200 make dev-up
|
||||
```
|
||||
|
||||
后续执行 `dev-smoke` 和 controller 时必须使用相同端口变量。
|
||||
|
||||
Compose 使用明文 PostgreSQL/OpenBao dev 模式，不覆盖生产 TLS 合同。DNS SAN、IP SAN、
|
||||
Kubernetes auth、最小 policy 和 ESO 必须在 Kind E2E fixture 中验证。
|
||||
|
||||
### 3. 运行针对临时依赖的测试或 controller
|
||||
|
||||
adapter 集成测试通过独立 Make target 执行，不默认塞进快速单元测试：
|
||||
|
||||
```sh
|
||||
make test-integration
|
||||
```
|
||||
|
||||
该 target 会启动一次性 Compose 依赖，并通过 `POSTGRES_TEST_DSN` 把测试指向开发
|
||||
PostgreSQL。registry 测试会删除并重建固定的测试 schema，因此禁止将该变量指向真实
|
||||
homelab database。测试后运行 `make dev-down` 清理依赖。
|
||||
|
||||
Gitea Actions 的 job 本身运行在 Docker container 中，不能通过 `127.0.0.1` 访问
|
||||
Docker host 上发布的 Compose 端口。CI 会暂时将 job container 加入 Compose 网络，
|
||||
并通过 `postgres:5432` 运行集成测试；清理前先断开该网络，才能删除 Compose
|
||||
network。本机执行仍使用默认的 `127.0.0.1:15432`。
|
||||
|
||||
本机运行 controller 时，先确认当前 kubeconfig 指向专用 Kind，而不是真实 homelab：
|
||||
|
||||
```sh
|
||||
kubectl config current-context
|
||||
make setup-test-e2e
|
||||
kubectl config current-context
|
||||
make install
|
||||
make run
|
||||
```
|
||||
|
||||
此时 controller 运行在开发容器内，可以直接访问上面的回环端口。若要验证 Tenant
|
||||
Ready，专用 Kind 还必须安装 ESO、创建测试 ClusterSecretStore，并让 Kind workload
|
||||
能够访问测试 OpenBao。不要把包含
|
||||
`127.0.0.1` 端点的样例部署到 Kind 内；Pod 中的回环地址只指向 Pod 自身。
|
||||
|
||||
### 4. 清理
|
||||
|
||||
```sh
|
||||
make dev-down
|
||||
make cleanup-test-e2e
|
||||
```
|
||||
|
||||
`dev-down` 会删除 Compose volume；所有数据库和 OpenBao dev 数据都应视为一次性。
|
||||
|
||||
## E2E 顺序
|
||||
|
||||
CI 的 E2E 与本机 `make run` 不同：controller 会作为 Pod 运行在 Kind 中。因此完整
|
||||
E2E fixture 必须把测试 PostgreSQL、OpenBao 和 ESO 部署进 Kind，并等待依赖 Ready 后
|
||||
再创建 `PostgreSQLInstance` 和 `PostgreSQLTenant`：
|
||||
|
||||
```text
|
||||
创建 Kind
|
||||
-> 安装 CRD
|
||||
-> 部署 PostgreSQL/OpenBao fixture，签发含 DNS/IP SAN 的测试证书
|
||||
-> 安装 ESO，配置 OpenBao auth/policy 和 ClusterSecretStore
|
||||
-> 等待依赖 Ready 并写入测试管理凭据
|
||||
-> 构建并加载 controller image
|
||||
-> 部署 controller
|
||||
-> 创建 Instance
|
||||
-> 等待 Instance Ready
|
||||
-> 创建 Tenant
|
||||
-> 等待 Tenant Ready
|
||||
-> 验证 registry、PostgreSQL catalog、OpenBao KV、ExternalSecret 和 Secret
|
||||
-> 分别使用 DNS host 与 IP hostaddr 登录
|
||||
-> 删除 Tenant 并分别验证 Retain 与 Delete（含故障点重试）
|
||||
-> 删除 Kind
|
||||
```
|
||||
|
||||
当前 controller 已实现第一条 Instance Ready 纵向链路：E2E fixture 在 Kind 内启动
|
||||
PostgreSQL/OpenBao，配置 Kubernetes auth，验证管理凭据读取、PostgreSQL 登录、registry
|
||||
migration 和 Instance Ready。Tenant provisioning、ESO、TLS DNS/IP SAN 与删除路径仍需
|
||||
后续纵向切片覆盖，不能从 Instance Ready 推断这些合同已经通过。
|
||||
|
||||
## 测试数据与泄漏检查
|
||||
|
||||
- 只使用显眼的固定 canary 测试密码，测试后扫描日志、Event、Condition、metrics 和
|
||||
CR dump，出现 canary 即失败。
|
||||
- 每个最终一致性阶段都注入一次中断，重启后验证密码不变且阶段只向前推进。
|
||||
- 清空、落后或伪造超前的 `status.phase` 后验证它能从外部事实保守恢复/纠正，且不会
|
||||
跳过任何回读。
|
||||
- 为未知同名 database、role、Bao record 和伪造 COMMENT 分别构造 Conflict。
|
||||
- Delete 在每个外部删除步骤失败后重试，确认未误删非当前 UID 资源。
|
||||
- 迁移测试按 [`migration.md`](migration.md) 完整执行，不以单纯 `pg_restore` 成功代替
|
||||
应用读写和回滚验证。
|
||||
|
||||
## 故障排查
|
||||
|
||||
查看依赖状态与日志：
|
||||
|
||||
```sh
|
||||
docker compose -f hack/dev/compose.yaml ps
|
||||
docker compose -f hack/dev/compose.yaml logs postgres openbao
|
||||
```
|
||||
|
||||
如果 envtest 报端口监听失败，通常是当前执行环境禁止监听回环端口，而非 controller
|
||||
失败；在 devcontainer 或允许本机监听的 runner 中执行。若 Kind 无法创建，先运行
|
||||
`docker info`，确认当前用户可以访问 devcontainer 内的 Docker daemon。
|
||||
@@ -0,0 +1,230 @@
|
||||
# Instance 领域对象规格
|
||||
|
||||
状态：Draft，含已确认决策。日期：2026-09-13。
|
||||
|
||||
上层合并边界见 [ADR-0008](../decisions/0008-merge-Ayatori Database controller.md)。本文只展开 Instance，不包含 Tenant 的供应
|
||||
实现，也不新增 CRD 字段。设计签名用于评审职责与行为，不是待复制的 Go 接口代码。
|
||||
|
||||
## 1. 对象职责与生命周期
|
||||
|
||||
Instance 表示一次登记的 PostgreSQL 管理对象，是聚合根。它负责字段与策略校验、
|
||||
根据观察结果判断能力是否满足要求、保护状态转换规则；不登录数据库，不读取 Bao，
|
||||
不查询权限或初始化 registry。
|
||||
|
||||
本草案选择：**领域对象只接收数据并做业务决策，不直接或通过端口、回调访问外部。**
|
||||
应用层调用适配器获取事实、执行被允许的操作，并将观察结果交回对象。Instance 不接收
|
||||
context、客户端或 IO 接口。领域行为不是公共 SetReady：调用方提供事实，不能指定结论。
|
||||
|
||||
每轮从 CR 重建一个 Instance；对象不跨 reconcile 缓存，也不是线程共享单例。
|
||||
管理连接可由装配层跨轮次复用，但连接复用不代表上次能力验证仍然成立。
|
||||
|
||||
身份与 endpoint 以管理员声明为准。改变 endpoint 不验证是否同一物理服务器或
|
||||
registry，不增加安装身份连续性检查；只使旧观察失效，按新配置重验管理能力。
|
||||
新 CR 是新 Instance，不自动获得旧 UID 资源的所有权，也不迁移或清理旧目标。
|
||||
下文“观察绑定匹配”仅指结果属于本轮身份／配置，不是物理服务器身份认证协议。
|
||||
|
||||
## 2. 字段与值对象
|
||||
|
||||
所有可变状态封装在对象内部。构造后身份和本轮 definition 不可变；配置变更通过
|
||||
下一轮装载新的 definition 处理，不提供任意 SetPhase/SetReady/SetEndpoint。
|
||||
|
||||
| 字段 | 类型与内容 | 来源／持久化 | 修改规则 |
|
||||
| --- | --- | --- | --- |
|
||||
| identity | InstanceIdentity：UID、name | CR metadata | 本次对象身份内不可变；同名新 UID 是新对象 |
|
||||
| revision | 正整数，期望配置版本 | metadata.generation | 本轮不可变；不是物理服务器版本 |
|
||||
| definition.endpoint | Endpoint：host、hostaddr、port、managementDatabase、tlsMode | CR spec | 本轮不可变；新配置重验 |
|
||||
| definition.adminCredential | CredentialReference：name、usernameKey、passwordKey | CR spec | 只引用 controller namespace 的管理 Secret，不存明文 |
|
||||
| availableExtensions | 可选的实际可安装扩展集合 | 应用层从目标 PostgreSQL 查询；本轮观察，不新增 status 字段 | 未观察与已观察的空集合不同；目标变化后旧结果失效 |
|
||||
| checkpoint | Pending/Validating/InitializingRegistry/Ready/Deleting | CR status.phase | 只能由领域动作变更，应用层负责持久化 |
|
||||
| observedRevision | 最近完成有结论协调的版本 | CR status.observedGeneration | 成功或已知失败时更新，单纯记录意图不更新 |
|
||||
| readiness | Unknown/Ready/NotReady，加安全失败类别和操作说明 | 由 status Ready Condition 重建，结果再映射回 Condition | 方法更新；不是第二套持久化状态 |
|
||||
| reportedVersion | 可选服务器版本字符串 | status.postgresqlVersion；验证后从服务器更新 | 仅供展示，不能证明连接成功 |
|
||||
| deleting | 是否已请求删除 | metadata.deletionTimestamp 映射 | 本轮不可变；优先于其他动作 |
|
||||
| evidence | 可选 CapabilityEvidence | 本轮外部回读；不新增 status 字段 | 重建时始终为空，不能从 Ready Condition 伪造 |
|
||||
|
||||
Endpoint 的构造约束沿用 API：非空 host、合法 IP、1–65535 端口、合法 PostgreSQL
|
||||
identifier、显式 TLS mode，禁止隐式降级。CredentialReference 包含合法 Secret 名称
|
||||
及非空字段名，不包含 namespace 或 Bao path；namespace 由应用层固定为 controller
|
||||
自身 namespace。这里校验领域值，不在对象里校验整个 controller 部署配置。
|
||||
|
||||
CapabilityEvidence 包含本轮目标绑定（Instance UID、revision、endpoint、凭据引用）、
|
||||
server version、管理能力检查结果、registry 观察结果。registry 结果区分
|
||||
Absent/NeedsMigration/Usable；连接失败不能当作 Absent。它不包含密码、token 或 DSN。
|
||||
|
||||
管理能力要求来自规格中的 role/database/grant/extension 操作，不等价于“能执行
|
||||
SHOW server_version”。具体权限探测矩阵需在 PostgreSQL 适配器规格中定义，不能
|
||||
让一个没有定义检查内容的布尔值承担验收。
|
||||
|
||||
不属于 Instance 的字段：Tenant 清单、客户端、连接池、token TTL、CA 文件句柄、
|
||||
Kubernetes resourceVersion。resourceVersion 留在应用层作为乐观并发保存的前提。
|
||||
|
||||
### 扩展支持判定（2026-09-14 已确认方向）
|
||||
|
||||
v1alpha1 按目标 PostgreSQL 实际可安装的扩展列表判断请求，不实现管理员 allowlist。
|
||||
allowlist 仅保留为后续可选策略，不接受一个看似生效、实际被忽略的策略字段；现有
|
||||
CRD 的 allowedExtensions 应在对应 API 改动中移除，本次只修订文档。
|
||||
|
||||
应用层查询实际可用扩展并提供与本轮目标绑定的观察；Instance 只做集合判断，不
|
||||
访问数据库。不沿用之前提议的字符正则，不自动改大小写或名称；SQL 适配器仍须
|
||||
安全引用 identifier。可用列表不是已安装列表，也不保证权限或其他安装前提满足。
|
||||
|
||||
未观察／查询失败不得当作空集合或不支持；不得用旧目标的列表授权新目标的操作。
|
||||
非空请求须属于已观察的可用集合，返回不支持的名称；空请求无需扩展支持判定，
|
||||
但不绕过 Instance 的其他就绪要求。安装后仍需回读，不能以集合匹配代替安装验证。
|
||||
列表变化不触发自动卸载；已有扩展的漂移处理留到 Tenant 用例细化。
|
||||
|
||||
## 3. 设计签名
|
||||
|
||||
```text
|
||||
Reconstitute(identity, revision, definition, checkpointSnapshot, deleting)
|
||||
-> Instance | InvalidDefinition
|
||||
|
||||
Instance.BeginValidation() -> Outcome
|
||||
Instance.AssessManagement(observation: CapabilityObservation) -> Outcome
|
||||
Instance.PlanRegistryPreparation(observation: CapabilityObservation)
|
||||
-> AlreadyUsable | PreparationAllowed | PreparationDenied
|
||||
Instance.AssessRegistryResult(result: RegistryPreparationResult) -> Outcome
|
||||
Instance.AssessReadiness(observation: CapabilityObservation) -> Outcome
|
||||
Instance.CheckExtensions(requested: ExtensionSet)
|
||||
-> Accepted | ExtensionsUnsupported | ExtensionSupportUnobserved
|
||||
Instance.RequireProvisioningReady() -> Accepted | InstanceNotReady
|
||||
Instance.BeginDeletion() -> Outcome
|
||||
Instance.Snapshot() -> InstanceSnapshot
|
||||
```
|
||||
|
||||
Outcome 是正常推进、已知失败或方法前提不成立，不包含重试秒数、Kubernetes patch
|
||||
或原始驱动错误。InstanceSnapshot 只包含 checkpoint、observedRevision、readiness、
|
||||
reportedVersion，不能序列化 evidence。快照与集合访问返回值副本。
|
||||
|
||||
CapabilityObservation 是不可变的事实输入：目标绑定、服务器版本、管理能力检查项和
|
||||
registry 观察结果；各检查项区分成功、失败、未观察，未观察不视为成功。失败只含安全
|
||||
类别，不含驱动异常或凭据。对象校验目标绑定与当前身份／配置一致，拒绝不匹配输入，
|
||||
不改变状态；完整性不足不能产生 Ready。观察结果由应用层收集，对象不能自行证明
|
||||
这些事实的真实性或实时性；采集来源、同轮次关联和并发检查由应用层保证。
|
||||
|
||||
RegistryPreparationResult 为操作失败（目标绑定、安全失败类别）或操作后的完整回读
|
||||
观察。单独的“迁移调用成功”不是就绪证据。CapabilityEvidence 是对象接受并判定满足
|
||||
要求的观察值，不是调用方传入的 Ready 布尔值。
|
||||
|
||||
### 构造与恢复
|
||||
|
||||
Reconstitute 校验期望 definition；无效输入不构造一个可参与用例决策的 Instance。
|
||||
入口把 InvalidDefinition 映射成 InvalidSpec，不必为了报告坏 CR 而制造非法领域对象。
|
||||
checkpoint 缺失或未知时保守使用 Pending；reportedVersion 和 Ready 都只是旧观察，
|
||||
evidence 为空。若 observedRevision 与 revision 不一致，旧 Ready 不得通过供应检查。
|
||||
|
||||
### 方法合同
|
||||
|
||||
| 方法 | 前置条件／输入 | 行为与状态变化 | 失败语义 |
|
||||
| --- | --- | --- | --- |
|
||||
| BeginValidation | 未删除；初次登记、配置变更或需重建 checkpoint | 转 Validating，readiness=Unknown，清空 evidence；不做外部 IO，不推进 observedRevision | deleting 时不启动验证 |
|
||||
| AssessManagement | 未删除；Validating；目标匹配的观察 | 判定管理访问、metadata、权限是否满足；registry 可用或可安全准备时转 InitializingRegistry，仍为 Unknown；不执行探测 | 失败保持 Validating，NotReady，observedRevision=当前版本 |
|
||||
| PlanRegistryPreparation | 未删除；InitializingRegistry；本轮前置观察 | 根据管理能力及 registry 现状决定无需写入、允许准备或禁止准备；返回决策，不执行迁移、不标 Ready | 访问失败、不兼容或证据不足时禁止写入，NotReady；保持阶段，更新 observedRevision |
|
||||
| AssessRegistryResult | 未删除；InitializingRegistry；准备结果或无需写入时的完整回读 | 按全部就绪条件判断回读结果；全满足才 Ready，并更新 observedRevision/version/evidence | 操作失败或回读不满足时保持 InitializingRegistry、NotReady；不得提前 Ready |
|
||||
| AssessReadiness | 未删除；Ready；本轮观察 | 配置版本不一致时仅 BeginValidation；否则根据全部观察判断是否仍满足就绪条件 | 访问失败转 Validating/NotReady；registry 缺失或需迁移时转 InitializingRegistry，保存后下一轮修复 |
|
||||
| CheckExtensions | 请求集合；本轮实际可用扩展观察 | 判断请求是否为实际可用集合的子集，返回不支持的名称；无 IO、无状态修改 | ExtensionsUnsupported 或 ExtensionSupportUnobserved；不卸载已存在扩展 |
|
||||
| RequireProvisioningReady | 供 Tenant 用例使用 | 要求未删除、Ready、observedRevision 匹配，并有本次调用链的新鲜完整 evidence | 不满足即 InstanceNotReady；持久化 Ready 本身不构成授权 |
|
||||
| BeginDeletion | deleting=true | 转 Deleting，清除供应能力，Unknown；不执行任何数据库或凭据删除 | 引用检查／finalizer 处理失败不得恢复成可供应 |
|
||||
| Snapshot | 任意合法对象状态 | 返回可安全持久化的结果值 | 不触发 IO，也不改变状态 |
|
||||
|
||||
领域方法只检查对象状态，不知道 checkpoint 是否已落盘。“已持久化 checkpoint”是
|
||||
应用用例执行外部写入的前提。内存字段变成 InitializingRegistry 不代表已保存成功；不能
|
||||
在同一轮无条件接着执行迁移。通过用例测试验证此约束，而不是伪造一个内存事务。
|
||||
|
||||
AssessManagement 成功只是中间步骤，observedRevision 不前移；完成就绪判定或
|
||||
明确失败才产生相应有结论结果。旧版本字符串可供诊断，但失败会清空 evidence。
|
||||
|
||||
Instance 不在本轮暴露 CreateDatabase/DeleteDatabase：Tenant 的供应／销毁授权来自
|
||||
Tenant 和 OwnershipClaim，不是从 Instance.Ready 推导。数据库执行能力如何承接
|
||||
已授权动作，留到 Tenant 对象规格，不在这里设计第二个万能 service。
|
||||
|
||||
## 4. 应用层与外部访问边界
|
||||
|
||||
```text
|
||||
应用层依赖的适配器能力（不传入 Instance）：
|
||||
InspectManagement(context, target) -> ManagementObservation | AccessFailure
|
||||
InspectRegistry(context, target) -> RegistryObservation | AccessFailure
|
||||
EnsureRegistry(context, target) -> Completed | AccessFailure
|
||||
```
|
||||
|
||||
应用层在 IO 前绑定目标并关联结果，领域对象在接受观察时检查身份和配置匹配；旧
|
||||
endpoint 的成功结果不得用于新 endpoint。Inspect 是只读；EnsureRegistry 是幂等初始化／迁移，
|
||||
不能顺带建立 Tenant 数据库或接管未知 schema。Completed 不足以推进 Ready，必须回读。
|
||||
|
||||
适配器由装配层绑定管理连接；Secret 读取与连接池释放留在该边界之后，Instance
|
||||
管理连接不涉及 Bao token。适配器不得把基础设施异常转换成 Ready。失败区分依赖不可用、
|
||||
认证失败、权限不足和 registry 不兼容；不兼容属于不可安全继续，不自动覆写。
|
||||
registry 不兼容的具体 Condition 映射须在接口规格中确定，不能统一误报权限不足。
|
||||
|
||||
管理连接由应用层从 controller namespace 的 Secret 装配；管理员维护 ExternalSecret，
|
||||
ESO 负责同步。Instance 路径不直接访问 Bao，也不以 Bao／ESO 当前可用性作为就绪条件。
|
||||
首次装配缺少有效 Secret 时失败；已有凭据可正常访问 PG 时继续按 PG 能力判定。
|
||||
检测到所引用 Secret 的有效用户名或密码变化时，应用／基础设施层使用新值重建连接池
|
||||
并重新采集管理能力观察；metadata 或无关字段变化不重建。不要求 Instance generation
|
||||
变化，也不能复用旧连接的成功观察来证明新凭据有效。Secret 变化监听、连接释放和
|
||||
刷新均不进入领域对象；应用层保证旧连接观察不混入刷新后的调用链。
|
||||
controller 不修改 PostgreSQL 密码、不回写 Secret 或 Bao 管理凭据。
|
||||
|
||||
## 5. 状态转换与初始化走查
|
||||
|
||||
```text
|
||||
Pending --BeginValidation/保存--> Validating
|
||||
Validating --AssessManagement(观察)/保存--> InitializingRegistry
|
||||
InitializingRegistry --AssessRegistryResult(回读结果)/保存--> Ready
|
||||
Ready --配置变化或访问失败/保存--> Validating
|
||||
Ready --registry 需修复/保存--> InitializingRegistry
|
||||
任意阶段 --删除请求/保存--> Deleting
|
||||
```
|
||||
|
||||
1. 入口读取 CR，装配 definition、checkpointSnapshot；客户端不注入领域对象。
|
||||
2. 应用层按 checkpoint 协调用例；首次调用 BeginValidation，没有 IO。
|
||||
3. 保存 Validating。若保存失败，结束本轮，不执行 registry 写入。
|
||||
4. 下一轮应用层调用适配器探测实例，将观察交给 AssessManagement；领域判定通过后
|
||||
保存 InitializingRegistry，保存失败则停止，不进行迁移。
|
||||
5. 再下一轮应用层采集前置观察，调用 PlanRegistryPreparation。仅在意图已持久化且
|
||||
领域允许时调用 EnsureRegistry；AlreadyUsable 则跳过写入，PreparationDenied 则
|
||||
保存失败结果并停止。允许的操作完成后回读，交给 AssessRegistryResult 决定能否
|
||||
Ready；操作失败也用安全结果交回，不在应用层直接修改 phase。
|
||||
6. 入口用原 resourceVersion 前提保存快照；并发变更导致冲突时重新装载，不覆盖新状态。
|
||||
7. 后续 Ready 检查先由应用层探测，再调用 AssessReadiness；Tenant 用例同样获取当前事实，不能
|
||||
仅凭另一个 CR 的 Ready Condition 永久缓存授权。实际资源写入仍须处理并发变化。
|
||||
|
||||
阶段调度和外部操作顺序在应用层；“观察是否满足业务要求、是否允许准备 registry、
|
||||
哪些结果算完成、失败退到哪里”在 Instance 方法内。controller 不重复这些规则，
|
||||
也不直接把 phase 设置成 Ready。领域允许操作并不锁住外部世界，适配器仍须保障幂等
|
||||
和并发安全；禁止把旧观察当成永久授权。
|
||||
|
||||
## 6. 不变量与恢复验收
|
||||
|
||||
- UID 不随名称复用；不同 UID 的 evidence/结果不可互用。
|
||||
- 未完成当前配置的能力回读，不能新产生 Ready，也不能通过供应检查。
|
||||
- checkpoint 可以落后或被伪造；每次初始化／供应前都核对事实。status 清空只需重新
|
||||
验证和幂等准备，不删除 registry，更不能重新生成 Tenant 密码。
|
||||
- 迁移成功而 status 保存失败：重试回读已存在 registry，安全完成，不重复破坏性写入。
|
||||
- registry 在 Ready 后消失：下一次回读撤销 Ready，保存修复意图后才能重新准备。
|
||||
- 外部 IO 超时：产生安全失败结果；保存 status 使用仍有效的外层上下文，不能复用
|
||||
已超时的 IO 上下文而丢失失败状态。
|
||||
- 已请求删除的 Instance 不允许新供应；BeginDeletion 不删除 PostgreSQL、Tenant 或
|
||||
Bao。应用层在开始受管时添加并保存 finalizer，而非出现 Tenant 后再添加。
|
||||
删除时查询所有引用它的 Tenant（含删除中的对象）；有引用或查询失败就保留
|
||||
finalizer，确认无引用才移除。引用查询、finalizer 写入和本地连接释放均不属于
|
||||
领域 IO，Instance 只根据删除请求禁用供应能力。
|
||||
- 首版不为 Instance 删除增加跨对象锁或准入控制。并发创建的 Tenant CR 不被
|
||||
finalizer 拦截，但遇到删除中／不存在的 Instance 不得开始供应；不承诺取消
|
||||
已在途的外部操作，也不声称引用查询与移除 finalizer 是跨对象原子事务。
|
||||
- CheckExtensions 失败不能授权扩展安装；可用列表变化不会自行卸载已有扩展。
|
||||
- Snapshot、错误、日志和领域对象格式化不输出明文凭据或 token。
|
||||
- 领域测试只提供观察值，无需数据库、网络、context 或 IO mock；相同状态和输入
|
||||
得到相同决策。缺少检查项、目标不匹配和旧配置结果不得产生 Ready。
|
||||
|
||||
上述每条都对应领域或用例测试；真实权限检查、迁移与并发保障由适配器集成测试
|
||||
验证。本文为设计文档，未执行或宣称通过这些测试。
|
||||
|
||||
## 7. 本轮待评审与后续阻塞项
|
||||
|
||||
本轮请先确认字段归属、应用层采集事实／Instance 纯决策的分工、方法与状态转换合同。
|
||||
管理 Secret 来源、Bao 故障不单独撤销 Instance Ready，以及管理用户名／密码变化时
|
||||
重建连接池，以及管理员声明的 Instance 身份／endpoint 和简化 finalizer 删除规则
|
||||
均已确认。其他决策及未决项见总体草案，不增加后台清扫器或状态字段。
|
||||
|
||||
批准本对象结构不等于批准这些未决行为，也不意味着立刻实现完整供应链路。
|
||||
@@ -0,0 +1,149 @@
|
||||
# 领域模型设计草案
|
||||
|
||||
状态：Draft，含已确认决策。日期：2026-09-13。
|
||||
|
||||
本文定义领域职责、身份与一致性边界，并用对象规格细化字段和方法合同；方法使用
|
||||
设计签名，不固定 Go 目录、SDK 或框架，也不批准实现。外部行为以
|
||||
[系统规格](specification.md) 为准；下列未决问题不能由实现自行决定。
|
||||
PR #6 的代码和已有 registry 表结构是可评估的实现素材，不反向决定领域模型。
|
||||
|
||||
## 1. 领域与统一语言
|
||||
|
||||
本系统的领域是“在共享 PostgreSQL 上供应并管理应用租户”，不是数据库服务器运维。
|
||||
v1alpha1 先采用一个限界上下文，不把 PostgreSQL、Bao、Kubernetes 各自当成业务上下文。
|
||||
|
||||
| 术语 | 含义 | 不是什么 |
|
||||
| --- | --- | --- |
|
||||
| Instance | 平台登记的外部 PostgreSQL 管理对象及其供应策略 | 连接池、VM 或 controller 单例 |
|
||||
| Tenant | 一个应用的数据库使用合同及受管资源生命周期 | PostgreSQL database 的别名 |
|
||||
| Database | 租户数据库的名称、owner、扩展等期望描述与实际观察 | 包含 Bao 登录与连接关闭的操作接口 |
|
||||
| LoginRole | 同时作为 database owner 和应用登录身份的角色 | 额外的 NOLOGIN owner |
|
||||
| OwnershipClaim | 某个 Tenant 身份对一组资源名称与凭据位置的所有权声明 | 工作流阶段或仅凭名称推断的归属 |
|
||||
| CredentialLocation | 固定推导的凭据位置及所有权关联 | 密码本身或用户可任意选择的 KV path |
|
||||
| CredentialProjection | 把既定凭据交付到目标 Secret 的要求与观察结果 | controller 直接写入明文 Secret |
|
||||
|
||||
UID 表示一次 Kubernetes 对象身份；namespace/name 用于定位，不足以证明归属。
|
||||
database OID 是诊断观察值，不充当本系统的租户身份。
|
||||
|
||||
## 2. 候选聚合边界
|
||||
|
||||
### Instance：实例能力与供应策略
|
||||
|
||||
Instance 是候选聚合根，持有自身身份、endpoint、管理凭据引用、实际可用扩展观察，
|
||||
以及用于判断当前能力的观察结果。它不持有所有 Tenant 对象的集合。
|
||||
|
||||
其行为包括：
|
||||
|
||||
- 判断租户申请的 extension 是否在本实例实际可安装列表中；v1alpha1 暂不实现 allowlist。
|
||||
- 根据管理连接、服务器信息、registry 和权限检查结果判断是否具备供应能力。
|
||||
- 判断配置变化使哪些能力观察过期，禁止以旧 generation 的 Ready 证明新配置可用。
|
||||
- 在 registry 初始化完成并回读验证后，接受新的就绪结果。
|
||||
|
||||
“探测实例”“准备管理 registry”是应用用例协调的外部操作，不是 Instance 的 IO 方法。
|
||||
领域对象只接收观察值，负责前提、规则和状态决策；应用层调用适配器获取事实与执行
|
||||
获准操作。领域对象不持有或调用外部访问端口、客户端或回调。具体选择见
|
||||
[Instance 字段与行为](domain-instance.md)，仍处于待评审状态。
|
||||
|
||||
### Tenant：供应合同与资源生命周期
|
||||
|
||||
Tenant 是另一个候选聚合根，通过身份引用 Instance，而不是 Instance 的聚合成员。
|
||||
操作一个 Tenant 不应要求装载、锁定或保存整个实例的租户集合。
|
||||
|
||||
Tenant 持有有效的 database/role 名称、请求的扩展、凭据交付目标、删除策略，以及
|
||||
已建立的资源绑定。它负责：
|
||||
|
||||
- 检查绑定后的不可变字段、extension 只追加规则。
|
||||
- 判断外部部分状态属于本 Tenant、尚不存在，还是与未知资源冲突。
|
||||
- 决定是否允许继续供应、何时达到 Ready、是否允许释放受管资源。
|
||||
- 按 Retain/Delete 合同限制行为，禁止把保留资源自动认领给同名新 UID。
|
||||
|
||||
Database、LoginRole 和 CredentialProjection 暂不设独立聚合根或独立 CRUD 用例。
|
||||
它们可作为 Tenant 内的资源描述与观察值；有规则才增加行为，不为了“充血”添加方法。
|
||||
真实 PostgreSQL database/role 的存在不意味着内存中必须各有一个有身份的实体。
|
||||
|
||||
聚合边界是业务规则的保护边界，不表示 Tenant 对应的 PostgreSQL、Bao、ESO 资源
|
||||
能够一次事务提交。跨系统供应必须允许部分完成。
|
||||
|
||||
### OwnershipClaim：跨租户唯一性与持久证据
|
||||
|
||||
名称唯一性不可能只靠某个 Tenant 的内存检查保证。需要一项领域能力，在持久化边界
|
||||
原子认领资源；已有 registry 是其适配器候选，仍需结合 catalog 和 Bao metadata 检查。
|
||||
|
||||
Claim 与 Tenant 关联，但不随 Tenant CR 消失：Retain 后证据必须继续存在。因此不能
|
||||
把它仅视为 CR 的附属 status。是否作为独立的小聚合，先以“可独立持久化、保留并保护
|
||||
归属不变量的声明”建模；不因此引入新的 CRD。
|
||||
|
||||
- 同一身份、同一绑定的重复认领可以成功；不同 UID 或不同绑定不能覆盖。
|
||||
- Claim 预留名称不等于证明同名外部资源由本 controller 创建。
|
||||
- 实际写入仍须核对所有权，不能把先查后建当成并发安全保证。
|
||||
- 当前 registry 的数据库事务不能覆盖 Bao；跨实例的凭据路径竞争也不能靠单个
|
||||
registry 的唯一约束解决。写入前提与条件创建协议需单独设计和验收。
|
||||
|
||||
## 3. 领域、用例与适配器的分工
|
||||
|
||||
| 层 | 承担的职责 | 禁止承揽的职责 |
|
||||
| --- | --- | --- |
|
||||
| 领域对象／策略 | 身份、有效合同、归属判断、允许的动作、完成条件 | 外部 IO（包括通过接口间接调用）、解析 CLI、生成 Kubernetes Condition |
|
||||
| 应用用例 | 装载模型与事实、持久化意图、调用能力、回读、提交结果 | 另写一套绕过领域规则的判断流程 |
|
||||
| controller 入口 | CR 映射、调度、watch、重试、status/finalizer 写入 | 在 reconcile 中重新定义业务规则 |
|
||||
| 基础设施适配器 | PostgreSQL、registry、Bao、ESO 的实际读写与并发保障 | 自行决定接管、改密码或扩大删除范围 |
|
||||
| 启动装配 | 校验部署配置，创建共享客户端、连接管理器及用例依赖 | 把连接生命周期当成 Instance 的业务状态 |
|
||||
|
||||
领域可使用独立的身份、endpoint、identifier、extension 集合等值对象，不依赖 CRD
|
||||
类型、pgx pool 或 Bao SDK。Kubernetes 对象的存取与 registry 的存取不是一个通用
|
||||
`Save(Tenant)` 可以原子完成的事情；不虚构跨系统 Unit of Work。
|
||||
|
||||
暂不引入事件总线、事件溯源、通用聚合框架或全套 Repository CRUD。领域建模的依据
|
||||
是业务规则，而不是接口和目录数量。
|
||||
|
||||
## 4. 状态与恢复
|
||||
|
||||
CR `status.phase` 仍是已批准的工作流 checkpoint，不在内存对象或 registry 再建一套
|
||||
权威 phase。领域对象可以由 CR 的期望状态、checkpoint 和外部观察重新构造。
|
||||
|
||||
phase 只决定候选步骤，外部证据决定该步骤是否允许执行、是否已经完成。应用层在
|
||||
写操作前保存意图，调用幂等操作后回读，再保存下一 checkpoint。status 写入失败时，
|
||||
下次从外部事实识别完成结果；不能重发密码，也不能相信伪造的 Ready。
|
||||
|
||||
业务失败区分 InvalidSpec、ImmutableField、Conflict 等；依赖故障由适配器转换成
|
||||
安全的能力失败，应用层决定重试并映射 Condition。凭据不进入模型序列化、status、
|
||||
事件或错误明细；只能在实际需要它的执行边界短暂传递。
|
||||
|
||||
## 5. 用例走查与验收方向
|
||||
|
||||
| 场景 | 领域判定 | 应用与适配器执行／恢复 |
|
||||
| --- | --- | --- |
|
||||
| 登记 Instance | 当前配置的能力要求是否满足 | 读取管理凭据，验证连接与权限，准备并回读 registry；完成后才 Ready |
|
||||
| 供应 Tenant | Instance 策略、绑定与归属允许供应 | 保存意图，认领资源，先写并回读 Bao 凭据，再创建 role/database，登录验证和 ESO 投射 |
|
||||
| Bao 写入后进程中断 | 同一身份的部分状态可继续 | 回读原凭据继续，不生成第二份密码 |
|
||||
| 两个 Tenant 竞争名称 | 只有匹配所有权的一方可继续 | 持久化认领和条件写入裁决竞争，失败方 Conflict，不覆盖资源 |
|
||||
| Delete 中断 | 已消失资源可视为完成；剩余资源仍须归属正确 | 按规格顺序继续删除，全部回读不存在后才清 registry 和 finalizer |
|
||||
| Retain 后同名 CR 重建 | 新 UID 不等于原所有者 | Conflict，不恢复管理、不改密码 |
|
||||
|
||||
领域测试验证规则与决策；adapter 测试验证锁、条件写入、SQL 与协议行为；controller
|
||||
测试验证 checkpoint 持久化和重启恢复；E2E 验证最终合同。不能只验证一串 mock 调用
|
||||
就声称实现了最终一致性。
|
||||
|
||||
## 6. 决策记录与待细化边界
|
||||
|
||||
1. **Instance 身份与物理目标（已确认）**：以管理员声明为准，endpoint 变更不验证
|
||||
物理服务器／registry 连续性，不增加安装身份绑定检查；旧观察失效，重验新配置
|
||||
的连接与管理能力。新 CR 视为新 Instance，不自动接管旧 UID 资源或迁移数据。
|
||||
2. **Retain 完成条件**：外部依赖不可用不能永久阻止 CR 删除，但 registry 又需标记
|
||||
unmanaged。需定义 CR 消失后的补偿／清扫入口及所需身份依据，不能承诺同时原子
|
||||
完成两者，也不能在没有回读时声称已写入保留标记。
|
||||
3. **管理凭据来源与 Ready（已确认）**：Instance 引用 controller namespace 内的
|
||||
管理 Secret 名称和字段；管理员维护 ExternalSecret，ESO 同步。controller 不直接
|
||||
从 Bao 读取管理凭据。已有凭据仍可访问 PG 时，Bao／ESO 故障不撤销 Instance Ready；
|
||||
首次装配无有效 Secret 则失败。Secret 的有效用户名／密码变化时重建管理连接池并
|
||||
重验，不因无关字段变化重建；controller 不修改 PG 密码，不回写 Secret 或 Bao。
|
||||
4. **绑定时机**：系统规格写“首次成功后不可变”，API 文档写“首次创建外部状态后
|
||||
不可变”。应明确绑定在认领、首次外部写入还是 Ready 时固定，及如何在 status 丢失
|
||||
后恢复；否则供应中途改名称可能产生无人管理的资源。
|
||||
|
||||
5. **Instance 删除（已确认）**：开始受管即添加 finalizer；删除期间停止新供应，
|
||||
有 Tenant 引用就等待，无引用才解除，不级联删除外部资源。首版采用 finalizer
|
||||
与引用检查，不引入跨对象锁／准入控制；不保证并发创建与删除的原子性。
|
||||
|
||||
Tenant 的 Retain 等待决行为留到 Tenant 设计，不属于本轮 Instance 设计范围。
|
||||
相关用例在决策批准前不进入实现，不同时实现整套模型。
|
||||
@@ -0,0 +1,125 @@
|
||||
# 现有数据库迁移 Runbook
|
||||
|
||||
| 项目 | 内容 |
|
||||
| --- | --- |
|
||||
| 状态 | Review；尚未在临时 PostgreSQL 演练 |
|
||||
| 适用范围 | 任意既有数据库迁移为新建 v1alpha1 Tenant |
|
||||
| 最后更新 | 2026-09-10 |
|
||||
|
||||
v1alpha1 不接管现有 database、role 或 OpenBao record。本流程通过逻辑 dump/restore 把
|
||||
数据迁移到 controller 创建的新资源，保留旧资源作为限时回滚点。
|
||||
|
||||
以下命令是顺序模板，不可原样复制到真实环境。先把尖括号变量解析成明确值，确认当前
|
||||
连接目标，再逐条执行。dump 可能包含敏感业务数据，必须放在加密临时存储且不得提交 Git。
|
||||
|
||||
## 前置条件
|
||||
|
||||
- 已验证 PostgreSQL/OpenBao 备份和恢复；记录恢复点。
|
||||
- Instance 已 Ready，目标 namespace 存在，ESO ClusterSecretStore Ready。
|
||||
- 最终 database/login role 当前由旧应用占用，但改名后的保留名称、新推导的 Bao path
|
||||
均不存在。
|
||||
- 已记录旧 database owner、grants、extensions、locale/encoding、连接配置和验证清单。
|
||||
- 已确认应用可停止写入，并确定回滚窗口和负责人。
|
||||
- 已确认旧 login role 不被其他 database/应用共享，且角色改名不会破坏未纳入本次维护
|
||||
的依赖。
|
||||
|
||||
## 迁移顺序
|
||||
|
||||
### 1. 盘点与预演
|
||||
|
||||
```sh
|
||||
pg_dump --schema-only --no-owner --no-privileges \
|
||||
--dbname='<old-admin-connection>' > schema-preview.sql
|
||||
```
|
||||
|
||||
检查不受 v1alpha1 管理的对象：额外 roles、跨库依赖、FDW、large objects、订阅、显式
|
||||
tablespace、owner/grant 和目标实例不支持的 extension。无法映射为单 database + 单 login
|
||||
owner 的环境必须先人工简化，不能让 controller 猜测。
|
||||
|
||||
### 2. 创建一致性 dump
|
||||
|
||||
停止应用写入并确认活跃写事务结束，然后创建最终 custom-format dump：
|
||||
|
||||
```sh
|
||||
pg_dump --format=custom --no-owner --no-privileges \
|
||||
--file='<secure-temp>/tenant.dump' \
|
||||
--dbname='<old-admin-connection>'
|
||||
pg_restore --list '<secure-temp>/tenant.dump'
|
||||
```
|
||||
|
||||
不要删除旧 database/role。记录停写时间、dump checksum 和 PostgreSQL 版本。
|
||||
|
||||
### 3. 释放最终名称
|
||||
|
||||
保持应用停写，终止旧 database 的应用连接。连接其他管理 database，以管理员身份把旧
|
||||
database 和旧 login role 改为明确的保留名称：
|
||||
|
||||
```sql
|
||||
ALTER DATABASE <old_database> RENAME TO <old_database>_retained_<timestamp>;
|
||||
ALTER ROLE <old_login_role> RENAME TO <old_login_role>_retained_<timestamp>;
|
||||
```
|
||||
|
||||
identifier 必须由管理员工具安全引用，不能把未经校验的值直接拼入 SQL。PostgreSQL 在
|
||||
角色改名时会清除以旧角色名加盐的 MD5 密码；使用 MD5 的旧环境必须在维护前准备安全的
|
||||
密码重设/回滚方法。SCRAM verifier 不受角色名改动影响，但仍须实际验证回滚登录。
|
||||
|
||||
### 4. 创建受管空目标
|
||||
|
||||
应用 `PostgreSQLTenant`，使用未被占用的 database/loginRole，等待 Ready。确认：
|
||||
|
||||
- registry 记录 UID 正确；
|
||||
- OpenBao metadata 属于该 Tenant；
|
||||
- ExternalSecret Ready 且目标 Secret 已投射；
|
||||
- 新凭据可以通过 DNS host 和 IP hostaddr 分别登录空 database。
|
||||
|
||||
### 5. Restore
|
||||
|
||||
从 OpenBao 或目标 Secret 安全取得新应用凭据，不要把密码放进 shell history。以新 login
|
||||
owner 连接目标 database：
|
||||
|
||||
```sh
|
||||
pg_restore --exit-on-error --no-owner --no-privileges \
|
||||
--dbname='<new-application-connection>' \
|
||||
'<secure-temp>/tenant.dump'
|
||||
```
|
||||
|
||||
extension 应由 Tenant spec 创建。若 dump 仍包含 extension 定义，预演必须确认 restore
|
||||
行为幂等；目标实例不支持的 extension 必须在迁移前解决。
|
||||
|
||||
### 6. 验证并切换
|
||||
|
||||
- 对比关键 schema、表数、行数/校验和、sequence、function 和 migration version。
|
||||
- 用新 login 验证读写、migration 和应用健康检查。
|
||||
- 将应用配置切换到新 Secret 或 OpenBao URL，保持旧数据库只读/停写。
|
||||
- 观察一个约定窗口，确认错误率、连接数和关键业务功能。
|
||||
|
||||
### 7. 收尾
|
||||
|
||||
回滚窗口结束后，按独立变更删除旧 database/role/旧凭据；它们不属于 controller，禁止
|
||||
通过 Tenant `Delete` 清理。安全删除 dump 和临时凭据材料，并记录验证结果。
|
||||
|
||||
## 回滚
|
||||
|
||||
在新目标出现问题且旧资源仍保留时：
|
||||
|
||||
1. 立即停止新目标写入。
|
||||
2. 评估切换后是否产生新数据；若有，先决定反向迁移或接受丢弃，不能盲目切回。
|
||||
3. 将应用连接切回 retained database/role；若必须恢复原名称，先确保新受管目标已用
|
||||
`Delete` 完整清理或改用不同名称，再安全地反向执行 rename。
|
||||
4. 恢复旧凭据（MD5 环境可能需要重设），验证旧服务。
|
||||
5. 保留失败 Tenant 供排障；选择 Retain 或 Delete 前明确其外部资源后果。
|
||||
|
||||
若已经删除旧资源，则只能使用已验证备份恢复，不再属于本 runbook 的快速回滚。
|
||||
|
||||
## 演练验收
|
||||
|
||||
发布首个可用版本前，必须在临时 PostgreSQL/OpenBao/Kind 环境执行本文并记录：
|
||||
|
||||
- 使用的 PostgreSQL major version 和命令版本；
|
||||
- dump/restore 返回码和对象差异；
|
||||
- DNS/IP TLS 登录结果；
|
||||
- ESO 投射与应用启动结果；
|
||||
- 回滚演练结果；
|
||||
- 哪些命令或前置检查需要修订。
|
||||
|
||||
完成演练前，本文不得标记为 `Verified`。
|
||||
@@ -0,0 +1,76 @@
|
||||
# 运维与故障处理
|
||||
|
||||
| 项目 | 内容 |
|
||||
| --- | --- |
|
||||
| 状态 | Review；命令待实现后演练 |
|
||||
| 最后更新 | 2026-09-10 |
|
||||
|
||||
## 日常检查
|
||||
|
||||
先看 API 合同，而不是从日志猜状态：
|
||||
|
||||
```sh
|
||||
kubectl get postgresqlinstances
|
||||
kubectl get postgresqltenants -A
|
||||
kubectl get postgresqltenant -n <namespace> <name> -o yaml
|
||||
kubectl describe postgresqltenant -n <namespace> <name>
|
||||
```
|
||||
|
||||
随后检查 controller 日志、ExternalSecret/Secret、OpenBao metadata、registry 和
|
||||
PostgreSQL catalog。排障时不得把 Secret data 或带 Token 的请求粘贴到 issue/日志。
|
||||
`status.phase` 是 controller 状态机 checkpoint，也用于定位当前步骤；`Ready`
|
||||
Condition/Reason 用于判断对外结果。phase 不能替代外部事实，清空或不一致时应由
|
||||
controller 自动重建/纠正。
|
||||
|
||||
## 常见 Reason
|
||||
|
||||
| Reason | 首要检查 |
|
||||
| --- | --- |
|
||||
| `InvalidSpec` / `ImmutableField` | API 字段、identifier、不可变/只追加约束 |
|
||||
| `DependencyUnavailable` | 网络、DNS、服务状态和超时 |
|
||||
| `AuthenticationFailed` | 管理凭据、CA、DNS/IP SAN、OpenBao auth |
|
||||
| `InsufficientPrivileges` | PostgreSQL grants、OpenBao policy、Kubernetes RBAC |
|
||||
| `InstanceNotReady` | 先恢复所引用 Instance |
|
||||
| `Conflict` | registry UID、同名 DB/role、OpenBao metadata；禁止直接覆盖 |
|
||||
| `CredentialProjectionFailed` | ClusterSecretStore、ExternalSecret Condition、目标 Secret |
|
||||
| `ProvisioningFailed` | `status.phase` 及对应外部资源的回读结果 |
|
||||
|
||||
修复依赖后让正常 reconcile 自动重试。不要通过删除/重建 CR 规避 Conflict；新 UID 只会
|
||||
使已有保留资源继续冲突。
|
||||
|
||||
## Retain 后的资源
|
||||
|
||||
Retain 删除完成后，database、role、OpenBao record 和 registry 所有权记录仍存在但标记
|
||||
unmanaged。v1alpha1 不支持重新关联。需要恢复管理时，使用 [`migration.md`](migration.md)
|
||||
把数据迁移到一个全新受管名称；不要手工把 registry UID 改成新 CR UID。
|
||||
|
||||
## Delete 卡住
|
||||
|
||||
1. 暂停应用写入并记录 Tenant UID、Instance UID、database、role 和 Bao path。
|
||||
2. 从 registry 和 OpenBao metadata 独立确认所有权。
|
||||
3. 检查删除阶段，修复 PostgreSQL/OpenBao/ESO 依赖，让 controller 继续。
|
||||
4. 若依赖永久丢失，列出每个可能残留的 database、role、KV metadata 和 Secret。
|
||||
5. 只有确认接受这些残留后，才人工移除 finalizer。
|
||||
|
||||
最终 finalizer 名称由 API 实现固定后补入命令。人工移除 finalizer不会执行剩余清理，
|
||||
也不会把外部资源变成可由新 CR 接管的资源。
|
||||
|
||||
## 备份与恢复
|
||||
|
||||
- PostgreSQL VM/磁盘备份必须与数据库一致性策略配套；仅复制在线磁盘不自动等于有效
|
||||
PostgreSQL 备份。
|
||||
- PostgreSQL 备份必须包含管理 database 中的 controller registry。
|
||||
- OpenBao 使用独立的受支持备份/快照流程，且恢复点应与 PostgreSQL 尽量接近。
|
||||
- Kubernetes 侧备份 CR、controller 配置、ClusterSecretStore 和公开 CA bundle，不备份
|
||||
明文 Secret 作为凭据事实来源。
|
||||
- 定期在隔离环境执行恢复演练，验证 registry、KV metadata、应用登录及 Retain/Delete。
|
||||
|
||||
恢复后先停止 controller，核对 PostgreSQL/OpenBao 时间点与 UID 映射，再启动单副本
|
||||
controller 观察；出现一侧存在、一侧缺失时不得手工生成新密码或改 registry，应先按
|
||||
Conflict 处理并决定恢复哪一侧。
|
||||
|
||||
## 升级与紧急停止
|
||||
|
||||
有疑似越权删除或凭据泄漏时，先把 controller Deployment scale 到 0，保留 CR、registry
|
||||
和日志证据，再撤销 OpenBao token/role 并限制 PostgreSQL 管理 role。恢复前在隔离环境
|
||||
复现并确认不会扩大破坏。一般依赖故障无需 scale down，最终一致性会自动重试。
|
||||
@@ -0,0 +1,71 @@
|
||||
# 安全模型
|
||||
|
||||
| 项目 | 内容 |
|
||||
| --- | --- |
|
||||
| 状态 | Review |
|
||||
| 最后更新 | 2026-09-10 |
|
||||
|
||||
## 保护目标
|
||||
|
||||
- 应用密码只存在于 OpenBao、ESO 投射的目标 Secret 和需要使用它的进程内存中。
|
||||
- controller 只能修改其 registry 能证明归属当前 Tenant UID 的资源。
|
||||
- namespace 租户不能越权管理 Instance、其他 namespace 或 controller 配置。
|
||||
- PostgreSQL 和 OpenBao 的网络身份使用受信 CA 验证，不因 DNS 不可用而降级 TLS。
|
||||
|
||||
## 信任边界
|
||||
|
||||
Kubernetes 管理员、OpenBao 管理员和 PostgreSQL 管理员是平台信任主体。能读取 Tenant
|
||||
目标 Secret 或对应 OpenBao path 的主体等同于持有数据库账号。database owner 可以
|
||||
改变自己 database 内的对象，因此 COMMENT 不能作为 controller 所有权依据。
|
||||
|
||||
VM/磁盘备份会包含 PostgreSQL registry 和租户数据，但不应包含 OpenBao 中的密码；完整
|
||||
灾难恢复必须同时保护 PostgreSQL 与 OpenBao，并控制两份备份的访问权限。
|
||||
|
||||
## 凭据处理
|
||||
|
||||
- controller 使用 Kubernetes auth 获取短期 OpenBao token，不配置长期静态 token。
|
||||
- 管理凭据只从 Instance 引用的 controller namespace Secret 读取，不复制到
|
||||
CR/status/Event/metric/trace；管理员维护 ExternalSecret，由 ESO 同步该 Secret。
|
||||
- 租户密码使用密码学安全随机源生成一次；中断恢复必须复用 OpenBao 现值。
|
||||
- controller 创建 ExternalSecret，不直接创建含 data/stringData 的 Secret。
|
||||
- 日志字段允许 namespace/name、UID、generation、阶段和错误类别；禁止记录请求/响应体、
|
||||
DSN、Authorization header、密码或完整 OpenBao URL path 作为 metric label。
|
||||
- panic、错误包装和测试失败输出必须经过凭据泄漏测试。
|
||||
|
||||
## TLS
|
||||
|
||||
- homelab 默认 `verify-full`，`disable` 只允许显式开发配置。
|
||||
- server 证书同时覆盖 DNS `host` 和 IP `hostaddr`；消费者自行选择连接目标。
|
||||
- OpenBao PKI 保管 CA 私钥并负责签发/续期。controller Deployment 只挂载公开 CA
|
||||
bundle，挂载只读且使用最小文件权限。
|
||||
- 证书轮换必须先发布同时信任新旧 CA 的 bundle，再轮换服务端证书，最后移除旧 CA。
|
||||
|
||||
## 最小权限
|
||||
|
||||
OpenBao controller identity 只管理固定 tenant base path，不读取管理凭据。管理凭据
|
||||
ESO 身份只读管理路径，租户 ESO 身份只读 tenant base path，二者隔离，Tenant 不得
|
||||
使用管理凭据 Store。controller 对管理 Secret 的读取限于自身 namespace，Instance
|
||||
不能指定其他 namespace；controller 不创建或修改管理 Secret／ExternalSecret。
|
||||
|
||||
PostgreSQL 管理 role 不应是 superuser。若平台选择 SECURITY DEFINER 函数承载创建或
|
||||
删除操作，函数必须固定 `search_path`、严格校验 identifier、拒绝任意 SQL，并仅向
|
||||
controller role 授予 EXECUTE。controller 不调用 shell 或 `psql` 拼接用户输入。
|
||||
|
||||
Kubernetes RBAC 应把 cluster-scoped Instance 管理限制给平台管理员。Tenant editor
|
||||
不自动获得 Secret read；是否读取目标 Secret 由 namespace 内独立 RBAC 决定。
|
||||
|
||||
## 删除保护
|
||||
|
||||
Delete 是明确的数据销毁授权，但仍必须在每一步校验 Instance UID、Tenant UID、名称和
|
||||
OpenBao metadata。禁止对未知对象使用 `CASCADE`。删除 finalizer 卡住时只能按
|
||||
[`operations.md`](operations.md) 核实外部状态后人工移除；该操作可能遗留资源。
|
||||
|
||||
## 发布前安全验收
|
||||
|
||||
- 使用错误 CA、错误 DNS 名和错误 IP 时连接失败；正确 DNS/IP SAN 均成功。
|
||||
- namespace 用户不能修改 Instance 或跨 namespace Tenant/ExternalSecret。
|
||||
- controller/ESO 的 OpenBao policy 互相隔离，越权请求被拒绝。
|
||||
- 应用 login 不能创建 role/database，也不能连接其他租户 database。
|
||||
- 日志、Event、Condition、metrics、CR 导出和测试 artifact 不含 canary password/token。
|
||||
- 伪造 COMMENT、同名 database/role 或错误 UID metadata 均不能绕过 Conflict。
|
||||
- Delete 只销毁 registry 可证明归属当前 Tenant 的资源。
|
||||
@@ -0,0 +1,558 @@
|
||||
# PostgreSQL Tenant Operator 系统规格说明书
|
||||
|
||||
| 项目 | 内容 |
|
||||
| --- | --- |
|
||||
| 状态 | Approved |
|
||||
| 目标 API | `database.ayatori.ddupan.top/v1alpha1` |
|
||||
| 最后更新 | 2026-09-13 |
|
||||
| 批准日期 | 2026-09-10 |
|
||||
| 规范范围 | 首次注册外部 PostgreSQL 实例并创建一个应用租户 |
|
||||
|
||||
本文档定义系统对用户和外部依赖呈现的行为，是 API、测试和实现共同遵守的合同。
|
||||
实现若需要改变本文合同，必须先修改规格并重新获得批准。
|
||||
|
||||
文中的“必须”“禁止”“应当”“可以”分别对应强制要求、强制限制、推荐行为和可选
|
||||
行为。
|
||||
|
||||
## 1. 背景
|
||||
|
||||
homelab 中的大部分应用共享一个运行在独立 VM 上的 PostgreSQL DBMS。应用需要各自
|
||||
独立的 database、作为 owner 的 login role 和密码，但不需要独立 PostgreSQL 实例。
|
||||
目前这些资源依靠人工 SQL 和人工 Secret 管理，难以重复、审计和检测漂移。
|
||||
|
||||
本系统使用 Kubernetes CRD 作为声明式 API，持续协调外部 PostgreSQL 与 OpenBao：
|
||||
|
||||
```text
|
||||
PostgreSQLInstance / PostgreSQLTenant
|
||||
|
|
||||
v
|
||||
Ayatori Database controller
|
||||
| |
|
||||
v v
|
||||
PostgreSQL catalog OpenBao KV v2
|
||||
```
|
||||
|
||||
## 2. 目标
|
||||
|
||||
v1alpha1 必须实现以下目标：
|
||||
|
||||
1. 注册一个已经存在的外部 PostgreSQL 实例并报告连接状态。
|
||||
2. 为一个应用租户创建独立 database 和一个同时作为 database owner 的 login role。
|
||||
3. 根据实例实际可安装扩展列表检查并安装租户申请的 PostgreSQL extension。
|
||||
4. 首次生成高强度长期密码，并只把凭据明文写入 OpenBao KV v2。
|
||||
5. 为 Kubernetes 应用创建 ExternalSecret，由 ESO 将凭据投射到同 namespace Secret。
|
||||
6. 同时输出 OpenBao API URL，使 Kubernetes 外的应用可以直接读取凭据。
|
||||
7. 同时输出 PostgreSQL DNS hostname 和 IP address，不假定所有消费者都能使用集群内
|
||||
DNS。
|
||||
8. 持续检测并修正由本系统管理的非破坏性漂移。
|
||||
9. 通过 Kubernetes Condition 报告进度、成功和可操作的失败原因。
|
||||
10. 重复 reconcile、controller 重启及外部依赖暂时失败不得重复创建或破坏资源。
|
||||
11. 删除 Tenant CR 时默认保留外部资源；显式选择 `Delete` 时提供完整清理路径。
|
||||
|
||||
## 3. 非目标
|
||||
|
||||
v1alpha1 不负责：
|
||||
|
||||
- 创建、升级、备份或高可用运行 PostgreSQL DBMS/VM；
|
||||
- 创建或运维 OpenBao；
|
||||
- 直接写入包含凭据明文的 Kubernetes Secret；Secret 必须由 ESO 投射；
|
||||
- 动态凭据、定时或自动密码轮换；
|
||||
- Web UI、独立 REST API 或 Backstage 插件；
|
||||
- 跨实例迁移 database；
|
||||
- schema/table 级别租户、多 login role 或跨租户 grant；
|
||||
- 删除不属于本系统管理的 database、role、extension 或 OpenBao Secret；
|
||||
- 接管不是由本系统创建的外部资源；
|
||||
- 提供生产环境 SLA。
|
||||
|
||||
## 4. 参与者与事实来源
|
||||
|
||||
| 对象 | 事实来源 | 说明 |
|
||||
| --- | --- | --- |
|
||||
| 期望状态 | Kubernetes CR `spec` | 用户声明的合同 |
|
||||
| 最近观察结果与当前阶段 | Kubernetes CR `status` | 可以丢失并重建，不是外部事实来源 |
|
||||
| database/role/grant/extension | PostgreSQL catalog | 每轮 reconcile 必须重新读取 |
|
||||
| 受管资源所有权与保留标记 | PostgreSQL controller registry | 与受管 DBMS 一起备份和恢复 |
|
||||
| controller 工作流阶段 | Kubernetes CR `status.phase` | 状态机 checkpoint；可由外部事实保守重建 |
|
||||
| 应用凭据 | OpenBao KV v2 | Kubernetes API 中不得出现明文 |
|
||||
| Kubernetes 凭据投射 | External Secrets Operator | ExternalSecret 由本 controller 管理 |
|
||||
| PostgreSQL 管理凭据 | controller namespace 的 Kubernetes Secret | 管理员维护 ExternalSecret，由 ESO 同步；Instance 只引用 Secret |
|
||||
|
||||
平台管理员管理 `PostgreSQLInstance`、controller 部署配置、OpenBao policy 和
|
||||
PostgreSQL 管理 role。应用或 GitOps 流程在获得 namespace RBAC 后管理
|
||||
`PostgreSQLTenant`。
|
||||
|
||||
## 5. 资源模型
|
||||
|
||||
### 5.1 PostgreSQLInstance
|
||||
|
||||
`PostgreSQLInstance` 是 cluster-scoped 资源，表示一个已经存在、可由 controller
|
||||
管理的 PostgreSQL server。
|
||||
|
||||
它必须声明：
|
||||
|
||||
- PostgreSQL host、port 和管理连接使用的 database；
|
||||
- PostgreSQL host address，供无法解析 DNS 的消费者使用；
|
||||
- TLS mode；
|
||||
- controller namespace 中 PostgreSQL 管理 Secret 的名称和字段名。
|
||||
|
||||
可安装的 extension 集合由应用层从目标 PostgreSQL 查询，不由管理员在 Instance
|
||||
中声明。v1alpha1 不实现 allowlist；该概念保留为后续可选策略。实际可用不代表安装
|
||||
权限及前置条件已满足，安装仍需执行并回读；查询失败不得被解释为扩展不支持。
|
||||
|
||||
实例 Ready 不代表 PostgreSQL 数据有备份或高可用，只表示 controller 当前可以安全
|
||||
建立管理连接、读取 server metadata、访问 controller registry 并使用所需管理能力。
|
||||
|
||||
Instance 身份和 endpoint 以管理员声明为准。修改 endpoint 不验证是否仍是原物理
|
||||
服务器或原 registry，不增加服务器／安装身份绑定检查；但旧配置观察失效，必须按
|
||||
新配置重新检查连接和管理能力。新 CR 按新 Instance 处理，不自动接管旧 UID 的租户
|
||||
资源。controller 不迁移旧服务器上的数据，也不清理旧目标，影响由管理员负责评估。
|
||||
|
||||
Instance 开始受管时即添加 finalizer，成功保存后才参与供应，不等发现 Tenant 后
|
||||
再补加。删除期间停止新供应；仍有引用它的 Tenant（包括正在删除的 Tenant）时保留
|
||||
finalizer，无引用后才移除。不级联删除 Tenant 或任何外部数据库、角色、凭据。
|
||||
引用检查失败不得当作无引用。首版不引入跨对象锁或准入控制：finalizer 不禁止同时
|
||||
创建 Tenant CR，新 Tenant 遇到正在删除或已不存在的 Instance 时不得开始供应。
|
||||
这不保证列表检查、CR 创建和在途外部操作之间的原子性；不是严格的跨对象事务。
|
||||
|
||||
### 5.2 PostgreSQLTenant
|
||||
|
||||
`PostgreSQLTenant` 是 namespaced 资源。v1alpha1 中，一个 Tenant 精确对应：
|
||||
|
||||
- 一个 `PostgreSQLInstance`；
|
||||
- 一个 database；
|
||||
- 一个同时作为 database owner、供应用使用的 `LOGIN` role；
|
||||
- 零个或多个 extension；
|
||||
- 一个 OpenBao KV v2 凭据位置；
|
||||
- 一个同 namespace ExternalSecret 及其目标 Kubernetes Secret。
|
||||
|
||||
Tenant 的 namespace 用于 Kubernetes RBAC 和身份识别，不代表 PostgreSQL schema。
|
||||
同一 Instance 中的 database 和 role 名称全局唯一。
|
||||
|
||||
## 6. 标识与默认值
|
||||
|
||||
以下是 v1alpha1 的标识合同：
|
||||
|
||||
| 字段 | 默认值 | 约束 |
|
||||
| --- | --- | --- |
|
||||
| Instance port | `5432` | 1–65535 |
|
||||
| Instance host address | 无 | 必须是合法 IPv4 或 IPv6 address |
|
||||
| 管理 database | `postgres` | 合法 PostgreSQL identifier |
|
||||
| TLS mode | `verify-full` | 禁止隐式降级 |
|
||||
| Tenant database | `metadata.name` | 同一 Instance 全局唯一 |
|
||||
| login role | `metadata.name` | 同一 Instance 全局唯一 |
|
||||
| deletion policy | `Retain` | `Retain` 或 `Delete` |
|
||||
|
||||
Tenant 的 `spec.instanceRef` 与 `metadata.name` 长度合计不得超过 241 个字符，确保
|
||||
派生的 ExternalSecret/Secret 默认名称
|
||||
`<instanceRef>-<metadata.name>-postgresql` 不超过 Kubernetes 253 字符限制。
|
||||
|
||||
固定默认值由 CRD defaulting 写入。依赖 `metadata.name` 或 `instanceRef` 的 database、
|
||||
login role、ExternalSecret/Secret 名称属于 controller 语义默认值：省略字段不会被 admission
|
||||
回写，controller 必须始终计算同一个 effective value，并通过 status 的 database、
|
||||
loginRole、credential reference 以及实际资源展示。
|
||||
v1alpha1 不为此引入 mutating webhook。
|
||||
|
||||
database 和 role 名称必须作为 PostgreSQL identifier 参数安全引用，禁止通过字符串
|
||||
拼接执行。名称校验必须拒绝空字符串、NUL 和超过 PostgreSQL identifier 长度限制的
|
||||
值，并统一限制为小写字母、数字和下划线。
|
||||
|
||||
Tenant 首次成功后，`instanceRef`、database、login role 和凭据位置必须
|
||||
不可变。修改这些字段不是 rename 或 migration，API 必须拒绝或报告明确的
|
||||
`ImmutableField`。
|
||||
|
||||
## 7. PostgreSQL 权限合同
|
||||
|
||||
建议的 v1alpha1 权限模型如下：
|
||||
|
||||
1. database 必须由 login role 拥有。
|
||||
2. login role 必须是 `LOGIN NOSUPERUSER NOCREATEDB NOCREATEROLE NOREPLICATION`。
|
||||
3. 必须撤销 `PUBLIC` 对租户 database 的连接权限，再显式允许 login role 连接。
|
||||
4. controller 不得修改其他 database 或无关 role 的权限。
|
||||
5. controller 只保证请求的 extension 存在；移除 extension 不得自动执行
|
||||
`DROP EXTENSION`。
|
||||
|
||||
这意味着应用可以在自己的 database 内执行 schema migration，但不能创建其他
|
||||
database、role 或访问其他租户。v1alpha1 不创建只有形式意义、却未隔离运行时权限的
|
||||
额外 `NOLOGIN` owner。若以后应用能分别使用 migration 和 runtime 凭据，再通过新的
|
||||
权限 profile 引入 owner/migrator/runtime 角色模型。
|
||||
|
||||
## 8. OpenBao 凭据合同
|
||||
|
||||
### 8.1 Controller 自身认证
|
||||
|
||||
controller 必须使用 Kubernetes auth 登录 OpenBao。controller 使用的 OpenBao API
|
||||
address、提供给消费者的 OpenBao API address、auth mount、auth role 和 KV v2 mount
|
||||
属于部署配置，不属于任何 CR。两个 API address 可以相同；若 controller 使用集群内
|
||||
地址而外部消费者不能解析，则必须单独配置 consumer address。生产部署的 KV mount
|
||||
默认为 `kv`；开发环境可以配置为 OpenBao dev server 默认的 `secret`。长期 OpenBao
|
||||
Token 禁止写入 Deployment、CR 或镜像。
|
||||
|
||||
### 8.2 管理凭据
|
||||
|
||||
`PostgreSQLInstance` 只引用 controller 自身 namespace 中 Kubernetes Secret 的名称及
|
||||
用户名、密码字段名，不允许指定 namespace 或 Bao path。endpoint 仍由 Instance 声明。
|
||||
平台管理员维护 ExternalSecret，将 OpenBao 管理凭据同步到该 Secret；controller 只读
|
||||
Secret，不创建或修改管理 Secret、其 ExternalSecret 或上游管理凭据。
|
||||
|
||||
Instance 管理连接不直接访问 Bao，不负责管理密码轮换。已装配的凭据仍可访问
|
||||
PostgreSQL 且满足 registry／权限要求时，Bao 或 ESO 暂时不可用不使 Instance NotReady。
|
||||
首次装配无法取得有效 Secret 时不能 Ready。检测到所引用 Secret 的有效用户名或密码
|
||||
变化时，controller 使用新值重建管理连接池并重新检查管理能力；仅 metadata 或无关
|
||||
字段变化不触发重建。刷新不依赖 Instance generation 变化，新连接验证失败按实际
|
||||
故障报告，不能用旧连接的成功结果证明新凭据可用。
|
||||
controller 不修改 PostgreSQL 密码、不回写 Secret，也不修改 Bao 管理凭据；数据库侧
|
||||
凭据变更由管理员负责。这是跟随已提供凭据的连接刷新，不是自动密码轮换。
|
||||
Tenant 凭据管理仍直接依赖 Bao。
|
||||
|
||||
### 8.3 租户凭据
|
||||
|
||||
Tenant 不声明凭据 path。controller 根据部署级 KV mount、base path 和 Tenant 的
|
||||
namespace/name 推导唯一的 mount-relative path。base path 来自 controller 启动参数
|
||||
`--openbao-tenant-base-path`，默认 `postgresql-tenants`。最终路径为
|
||||
`<base-path>/<namespace>/<metadata.name>`。推导结果禁止以 `/` 开头，禁止包含空路径段、
|
||||
`.`、`..`，也禁止把 KV v2 HTTP API 的 `data` 或 `metadata` 层编码进路径。
|
||||
|
||||
新 Tenant 的凭据建立顺序必须可从任意中断点恢复：
|
||||
|
||||
1. 验证 Instance、名称、extension 和目标 OpenBao 路径；
|
||||
2. 确认目标 database、role 和 OpenBao 记录不存在，或能够验证为同一 Tenant
|
||||
已创建的部分状态；
|
||||
3. 生成密码；
|
||||
4. 先创建带 controller 所有权 metadata 的 OpenBao KV v2 记录；
|
||||
5. 从 OpenBao 重新读取凭据；
|
||||
6. 使用该凭据创建作为 database owner 的 login role 和其他 PostgreSQL 资源；
|
||||
7. 用 login role 实际连接目标 database；
|
||||
8. 全部验证成功后将 Tenant 标记 Ready。
|
||||
|
||||
若第 4 步成功、后续 PostgreSQL 操作失败，下一轮必须读取同一份 OpenBao 凭据继续，
|
||||
不得生成第二个密码。若 PostgreSQL 先存在而 OpenBao 记录不存在，controller 必须报告
|
||||
Conflict，不得擅自重置已有 role 密码。
|
||||
|
||||
controller 必须在 PostgreSQL 管理 database 的专用 registry schema 中持久保存可验证的
|
||||
Instance UID、Tenant UID 与 namespace/name 关联，不能只依赖会丢失的 CR status 判断
|
||||
资源所有权。registry 必须可回读且不得改变数据库授权语义；database 或 role COMMENT
|
||||
不能作为权威所有权记录。
|
||||
|
||||
默认写入字段固定为：
|
||||
|
||||
```text
|
||||
username
|
||||
password
|
||||
database
|
||||
host
|
||||
hostaddr
|
||||
port
|
||||
sslmode
|
||||
```
|
||||
|
||||
这些字段是 controller 的规范化输出合同。controller 不生成包含密码的 URI、JDBC URL
|
||||
或应用专用键名。应用通过 ExternalSecret template、Helm values 或自身配置把原子字段
|
||||
映射为 `DATABASE_URL`、独立环境变量或配置文件；因此 URI escaping 和应用特有格式也
|
||||
由消费方负责。`host` 是 DNS 名称，`hostaddr` 是可直接连接的 IP；消费者自行选择其
|
||||
支持且可达的连接目标。PostgreSQL server 证书必须同时包含与 `host` 匹配的 DNS SAN
|
||||
和与 `hostaddr` 匹配的 IP SAN，使两种目标都能在 `verify-full` 下独立完成身份验证。
|
||||
|
||||
### 8.4 凭据输出与 ExternalSecret
|
||||
|
||||
controller 必须根据部署级 base path 推导 Tenant 的 KV path，Tenant 不能选择 mount 或
|
||||
任意远端路径。ExternalSecret 固定命名为
|
||||
`<instanceRef>-<metadata.name>-postgresql`。Tenant 可以通过
|
||||
`spec.credential.secretName` 指定目标 Kubernetes Secret 名称；省略时使用同一默认名。
|
||||
自定义名称只需是合法 Kubernetes Secret 名称，不限制命名内容；两者均与 Tenant 位于
|
||||
同一 namespace。
|
||||
|
||||
controller 必须创建同 namespace ExternalSecret，从固定的 ClusterSecretStore 读取七个
|
||||
原子字段。ExternalSecret 及目标 Secret 的名称通过 Tenant status 暴露。controller
|
||||
不得直接读取 OpenBao 密码后写入 Kubernetes Secret。
|
||||
|
||||
Tenant status 还必须提供完整、可由外部消费者使用的 OpenBao KV v2 API URL。URL 可以
|
||||
包含 consumer API address、mount 和 secret path，但不得包含 Token、密码或其他认证
|
||||
信息。默认 `kubectl get` 表格显示目标 Secret 名称；完整 OpenBao URL 通过
|
||||
`kubectl get postgresqltenant <name> -o yaml` 获取，避免表格列过长。
|
||||
|
||||
OpenBao metadata 必须能够标识 Tenant UID、namespace/name 和 Instance，使 controller
|
||||
区分自己的残留记录与外部记录。任何凭据值都不得进入日志、Event、Condition、metric
|
||||
label、trace、CR spec/status 或测试快照。
|
||||
|
||||
## 9. Reconcile 行为
|
||||
|
||||
系统采用最终一致性模型。Kubernetes、PostgreSQL、OpenBao 和 ESO 可以短暂处于不同
|
||||
阶段；controller 不尝试实现跨系统事务，而是以 Kubernetes CR `status.phase` 作为
|
||||
工作流 checkpoint，通过幂等外部操作和每轮回读验证最终收敛。
|
||||
|
||||
两个 CR 的状态机权威记录都在 `status.phase`。controller 根据 phase 选择下一项候选
|
||||
动作，但 phase 不能替代外部状态检查：执行前后仍须回读 PostgreSQL catalog、registry、
|
||||
OpenBao 和 Kubernetes/ESO。外部写入成功但 status 更新失败时，下一轮必须识别已完成
|
||||
事实并推进 phase，不得重复生成密码或报告虚假冲突。
|
||||
|
||||
status 丢失时，controller 必须从 registry 的所有权记录和各外部系统实际状态保守重建
|
||||
phase。若 status 被伪造或领先于实际状态，controller 必须纠正到安全阶段并补齐资源，
|
||||
不能跳过验证。registry 不保存或驱动协调 phase。
|
||||
|
||||
Instance phase 按当前 generation 表示连接与初始化进度：
|
||||
|
||||
```text
|
||||
Pending -> Validating -> InitializingRegistry -> Ready
|
||||
(any phase) --------------------------------> Deleting
|
||||
```
|
||||
|
||||
spec generation 改变后可以从 `Ready` 回到 `Validating`。Tenant phase 如下：
|
||||
|
||||
```text
|
||||
Pending -> Planned -> CredentialCreated -> RoleCreated -> DatabaseCreated
|
||||
-> ExternalSecretCreated -> CredentialProjected -> Ready -> Deleting
|
||||
```
|
||||
|
||||
失败不增加 `Failed` phase；phase 保留在无法推进的步骤，由 `Ready=False` 的 Reason 和
|
||||
message 表达 `Conflict`、认证失败或依赖不可用。Retain 删除完成后 CR 已不存在，因此
|
||||
没有持久的 `Retained` phase。
|
||||
|
||||
每轮 Tenant reconcile 必须按以下逻辑执行：
|
||||
|
||||
```text
|
||||
读取 Tenant
|
||||
-> 读取 Instance
|
||||
-> 校验不可变字段与输入
|
||||
-> 检查 Instance Ready
|
||||
-> 读取 OpenBao 与 PostgreSQL 实际状态
|
||||
-> 检测冲突或部分完成状态
|
||||
-> 执行非破坏性补齐
|
||||
-> 使用应用凭据验证登录
|
||||
-> 创建并验证 ExternalSecret/Secret 投射
|
||||
-> 回读实际状态
|
||||
-> 更新 status
|
||||
```
|
||||
|
||||
要求：
|
||||
|
||||
- 所有步骤必须幂等；
|
||||
- 每个外部写入前必须先在 CR status 持久化足够的操作意图，写入后必须回读并推进
|
||||
`status.phase`；
|
||||
- 暂时性网络、锁和依赖错误必须重试；
|
||||
- 输入错误、资源冲突和禁止操作不得忙循环重试，只在 generation 或依赖状态变化后
|
||||
重试；
|
||||
- 未知外部资源不得被修改、接管或删除；
|
||||
- 用户从 `spec.extensions` 移除 extension 时不得执行卸载，必须报告该字段在 v1alpha1
|
||||
中只允许追加；
|
||||
- controller 重启不得影响已经签发的应用密码；
|
||||
- `status` 丢失后必须可以从 registry、PostgreSQL、OpenBao 和 Kubernetes/ESO 重建。
|
||||
|
||||
## 10. Condition 合同
|
||||
|
||||
两个资源都必须提供唯一的 `Ready` Condition。可以增加辅助 Condition，但调用方只需
|
||||
依赖 `Ready`。
|
||||
|
||||
| 状态 | 含义 |
|
||||
| --- | --- |
|
||||
| `Ready=Unknown` | 正在首次观察或 reconcile，尚无结论 |
|
||||
| `Ready=False` | 当前 generation 未达到合同要求 |
|
||||
| `Ready=True` | 当前 generation 已回读验证成功 |
|
||||
|
||||
Condition 必须带正确的 `observedGeneration`。资源自身的
|
||||
`status.observedGeneration` 只在当前 generation 完成一次有结论的 reconcile 后更新。
|
||||
|
||||
最低 Reason 集合：
|
||||
|
||||
| Reason | 适用资源 | 含义 |
|
||||
| --- | --- | --- |
|
||||
| `Reconciling` | 两者 | 尚在处理 |
|
||||
| `Ready` | 两者 | 当前 generation 已验证 |
|
||||
| `InvalidSpec` | 两者 | 输入不满足规格 |
|
||||
| `DependencyUnavailable` | 两者 | PostgreSQL 或 OpenBao 暂时不可用 |
|
||||
| `AuthenticationFailed` | Instance | 管理凭据或 TLS 验证失败 |
|
||||
| `InsufficientPrivileges` | Instance | 管理 role 缺少必要权限 |
|
||||
| `InstanceNotReady` | Tenant | 引用的 Instance 未 Ready |
|
||||
| `Conflict` | Tenant | 目标名称或 OpenBao 路径已被其他主体占用 |
|
||||
| `ProvisioningFailed` | Tenant | 可重试的创建/验证失败 |
|
||||
| `CredentialProjectionFailed` | Tenant | ESO 或目标 Secret 未达到期望状态 |
|
||||
|
||||
Condition message 必须适合人类排障，但禁止包含连接串密码、Token 或完整 Secret 数据。
|
||||
|
||||
## 11. 删除与保留
|
||||
|
||||
### 11.1 Retain
|
||||
|
||||
`Retain` 是默认策略：
|
||||
|
||||
- 删除 Tenant CR 不得删除 database、role、extension 或 OpenBao 记录；
|
||||
- controller 不得因外部依赖不可用而永久阻止 Retain CR 删除；
|
||||
- 保留资源必须继续携带原 Tenant UID 和 namespace/name 的所有权记录，但在 CR 删除后
|
||||
明确处于 unmanaged 状态；
|
||||
- 重新创建同名 Tenant 会产生新的 UID，必须因已有资源不属于新 UID 而报告 Conflict；
|
||||
- v1alpha1 不提供重新关联、import 或 adoption；恢复管理必须使用第 12 节的迁移流程，
|
||||
或等待后续版本定义显式纳管协议。
|
||||
|
||||
### 11.2 Delete
|
||||
|
||||
用户在创建 Tenant 时显式设置 `deletionPolicy: Delete`，表示删除 CR 时授权永久清理
|
||||
该 Tenant 的外部资源。controller 必须使用 finalizer，并按以下顺序处理：
|
||||
|
||||
1. 再次验证 database、role 和 OpenBao 记录都属于当前 Tenant UID；
|
||||
2. 删除 ExternalSecret，并确认目标 Kubernetes Secret 已删除；
|
||||
3. 禁止该 login role 建立新连接；
|
||||
4. 终止该 database 的现有连接；
|
||||
5. 删除 database，database 内 extension 随之删除；
|
||||
6. 删除 login role；
|
||||
7. 删除 OpenBao KV 记录及其可恢复版本；
|
||||
8. 回读确认外部资源均不存在；
|
||||
9. 删除 controller registry 记录；
|
||||
10. 移除 finalizer，允许 Kubernetes 删除 CR。
|
||||
|
||||
任一步失败都必须保持 finalizer 并从安全检查开始重试。controller 禁止使用
|
||||
`CASCADE` 删除无法证明属于该 Tenant 的依赖对象。若 Instance 或 OpenBao 永久丢失，
|
||||
管理员可以在核实外部状态后手工移除 finalizer；该逃生操作必须在运维 runbook 中明确
|
||||
标记为可能遗留资源。
|
||||
|
||||
v1alpha1 不自动检查备份，也不承诺恢复被 `Delete` 删除的数据。显式选择 Delete 的
|
||||
用户承担数据销毁语义；默认 Retain 用于避免普通误删。
|
||||
|
||||
## 12. 现有环境迁移
|
||||
|
||||
v1alpha1 不接管现有 database 或 role，但必须提供可重复、可回滚的迁移 runbook。对每
|
||||
个现有应用租户，推荐的停机迁移顺序是：
|
||||
|
||||
1. 盘点 database、role、owner、grant 和 extension，并完成可恢复备份；
|
||||
2. 创建逻辑备份，必须使用可映射到新 owner 的格式，避免恢复旧 role ownership；
|
||||
3. 停止应用写入并确认没有活动写事务；
|
||||
4. 完成最终逻辑备份；
|
||||
5. 将旧 database 和 role 重命名为带迁移时间戳的保留名称，释放最终名称；
|
||||
6. 创建 `PostgreSQLTenant`，由 controller 创建最终 database、role 和 OpenBao 凭据；
|
||||
7. 等待 Tenant Ready；
|
||||
8. 以新 owner 恢复逻辑备份，并验证 row count、schema、extension 和应用权限；
|
||||
9. 让 ESO 投射新凭据，重启或重新部署应用；
|
||||
10. 验证应用读写后结束维护窗口；
|
||||
11. 保留旧 database、role 和备份直到回滚窗口结束，再由管理员手工清理。
|
||||
|
||||
回滚时停止新应用写入、恢复原名称或连接配置，并重新使用旧凭据。迁移工具不得把旧
|
||||
密码、管理凭据或 dump 文件提交到 Git。真实命令、锁定方式和各现有应用验证项见
|
||||
[`migration.md`](migration.md)，并必须在实现首个可用版本前通过临时 PostgreSQL 实例
|
||||
演练。
|
||||
|
||||
## 13. 安全要求
|
||||
|
||||
1. 所有 PostgreSQL 与 OpenBao 网络访问必须支持超时和 context cancellation。
|
||||
2. homelab 部署必须通过 Deployment 挂载的共享 CA bundle 验证 TLS server identity；
|
||||
该 bundle 的信任根来自 OpenBao PKI，但不得包含 CA 私钥。Instance 默认使用
|
||||
`verify-full`，其 host 必须与服务器证书名称匹配。开发环境可以显式使用 `disable`
|
||||
明文连接。
|
||||
3. PostgreSQL 管理 role 应使用满足本规格的最小权限，不应使用 PostgreSQL
|
||||
superuser；若 extension 安装需要额外权限，必须单独记录例外。
|
||||
4. controller 的 OpenBao policy 仅覆盖受管租户 KV 操作，不授予管理凭据路径权限。
|
||||
管理凭据的 ESO 同步身份与应用凭据的 ESO 读取身份隔离。controller 只在自身
|
||||
namespace 获得管理 Secret 读取权限，不因此扩大跨 namespace Secret data 访问范围。
|
||||
5. namespace 用户不得修改 cluster-scoped Instance。
|
||||
6. 所有 identifier、extension name 和引用字段必须在发起外部调用前校验。
|
||||
7. controller 不得通过 shell 或 `psql` 子进程执行用户输入。
|
||||
8. 错误包装、结构化日志和 tracing 必须经过 Secret 泄露测试。
|
||||
|
||||
详细威胁模型和部署 policy 见 [`security.md`](security.md)。
|
||||
|
||||
## 14. 可观测性要求
|
||||
|
||||
v1alpha1 至少必须提供：
|
||||
|
||||
- Kubernetes Events：开始 provisioning、成功及需要人工处理的失败；
|
||||
- 结构化日志：resource namespace/name、Instance、generation、阶段和错误类别；
|
||||
- controller-runtime 默认 reconcile metrics；
|
||||
- 不包含 database、role、OpenBao path 等无界用户输入的低基数失败分类 metric。
|
||||
|
||||
日志和 metrics 的存在不能代替 Condition；Condition 是 API 使用者判断状态的主要方式。
|
||||
|
||||
## 15. 验收标准
|
||||
|
||||
实现 v1alpha1 第一条完整纵向切片前，测试必须覆盖：
|
||||
|
||||
1. 有效 Instance 可以建立 TLS 管理连接并变为 Ready。
|
||||
2. PostgreSQL 管理能力不可用时 Instance Ready=False，恢复后自动变为 Ready；已有
|
||||
管理凭据可正常使用时，Bao／ESO 故障不单独影响 Instance Ready。首次装配缺少有效
|
||||
管理 Secret 时不能 Ready；Tenant 的 Bao 操作失败按其自身依赖故障报告。
|
||||
3. 有效 Tenant 创建 database、作为 owner 的 login、grant、extension 和 OpenBao
|
||||
记录。
|
||||
4. 应用凭据可以实际连接且不能创建其他 database/role。
|
||||
5. 相同 generation 重复 reconcile 不改变密码、不重复创建资源。
|
||||
6. controller 在每个外部写入步骤后中断，重启后都能继续并得到相同最终状态。
|
||||
7. 预先存在且不属于当前 Tenant UID 的 database、role 或 OpenBao path 导致
|
||||
Conflict，且不修改已有资源。
|
||||
8. 目标实例实际不支持的 extension 在供应外部写入前被拒绝；扩展列表查询失败时
|
||||
按依赖故障处理，不报告为不支持。安装结果仍须回读验证。
|
||||
9. status 被清空后可以从两个外部事实来源重建。
|
||||
10. 删除 Retain Tenant 后外部资源仍存在且不再受管；重新创建同名 Tenant 报告
|
||||
Conflict。
|
||||
11. 日志、Event、Condition、metric 和 CR 中不存在生成的密码或管理凭据。
|
||||
12. 两个 namespace 对同一 Instance 申请相同名称时，只有第一个成功，第二个报告
|
||||
Conflict。
|
||||
13. 删除 Delete Tenant 时，任一步骤失败都可重试，且最终删除 database、login role、
|
||||
OpenBao KV 历史和 finalizer。
|
||||
14. 使用迁移 runbook 可以把一个现有 database 转移到新建的受管 database，并在回滚
|
||||
窗口内恢复旧服务。
|
||||
15. Tenant 只有在 ExternalSecret Ready、目标 Secret 存在且应用凭据实际可登录后才
|
||||
Ready。
|
||||
16. Tenant status 同时提供 Kubernetes Secret reference 和不含认证信息的 OpenBao API
|
||||
URL。
|
||||
17. DNS 不可用时，使用输出的 `hostaddr` 可以连接 PostgreSQL；server 证书同时覆盖
|
||||
`host` 的 DNS SAN 和 `hostaddr` 的 IP SAN，两种连接目标均可通过 `verify-full`。
|
||||
18. 两个 CR 的 `status.phase` 都能反映当前协调步骤；清空 status 后可以从外部事实重建，
|
||||
且伪造或过期 phase 不会使 controller 跳过验证或外部操作。
|
||||
|
||||
单元测试验证纯决策逻辑，adapter 集成测试使用 Docker PostgreSQL/OpenBao，controller
|
||||
集成测试使用 envtest，完整网络路径使用 Kind E2E。
|
||||
|
||||
## 16. 已确认决策
|
||||
|
||||
- v1alpha1 使用一个同时作为 database owner 的 login role，不创建额外 NOLOGIN owner。
|
||||
- v1alpha1 不接管任意现有资源，但必须提供并演练 dump/restore 迁移路径。
|
||||
- v1alpha1 同时实现默认 `Retain` 和显式 `Delete`；Delete 必须有 finalizer、所有权验证
|
||||
和完整清理路径。
|
||||
- OpenBao KV v2 mount 和 base path 是 controller 部署配置，mount 默认 `kv`，base path
|
||||
由 `--openbao-tenant-base-path` 配置并默认 `postgresql-tenants`；Tenant 不能选择 mount
|
||||
或任意远端 path，controller 根据 namespace/name 推导记录路径。
|
||||
- 租户 KV 记录固定写入 `username/password/database/host/hostaddr/port/sslmode` 七个
|
||||
原子字段；
|
||||
controller 不生成连接 URI，应用负责映射和拼装自身配置。
|
||||
- PostgreSQL TLS 使用 controller Deployment 挂载的共享 CA bundle。OpenBao PKI 是
|
||||
CA 权威并继续签发、续期 PostgreSQL server 证书；controller 只消费公开 trust
|
||||
bundle，不接触 CA 私钥。bundle 可以由 ConfigMap 或现有证书同步机制投射，不允许
|
||||
Tenant 或 Instance 选择其他 CA；开发环境可以显式使用 `sslMode: disable`。
|
||||
- 每个 PostgreSQLInstance 在其管理 database 中维护 controller 专用 registry schema。
|
||||
registry 是受管资源所有权、安装身份和 Retain 后 unmanaged 标记的权威记录；两个
|
||||
CR 的 `status.phase` 是 controller 状态机的权威 checkpoint，Instance status 不聚合
|
||||
Tenant 清单。
|
||||
- PostgreSQL database 和 role identifier 必须匹配 `^[a-z][a-z0-9_]{0,62}$`，不支持
|
||||
需要双引号的大小写或特殊字符名称。
|
||||
- External Secrets Operator 是 v1alpha1 的运行依赖。controller 管理同 namespace
|
||||
ExternalSecret，但不直接写明文 Secret；Tenant status 同时输出目标 Secret reference
|
||||
和供非 Kubernetes 消费者使用的 OpenBao API URL。
|
||||
- PostgreSQLInstance 同时声明 DNS `host` 和 IP `hostaddr`；PostgreSQL server 证书必须
|
||||
同时包含对应 DNS SAN 和 IP SAN，消费者自行选择连接目标。
|
||||
|
||||
## 17. 批准状态
|
||||
|
||||
2026-09-14 确认 extension 判定修订：v1alpha1 使用实例实际可安装列表，不实现管理员
|
||||
allowlist；后续可按需引入策略。现有 allowedExtensions 字段尚待 API 实现移除。
|
||||
|
||||
2026-09-13 已确认管理连接修订：Instance 引用 controller namespace 内的管理 Secret，
|
||||
管理员维护 ExternalSecret，由 ESO 同步；controller 不再从 Bao 直接读取管理凭据。
|
||||
此项是已批准行为，现有 API types 与实现尚待后续修改。
|
||||
|
||||
具体设计决策和本文整体已于 2026-09-10 获得批准，可以进入 API reference、测试和
|
||||
实现阶段。同日确认状态机修订：两个 CR 的 `status.phase` 是 controller 工作流的权威
|
||||
checkpoint；PostgreSQL registry 只承担所有权、安装身份和保留状态。
|
||||
|
||||
## 18. 与当前脚手架的已知差异
|
||||
|
||||
当前 API skeleton 至少需要以下调整：
|
||||
|
||||
- 删除 Tenant 自选 OpenBao path 的能力，改由部署级 mount、base path 和 Tenant
|
||||
identity 推导，并修正当前包含 `kv/` 前缀的示例；
|
||||
- 增加 controller 部署级 OpenBao KV mount 和 TLS 配置；
|
||||
- 增加部署级 OpenBao consumer address、ClusterSecretStore 和 KV base path 配置；
|
||||
- 删除独立 `ownerRole` 字段，使 login role 成为 database owner；
|
||||
- 为 Instance 增加 `hostaddr`，为 Tenant 增加目标 Secret 配置及 Secret/Bao URL 输出
|
||||
status；
|
||||
- 按已确认的 identifier 合同收紧校验；
|
||||
- 增加 PostgreSQL controller registry，记录基于 UID 的所有权、安装身份和保留状态；
|
||||
- 修正凭据 type 中遗留的 rotation 注释；
|
||||
- 使 Condition、不可变字段和 extension 追加语义具备 API 校验或明确的 reconcile
|
||||
结果。
|
||||
|
||||
这些是规格批准后的实现工作，不属于本规格本身。
|
||||
@@ -1,4 +1,4 @@
|
||||
# ADR-0001：采用 Kubernetes API 作为资源模型
|
||||
# ADR-0001：采用 Kubernetes API machinery 作为状态协调平面
|
||||
|
||||
- 状态：Accepted
|
||||
- 日期：2026-09-17
|
||||
@@ -10,16 +10,49 @@ homelab 的基础设施状态分散在多套工具和后端中。仅集中 IaC
|
||||
|
||||
## 决策
|
||||
|
||||
Ayatori 使用 Kubernetes API machinery 与 CRD 表达平台资源、引用和状态，但不将平台
|
||||
限定为容器编排系统。Controller 可以运行于专用 management environment，并管理集群外
|
||||
的 VM、LB、数据库、对象存储、DNS、凭据和托管 Kubernetes 控制面。
|
||||
Ayatori 使用 kube-apiserver、etcd、Kubernetes API machinery 与 CRD 构成 API 和状态协调
|
||||
平面。主要复用的是以下难以可靠重建的能力：
|
||||
|
||||
- 版本化对象 API、schema、defaulting、validation 与 admission；
|
||||
- 带 `resourceVersion` 的乐观并发、list/watch 与断线恢复；
|
||||
- informer/cache/workqueue 生态；
|
||||
- authentication、RBAC、namespace、审计与 API discovery；
|
||||
- spec/status、conditions、finalizer 等控制面约定。
|
||||
|
||||
这项选择不把 Ayatori 限定为容器编排系统，也不意味着原生 Kubernetes workload API 是领域
|
||||
模型。kube-apiserver 保存期望、引用和观察状态；Ayatori controller-manager 实现平台领域的
|
||||
调度、生命周期、故障恢复、垃圾回收和后端收敛。Controller 可以运行于专用 management
|
||||
environment，并管理集群外的 VM、LB、数据库、对象存储、DNS、凭据和托管 Kubernetes 控制面。
|
||||
|
||||
Ayatori 可以选择性复用 Kubernetes 内置资源的 API contract，而不采用其上游实现组件。例如，
|
||||
`core/v1 Node` 可以表达计算节点身份、capacity、conditions、labels、taints 和维护状态，由
|
||||
Ayatori Compute Agent 更新并由 Ayatori controller 消费；这不要求部署或模拟 kubelet，也不
|
||||
要求存在 Pod、CRI、kube-scheduler 或 kube-controller-manager。`Lease`、`Namespace`、
|
||||
`Secret`、`ConfigMap`、`Event` 和 RBAC 等资源同样按各自适用的 API 语义独立选择。
|
||||
|
||||
复用内置资源前必须明确其 producer、consumer、ownership、采用的字段和未采用的上游语义。
|
||||
不能因为 Kubernetes 通常将若干组件一起部署，就把这些实现关系重新带入 Ayatori。
|
||||
|
||||
Kubernetes workload 集群与 OpenSandbox、Proxmox 等一样，是通过 adapter 接入的 backend 或
|
||||
executor。它可以是远端集群，也可以完全不存在。除 Flux 和 Ayatori controllers 等管理组件的
|
||||
部署外，领域 API 不得隐含依赖 controller 所在集群的 Pod、Job、Service、NetworkPolicy、
|
||||
namespace 共置或 owner reference 语义；确有需要的能力必须由领域 API 和 adapter 契约显式表达。
|
||||
|
||||
GitOps 是长期期望状态的主要提交入口；API 是当前意图、关系和状态的在线控制面；真实后端
|
||||
仍是运行事实来源。Controller 负责三者之间持续收敛。
|
||||
|
||||
`generic-apiserver` 或 Kubernetes API aggregation 只会让 Ayatori 接管资源的服务端实现，并不会
|
||||
替代上述领域 controller。除非 CRD/kube-apiserver 的存储模型、API 语义或扩展边界形成经过验证的
|
||||
阻碍，Ayatori 不自行承担 watch、RBAC、API 兼容、存储版本迁移和高可用 API Server 的实现与运维。
|
||||
|
||||
## 结果
|
||||
|
||||
- 获得统一声明式 API、watch、RBAC、admission、conditions 和 controller 生态。
|
||||
- Ayatori controller-manager 实际承担类似 kube-controller-manager 的领域控制循环职责，必须把
|
||||
reconcile、状态迁移、恢复与后端契约作为产品核心，而不是把它们误交给 kube-apiserver。
|
||||
- 原生 Kubernetes workload 对象不能成为所有 adapter 的最低公共语义；Kubernetes 只是其中一种
|
||||
执行后端。
|
||||
- 允许由 Ayatori 自己实现合适的内置 API 资源语义；API 类型与上游 controller/runtime 不绑定。
|
||||
- 可以把机器与人工执行统一建模为异步控制循环。
|
||||
- 必须维护 CRD 版本、conversion、认证、备份和控制面升级。
|
||||
- 不在 API 中保存日志、指标、大对象或业务数据，只保存控制所需状态及引用。
|
||||
|
||||
@@ -0,0 +1,45 @@
|
||||
# ADR-0006：按实际管理缺口扩展资源 API
|
||||
|
||||
- 状态：Accepted
|
||||
- 日期：2026-09-20
|
||||
|
||||
## 背景
|
||||
|
||||
Ayatori 可以在技术上逐步加入 VM、任务、数据库、负载均衡、对象存储、KaaS、FaaS 与应用
|
||||
托管等能力。如果按传统私有云产品目录推进，项目会把后端“能够实现”的能力误当成 homelab
|
||||
实际需要的产品，并承担没有消费者的 API、controller、升级和恢复成本。
|
||||
|
||||
当前真正反复出现的问题，是 Database、LoadBalancer 和 Bucket/Object Storage 缺少符合本环境
|
||||
需求的稳定管理 API。Proxmox VM 也存在明确缺口：远程 API 能力有限，一部分操作只能登录节点
|
||||
使用 CLI 完成，因此单靠 Terraform provider 或 Proxmox API 无法覆盖期望生命周期。
|
||||
|
||||
当前 `Job` controller 是验证 Kubernetes API machinery、状态机、finalizer、回收和 adapter 边界
|
||||
的首个纵向切片。OpenSandbox 和 microVM 可以成为内部执行后端，但这不等于平台需要 Lambda、
|
||||
Cloud Run 或其他 FaaS/PaaS 产品。
|
||||
|
||||
## 决策
|
||||
|
||||
Ayatori 不设置必须完成的云产品清单。新增北向资源必须由现实消费者、重复管理缺口和持续
|
||||
reconcile 的明确收益驱动。
|
||||
|
||||
当前优先方向是：
|
||||
|
||||
1. `Database`；
|
||||
2. `LoadBalancer`；
|
||||
3. `Bucket` / Object Storage；
|
||||
4. `VirtualMachine`，其价值已确认，但实现成本更高。
|
||||
|
||||
`Run`/当前实验性的 `Job` 定位为控制面执行原语和架构验证切片，不自动扩展为面向用户的计算
|
||||
产品。KaaS 是可能有真实需求的候选能力，但不是必达终点。FaaS、Cloud Run 和应用托管默认不做，
|
||||
除非未来以新的需求和 ADR 改变决定。
|
||||
|
||||
VirtualMachine controller 对外提供稳定北向 API；南向允许根据操作选择 Proxmox API、节点上的
|
||||
受限强类型 Agent/CLI 或 `ManualTask`。节点 Agent 必须提供版本化、幂等、可观察和可审计的操作，
|
||||
不能退化为任意远程 shell。
|
||||
|
||||
## 结果
|
||||
|
||||
- 路线图可以根据当前收益调整，不把技术可行性误作产品承诺。
|
||||
- 第一个 Job controller 的实现仍有测试和架构验证价值，但其 API 不约束长期产品形态。
|
||||
- VM 被保留为核心高价值方向，同时承认其南向集成不是单一 provider 能解决的问题。
|
||||
- 每个新增资源都要独立证明生命周期和管理价值；已有 backend 不自动产生新的产品层。
|
||||
@@ -0,0 +1,61 @@
|
||||
# ADR-0007：复用 Node API 建立按需实现的 Compute 能力
|
||||
|
||||
- 状态：Accepted
|
||||
- 日期：2026-09-20
|
||||
- 实施优先级：Deferred；当前优先 Database、LoadBalancer 与 Bucket
|
||||
|
||||
## 背景
|
||||
|
||||
Ayatori 长期可能需要管理现有 Proxmox VM、当前 libvirt VM，以及允许普通计算节点临时加入、
|
||||
排空和退出。Proxmox 的远程 API 不能覆盖全部所需操作；若 Ayatori 进一步实现节点 inventory、
|
||||
简单 placement、fencing 和安全 reschedule，Proxmox 的控制面价值会逐步被替代。
|
||||
|
||||
同一物理节点未来也可能运行 OpenSandbox/Kata 等执行后端。Kata 虽然以 microVM 隔离 Pod 或
|
||||
container，但其公开生命周期是 Sandbox/Run，不是具有磁盘、NIC、console、placement、迁移和
|
||||
长期身份的 VirtualMachine 产品。
|
||||
|
||||
## 决策
|
||||
|
||||
### 节点 API
|
||||
|
||||
Ayatori 选择性复用 `core/v1 Node` 与 `coordination.k8s.io/v1 Lease` 表达计算节点身份、能力、
|
||||
容量、健康、维护状态与心跳。它们只是 API contract：由 Ayatori Compute Agent 写入，并由
|
||||
Ayatori 自有 controller 消费。
|
||||
|
||||
这项选择不引入 kubelet、Pod、CRI、kube-scheduler 或 kube-controller-manager。Compute Agent
|
||||
不是对 kubelet 的模拟或兼容实现，而是 Node API 在 Ayatori Compute 领域中的正式 producer。
|
||||
每个 Node 必须带 Ayatori ownership label；Agent 只能更新自己的 Node/status 与 Lease。
|
||||
|
||||
初版 VirtualMachine 显式指定 Node。出现实际需求后，再由 Ayatori controller 基于 Node 的
|
||||
Ready、unschedulable、taints、labels、capacity 和已有 allocation 实现小规模 filter/score。
|
||||
具体资源分配不能依靠多个 controller 反复改写 `Node.status.allocatable`；需要并发预留时增加
|
||||
独立 Allocation 资源或等价的原子分配记录。
|
||||
|
||||
### VM 数据面
|
||||
|
||||
长期主路径可以是普通 Linux Compute Node 上的 libvirt/QEMU，由受限的 Compute Agent 执行
|
||||
版本化、强类型、幂等且可观察的 VM 操作。Agent 不提供任意远程 shell。
|
||||
|
||||
Proxmox 是 brownfield 迁移后端：初期用于 adopt 现有 VM，并继续提供当前已有的集群、存储、
|
||||
备份与 HA 能力。若 Ayatori Compute 已经可靠覆盖所需 placement、fencing、存储可移植性和恢复
|
||||
语义，可以逐步把 PVE 节点迁移为普通 Compute Node；不为维持虚假 backend 对等性承诺永久支持
|
||||
所有 Proxmox 特性。
|
||||
|
||||
### HA 边界
|
||||
|
||||
自动 reschedule 必须满足：旧节点已经可靠 fenced，且 Volume 明确报告可在目标节点使用。
|
||||
任一条件无法证明时，VM 进入 Blocked/ManualTask，不得冒险在第二个节点启动。首版允许完全
|
||||
人工 placement 与恢复；不以通用 Placement、透明 live migration、多租户 SDN 或 Nova 兼容为目标。
|
||||
|
||||
### Sandbox 边界
|
||||
|
||||
OpenSandbox/Kata microVM 归属于 Run/Sandbox backend 的隔离实现，不创建 VirtualMachine 资源。
|
||||
若未来 VM 与 Sandbox 共享物理节点，容量协调必须另行形成经过验证的设计；不能仅因两者底层
|
||||
都使用 KVM 就合并其北向生命周期。
|
||||
|
||||
## 结果
|
||||
|
||||
- 复用成熟 Node/Lease API，而不继承 Kubernetes workload plane。
|
||||
- Compute 能力可以按 homelab 所需规模实现，不必复制完整 Nova。
|
||||
- PVE 帮助现有资源平滑迁移，但不是长期架构必须保留的一层。
|
||||
- Compute 方向已记录，但不改变当前 Database、LoadBalancer、Bucket 的产品优先级。
|
||||
@@ -0,0 +1,92 @@
|
||||
# ADR-0008：将 PostgreSQL Tenant Operator 合并为 Ayatori Database 模块
|
||||
|
||||
- 状态：Accepted
|
||||
- 日期：2026-09-20
|
||||
|
||||
## 背景
|
||||
|
||||
独立仓库 `postgresql-tenant-operator` 已经为 homelab 共享 PostgreSQL 设计了
|
||||
`PostgreSQLInstance` 与 `PostgreSQLTenant` API，并包含批准的行为规格、领域值对象、状态机、
|
||||
PostgreSQL ownership registry、OpenBao/External Secrets 边界、迁移与恢复文档及测试。
|
||||
|
||||
Database 是 Ayatori 当前最优先的真实管理缺口之一。继续把该 controller 作为独立产品，会重复
|
||||
维护 manager、API machinery、发布、认证、可观测性和通用 controller 约定，也会使后续应用组合
|
||||
必须跨两个控制平面理解状态。
|
||||
|
||||
截至 2026-09-20，源仓库已经合并 Instance 的 Endpoint、凭据引用、身份/版本、定义与观测目标
|
||||
等值对象，以及扩展支持模型和最小生命周期/checkpoint。它们尚未接入实际运行链路。完整 Ready
|
||||
判定、Kubernetes Secret 管理凭据与连接刷新、应用层/数据库 adapter/controller 接入、CRD 规格
|
||||
对齐及集成验证仍未完成；Tenant 的创建、凭据交付与 Retain/Delete 生命周期也未落地。
|
||||
|
||||
现有运行链路仍是直接读取 OpenBao 管理凭据的旧实现，不能作为新设计已经可用的证据。源仓库
|
||||
本地 `feature/instance-extension-observations` 还保留两个未提交文件，用于 Instance 接受扩展观测
|
||||
及测试；该工作已暂停，不能作为已合并能力或迁移基线。部分生成的 CRD/API 代码也仍落后于批准
|
||||
规范，因此迁移不能把当前工作树或全部脚手架原样复制到 Ayatori。
|
||||
|
||||
## 决策
|
||||
|
||||
PostgreSQL Tenant Operator 合并为 Ayatori 的 Database 领域模块。保留已经批准且仍适用的安全、
|
||||
所有权、幂等与删除行为，不重新发明 database、role、credential 和 registry 语义。
|
||||
|
||||
当前没有可用发布版本、没有被该 operator 托管的 PostgreSQL 实例或 Tenant，也没有需要在线
|
||||
转换的已部署 CR。因此此次合并不承担旧实现兼容性：旧运行链路可以直接撤销，不保留直接读取
|
||||
OpenBao 管理凭据的路径，也不兼容落后于规范的旧 CRD、samples 或实现细节。
|
||||
|
||||
没有部署兼容负担不等于重新设计已经批准的产品合同。源项目的系统规格、API 语义、Instance 与
|
||||
Tenant 领域模型、状态机、ownership registry、OpenBao/ExternalSecret 凭据交付、Retain/Delete、
|
||||
恢复与测试设计整体作为 Ayatori Database 模块的规范基线。除 API group、项目归属和装配结构外，
|
||||
迁移不得静默改变这些行为；确需改变时必须先单独修订规格并记录决定。
|
||||
|
||||
目标结构遵守 Ayatori 的模块化单体边界：
|
||||
|
||||
```text
|
||||
api/database/v1alpha1/
|
||||
internal/database/domain/
|
||||
internal/database/controller/
|
||||
internal/database/adapter/postgresql/
|
||||
internal/database/adapter/openbao/
|
||||
internal/database/adapter/externalsecrets/
|
||||
docs/database/
|
||||
```
|
||||
|
||||
最终目录可按 Kubebuilder 与现有模块约定微调，但 Database 不依赖 execution/Job 模块，也不把
|
||||
PostgreSQL、OpenBao 或 External Secrets 客户端放入共享万能 service/repository 层。
|
||||
|
||||
Database API 直接重构为 Ayatori 统一结构：API group 使用
|
||||
`database.ayatori.ddupan.top/v1alpha1`，Go package 使用 `api/database/v1alpha1`，controller、
|
||||
domain 与 adapter 放入 Ayatori 对应 Database 模块。原 `database.ddupan.top/v1alpha1` 不保留
|
||||
别名、conversion 或兼容入口。
|
||||
|
||||
迁移前逐项核对批准规格、领域模型与当前 Go types；冲突时以批准规格为准。代码质量通过重写
|
||||
旧运行链路、清晰 application/adapter 边界和测试实现，不通过改变已批准行为获得。无需实现在线
|
||||
CRD conversion 或数据迁移。
|
||||
|
||||
## 迁移方式
|
||||
|
||||
1. 以包含已合并 Instance 领域基础和 CI #14 的最新 `main` commit 作为 source reference；记录
|
||||
commit，将完整批准规格与设计文档迁入 Ayatori Database 文档，并迁移领域模型和纯单元测试。
|
||||
设计合同直接复用；旧运行代码不逐文件复制。
|
||||
2. 保留源仓库暂停中的脏工作树，不移动、提交或复制两个 extension observation 文件。以后可以
|
||||
先在源仓库形成独立 commit，或在 Ayatori 根据批准合同重新实现，但不得把未提交内容描述为来源。
|
||||
3. 在 Ayatori multi-group 项目中用 Kubebuilder 注册 Database API，按批准规格迁移 types，重新
|
||||
生成 `database.ayatori.ddupan.top` CRD、DeepCopy 与 RBAC；不直接复制旧生成文件或旧 `PROJECT`。
|
||||
4. 删除旧运行链路假设，以 Ayatori 当前 Go、Kubernetes 与 controller-runtime 版本重新建立
|
||||
application ports 和 adapter contract；先恢复 PostgreSQL registry/adapter contract tests。
|
||||
5. 逐片实现 Instance observe、Kubernetes Secret 管理凭据与连接刷新、Tenant provisioning、
|
||||
OpenBao、ExternalSecret、删除与恢复流程；
|
||||
每片必须包含对应单元、envtest 和真实 PostgreSQL/OpenBao 集成测试。
|
||||
6. Ayatori 中的 Database 模块达到原项目验收标准并完成迁移演练后，冻结旧仓库并将其 README
|
||||
指向 Ayatori；不同时运行两个 controller 管理同一组 CR。
|
||||
|
||||
不通过一次性 unrelated-history merge 或整仓复制保留表面上的 Git 历史。旧仓库和 source commit
|
||||
保留完整来源历史；Ayatori 迁移提交按可审阅行为切片记录 provenance。
|
||||
|
||||
## 结果
|
||||
|
||||
- Ayatori 获得第一个真实产品领域，而不是继续围绕实验性 Job 扩张。
|
||||
- 已批准的 DBaaS 设计与测试投资得到保留。
|
||||
- 单一 manager/release 不意味着领域耦合；Database 仍保持独立 package、adapter 和测试边界。
|
||||
- 可以从已合并的领域基础开始迁移；旧运行链路和未提交 extension observation 不进入首个切片。
|
||||
- 无部署兼容负担允许彻底重写旧运行链路，不为尚未使用的实现技术债保留兼容层；已批准设计合同
|
||||
仍然有效。
|
||||
- Database 使用 Ayatori 统一 API group 与目录结构，不为未投入使用的旧 group 保留入口。
|
||||
+23
-25
@@ -9,49 +9,47 @@
|
||||
- 定义 API、conditions、ownership 和 executor 公共约定。
|
||||
- 建立不可变制品与 Dev 到 Prod promotion。
|
||||
|
||||
## 1. Job Service
|
||||
## 1. Controller 纵向验证切片
|
||||
|
||||
- 实现最小 `Job` API。
|
||||
- Kubernetes Pod executor。
|
||||
- 统一日志、退出状态、超时、workspace、cache 与 artifact。
|
||||
- 接入 Gitea Actions 和平台内部 IaC 执行。
|
||||
- 使用当前最小 `Job` API 验证 watch、状态机、finalizer、取消、TTL、external reference 与
|
||||
backend adapter。
|
||||
- Kubernetes executor 不能与 management API client 或同集群 namespace 语义绑定。
|
||||
- 验证完成后，将可复用机制收敛为内部 `Run`/execution 能力；不把这一切片扩展为 FaaS、
|
||||
Cloud Run 或通用 Job Service。
|
||||
|
||||
## 2. OpenSandbox Executor
|
||||
## 2. 首批资源产品
|
||||
|
||||
- 通过 OpenSandbox lifecycle 与 execd API 创建、执行和清理 sandbox。
|
||||
- 支持强隔离任务、未知代码、嵌套容器和 AI agent。
|
||||
- 增加交互式 `Sandbox` API、TTL、endpoint 与 snapshot。
|
||||
- `Database`：PostgreSQL database、role、credential 与回收。
|
||||
- `LoadBalancer`：Envoy 配置/xDS、健康检查、固定 VIP 与 GoBGP 路由宣告。
|
||||
- `Bucket`：SeaweedFS bucket、policy、credential 与删除策略。
|
||||
- 按纵向价值选择先后，不为三者预先建立统一 provider 框架。
|
||||
|
||||
## 3. Human Executor
|
||||
## 3. Human Executor 与延迟自动化
|
||||
|
||||
- `ManualTask`、`TaskReport` 和版本化 Runbook。
|
||||
- Telegram/Email 通知、领取、提醒和升级。
|
||||
- 后端验证与上游 reconcile 恢复。
|
||||
|
||||
## 4. LBaaS
|
||||
## 4. Compute 与节点生命周期
|
||||
|
||||
- Envoy 配置/xDS adapter。
|
||||
- 健康检查与 GoBGP 路由宣告。
|
||||
- 固定 VIP、listener/backend 引用和故障恢复。
|
||||
|
||||
## 5. Compute 与节点生命周期
|
||||
|
||||
- Proxmox VM adapter 与现有资源 adopt。
|
||||
- ComputeNode 加入、drain 和 `SafeToRemove`。
|
||||
- 建立稳定的 `VirtualMachine` 北向 API，并支持现有资源 adopt。
|
||||
- 南向按能力组合 Proxmox API、节点受限 Agent/CLI 与 `ManualTask`，不假设 Proxmox API 完整。
|
||||
- Node 加入、drain 和 `SafeToRemove`；Node API 由 Ayatori Compute Agent 实现，不依赖 kubelet。
|
||||
- StorageClass、StoragePool、Volume 与迁移计划。
|
||||
- 先支持人工磁盘迁移，再通过 Job executor 自动化。
|
||||
- 先支持人工磁盘迁移，再按实际收益自动化。
|
||||
|
||||
## 6. 数据服务
|
||||
## 5. 条件性扩展
|
||||
|
||||
- PostgreSQL database/role/credential。
|
||||
- SeaweedFS bucket/policy/credential。
|
||||
- DNS 与证书资源。
|
||||
- OpenSandbox/microVM 可以作为内部 Run backend，但不由此产生 FaaS 产品承诺。
|
||||
- DNS、证书和 Credential 只有在跨系统协调收益明确时形成独立资源。
|
||||
- KaaS 只有出现托管控制面、租户隔离或频繁集群生命周期的真实需求时才立项。
|
||||
|
||||
## 7. KaaS
|
||||
### KaaS 候选方案
|
||||
|
||||
- 采用成熟 hosted-control-plane 后端。
|
||||
- 组合控制面、worker、LB、DNS、网络和凭据。
|
||||
- 用户集群只暴露 worker node，控制面完全由平台托管。
|
||||
- 本节记录候选实现边界，不构成路线图承诺。
|
||||
|
||||
## 首个业务里程碑
|
||||
|
||||
|
||||
@@ -29,6 +29,20 @@ Ayatori 是具有产品质量的内部平台，而非初期即面向公众的通
|
||||
平台允许对当前环境形成明确意见：Proxmox、OpenSandbox、Envoy、GoBGP、OpenBao、
|
||||
PostgreSQL、SeaweedFS、Samba AD DNS、Cloudflare 和 Flux 都可以是已知实现。
|
||||
|
||||
Ayatori 不以补齐传统私有云或公有云的产品目录为目标。一个资源只有同时满足以下条件，才进入
|
||||
北向 API：
|
||||
|
||||
1. homelab 存在现实消费者和重复需求；
|
||||
2. 现有后端 API 或 IaC 无法提供足够的管理体验；
|
||||
3. 持续 observe/reconcile 明显优于一次性自动化；
|
||||
4. 统一生命周期、状态、组合或权限能产生可验证的收益；
|
||||
5. 收益足以承担长期 API 兼容、controller 和恢复测试成本。
|
||||
|
||||
当前最明确的管理缺口是 Database、LoadBalancer 与 Bucket/Object Storage。VirtualMachine 同样
|
||||
具有明确价值：Proxmox 的 API 不能覆盖所需的全部生命周期，一部分操作必须在节点上通过 CLI
|
||||
完成，因此 Ayatori 可以提供稳定北向 API，并在南向组合 Proxmox API、受限节点 Agent 与人工
|
||||
任务。KaaS 只有在出现托管控制面的实际需求时才进入实现，不是产品路线的必达终点。
|
||||
|
||||
## 非目标
|
||||
|
||||
- 不替代 hypervisor、microVM runtime、数据库、对象存储或网络协议栈。
|
||||
@@ -36,3 +50,5 @@ PostgreSQL、SeaweedFS、Samba AD DNS、Cloudflare 和 Flux 都可以是已知
|
||||
- 不以隐藏全部后端信息或制造虚假多云可移植性为目标。
|
||||
- 不创建理解所有应用需求的中央 Application controller。
|
||||
- 不要求所有人工步骤立即自动化。
|
||||
- 不因为已有 Run、OpenSandbox 或 microVM backend，就构建 FaaS、Cloud Run 或应用托管产品。
|
||||
- 不预先承诺 KaaS；它是需求驱动的候选能力。
|
||||
|
||||
@@ -1,132 +0,0 @@
|
||||
package kubernetes
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
executionv1alpha1 "git.ddupan.top/panxiao81/ayatori/api/execution/v1alpha1"
|
||||
batchv1 "k8s.io/api/batch/v1"
|
||||
corev1 "k8s.io/api/core/v1"
|
||||
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
||||
"k8s.io/apimachinery/pkg/runtime/schema"
|
||||
)
|
||||
|
||||
const (
|
||||
ControllerName = "execution.ayatori.ddupan.top/kubernetes"
|
||||
ReferenceType = "Job"
|
||||
JobUIDLabel = "execution.ayatori.ddupan.top/job-uid"
|
||||
)
|
||||
|
||||
var ayatoriJobGVK = schema.GroupVersionKind{
|
||||
Group: executionv1alpha1.GroupVersion.Group,
|
||||
Version: executionv1alpha1.GroupVersion.Version,
|
||||
Kind: "Job",
|
||||
}
|
||||
|
||||
// BuildJob translates the stable execution API into the Kubernetes adapter's
|
||||
// backend object. It intentionally does not accept or expose a PodSpec.
|
||||
func BuildJob(
|
||||
job *executionv1alpha1.Job,
|
||||
parameters *executionv1alpha1.KubernetesExecutionParameters,
|
||||
resources executionv1alpha1.ExecutionResourceRequirements,
|
||||
) *batchv1.Job {
|
||||
backoffLimit := int32(0)
|
||||
controller := true
|
||||
blockOwnerDeletion := true
|
||||
|
||||
//nolint:modernize // ObjectMeta is promoted through embedded TypeMeta; embedlit produces invalid Go here.
|
||||
return &batchv1.Job{
|
||||
ObjectMeta: metav1.ObjectMeta{
|
||||
Name: job.Name,
|
||||
Namespace: job.Namespace,
|
||||
Labels: map[string]string{
|
||||
JobUIDLabel: string(job.UID),
|
||||
},
|
||||
OwnerReferences: []metav1.OwnerReference{{
|
||||
APIVersion: ayatoriJobGVK.GroupVersion().String(),
|
||||
Kind: ayatoriJobGVK.Kind,
|
||||
Name: job.Name,
|
||||
UID: job.UID,
|
||||
Controller: &controller,
|
||||
BlockOwnerDeletion: &blockOwnerDeletion,
|
||||
}},
|
||||
},
|
||||
Spec: batchv1.JobSpec{
|
||||
BackoffLimit: &backoffLimit,
|
||||
Template: corev1.PodTemplateSpec{
|
||||
ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{JobUIDLabel: string(job.UID)}},
|
||||
Spec: corev1.PodSpec{
|
||||
RestartPolicy: corev1.RestartPolicyNever,
|
||||
ServiceAccountName: parameters.Spec.ServiceAccountName,
|
||||
RuntimeClassName: optionalString(parameters.Spec.RuntimeClassName),
|
||||
NodeSelector: parameters.Spec.Scheduling.NodeSelector,
|
||||
Tolerations: parameters.Spec.Scheduling.Tolerations,
|
||||
SecurityContext: parameters.Spec.PodSecurityContext,
|
||||
ImagePullSecrets: job.Spec.Task.ImagePullSecrets,
|
||||
Containers: []corev1.Container{{
|
||||
Name: "task",
|
||||
Image: job.Spec.Task.Image,
|
||||
ImagePullPolicy: parameters.Spec.ImagePullPolicy,
|
||||
Command: job.Spec.Task.Command,
|
||||
Args: job.Spec.Task.Args,
|
||||
WorkingDir: job.Spec.Task.WorkingDir,
|
||||
Env: environment(job.Spec.Task.Env),
|
||||
Resources: resourceRequirements(resources),
|
||||
}},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func ValidateOwnership(owner *executionv1alpha1.Job, backend *batchv1.Job) error {
|
||||
if backend.Labels[JobUIDLabel] != string(owner.UID) {
|
||||
return fmt.Errorf("backend Job %s/%s is not owned by Ayatori Job UID %s", backend.Namespace, backend.Name, owner.UID)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func environment(values []executionv1alpha1.EnvVar) []corev1.EnvVar {
|
||||
result := make([]corev1.EnvVar, 0, len(values))
|
||||
for _, value := range values {
|
||||
env := corev1.EnvVar{Name: value.Name}
|
||||
if value.Value != nil {
|
||||
env.Value = *value.Value
|
||||
}
|
||||
if value.ValueFrom != nil {
|
||||
env.ValueFrom = &corev1.EnvVarSource{
|
||||
SecretKeyRef: value.ValueFrom.SecretKeyRef,
|
||||
ConfigMapKeyRef: value.ValueFrom.ConfigMapKeyRef,
|
||||
}
|
||||
}
|
||||
result = append(result, env)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
func resourceRequirements(resources executionv1alpha1.ExecutionResourceRequirements) corev1.ResourceRequirements {
|
||||
return corev1.ResourceRequirements{
|
||||
Requests: resourceList(resources.Requests),
|
||||
Limits: resourceList(resources.Limits),
|
||||
}
|
||||
}
|
||||
|
||||
func resourceList(values executionv1alpha1.ResourceValues) corev1.ResourceList {
|
||||
result := corev1.ResourceList{}
|
||||
if values.CPU != nil {
|
||||
result[corev1.ResourceCPU] = values.CPU.DeepCopy()
|
||||
}
|
||||
if values.Memory != nil {
|
||||
result[corev1.ResourceMemory] = values.Memory.DeepCopy()
|
||||
}
|
||||
if len(result) == 0 {
|
||||
return nil
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
func optionalString(value string) *string {
|
||||
if value == "" {
|
||||
return nil
|
||||
}
|
||||
return &value
|
||||
}
|
||||
@@ -1,71 +0,0 @@
|
||||
package kubernetes
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
executionv1alpha1 "git.ddupan.top/panxiao81/ayatori/api/execution/v1alpha1"
|
||||
corev1 "k8s.io/api/core/v1"
|
||||
"k8s.io/apimachinery/pkg/api/resource"
|
||||
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
||||
"k8s.io/apimachinery/pkg/types"
|
||||
)
|
||||
|
||||
func TestBuildJob(t *testing.T) {
|
||||
literal := "world"
|
||||
cpuRequest := resource.MustParse("100m")
|
||||
memoryLimit := resource.MustParse("128Mi")
|
||||
//nolint:modernize // ObjectMeta is promoted through embedded TypeMeta; embedlit produces invalid Go here.
|
||||
job := &executionv1alpha1.Job{
|
||||
ObjectMeta: metav1.ObjectMeta{Name: "hello", Namespace: "ci", UID: types.UID("job-uid")},
|
||||
Spec: executionv1alpha1.JobSpec{Task: executionv1alpha1.TaskSpec{
|
||||
Image: "alpine:3.22", Command: []string{"echo"}, Args: []string{"hello"},
|
||||
Env: []executionv1alpha1.EnvVar{
|
||||
{Name: "TARGET", Value: &literal},
|
||||
{Name: "TOKEN", ValueFrom: &executionv1alpha1.EnvVarSource{
|
||||
//nolint:modernize // LocalObjectReference is an embedded Kubernetes API field.
|
||||
SecretKeyRef: &corev1.SecretKeySelector{LocalObjectReference: corev1.LocalObjectReference{Name: "token"}, Key: "value"},
|
||||
}},
|
||||
},
|
||||
}},
|
||||
}
|
||||
parameters := &executionv1alpha1.KubernetesExecutionParameters{Spec: executionv1alpha1.KubernetesExecutionParametersSpec{
|
||||
ServiceAccountName: "runner", RuntimeClassName: "runc", ImagePullPolicy: corev1.PullIfNotPresent,
|
||||
Scheduling: executionv1alpha1.KubernetesSchedulingParameters{NodeSelector: map[string]string{"role": "execution"}},
|
||||
}}
|
||||
resources := executionv1alpha1.ExecutionResourceRequirements{
|
||||
Requests: executionv1alpha1.ResourceValues{CPU: &cpuRequest},
|
||||
Limits: executionv1alpha1.ResourceValues{Memory: &memoryLimit},
|
||||
}
|
||||
|
||||
backend := BuildJob(job, parameters, resources)
|
||||
pod := backend.Spec.Template.Spec
|
||||
if backend.Spec.BackoffLimit == nil || *backend.Spec.BackoffLimit != 0 {
|
||||
t.Fatalf("backoffLimit = %v, want 0", backend.Spec.BackoffLimit)
|
||||
}
|
||||
if pod.RestartPolicy != corev1.RestartPolicyNever || pod.ServiceAccountName != "runner" {
|
||||
t.Fatalf("unexpected pod execution policy: %#v", pod)
|
||||
}
|
||||
if pod.RuntimeClassName == nil || *pod.RuntimeClassName != "runc" {
|
||||
t.Fatalf("runtimeClassName = %v, want runc", pod.RuntimeClassName)
|
||||
}
|
||||
container := pod.Containers[0]
|
||||
if container.Resources.Requests.Cpu().Cmp(cpuRequest) != 0 || container.Resources.Limits.Memory().Cmp(memoryLimit) != 0 {
|
||||
t.Fatalf("resources were not mapped: %#v", container.Resources)
|
||||
}
|
||||
if container.Env[1].ValueFrom == nil || container.Env[1].ValueFrom.SecretKeyRef.Name != "token" {
|
||||
t.Fatalf("secret reference was not preserved: %#v", container.Env[1])
|
||||
}
|
||||
if backend.Labels[JobUIDLabel] != "job-uid" || backend.OwnerReferences[0].UID != job.UID {
|
||||
t.Fatalf("ownership identity was not preserved: %#v", backend.ObjectMeta)
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateOwnership(t *testing.T) {
|
||||
job := &executionv1alpha1.Job{}
|
||||
job.UID = types.UID("expected")
|
||||
backend := BuildJob(job, &executionv1alpha1.KubernetesExecutionParameters{}, executionv1alpha1.ExecutionResourceRequirements{})
|
||||
backend.Labels[JobUIDLabel] = "different"
|
||||
if err := ValidateOwnership(job, backend); err == nil {
|
||||
t.Fatal("ValidateOwnership() succeeded for a different Job UID")
|
||||
}
|
||||
}
|
||||
@@ -1,397 +0,0 @@
|
||||
package controller
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"slices"
|
||||
"time"
|
||||
|
||||
executionv1alpha1 "git.ddupan.top/panxiao81/ayatori/api/execution/v1alpha1"
|
||||
kubernetesadapter "git.ddupan.top/panxiao81/ayatori/internal/adapter/kubernetes"
|
||||
batchv1 "k8s.io/api/batch/v1"
|
||||
corev1 "k8s.io/api/core/v1"
|
||||
apierrors "k8s.io/apimachinery/pkg/api/errors"
|
||||
"k8s.io/apimachinery/pkg/api/meta"
|
||||
"k8s.io/apimachinery/pkg/api/resource"
|
||||
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
||||
"k8s.io/apimachinery/pkg/labels"
|
||||
"k8s.io/apimachinery/pkg/types"
|
||||
ctrl "sigs.k8s.io/controller-runtime"
|
||||
"sigs.k8s.io/controller-runtime/pkg/client"
|
||||
"sigs.k8s.io/controller-runtime/pkg/log"
|
||||
)
|
||||
|
||||
const (
|
||||
jobFinalizer = "execution.ayatori.ddupan.top/job-cleanup"
|
||||
reasonResultUnknown = "ResultUnknown"
|
||||
)
|
||||
|
||||
// JobReconciler executes Ayatori Jobs using supported adapters.
|
||||
type JobReconciler struct {
|
||||
client.Client
|
||||
Now func() time.Time
|
||||
}
|
||||
|
||||
// +kubebuilder:rbac:groups=execution.ayatori.ddupan.top,resources=jobs,verbs=get;list;watch;update;patch
|
||||
// +kubebuilder:rbac:groups=execution.ayatori.ddupan.top,resources=jobs/status,verbs=get;update;patch
|
||||
// +kubebuilder:rbac:groups=execution.ayatori.ddupan.top,resources=jobs/finalizers,verbs=update
|
||||
// +kubebuilder:rbac:groups=execution.ayatori.ddupan.top,resources=jobclasses;kubernetesexecutionparameters,verbs=get;list;watch
|
||||
// +kubebuilder:rbac:groups=batch,resources=jobs,verbs=get;list;watch;create;delete
|
||||
// +kubebuilder:rbac:groups="",resources=namespaces;serviceaccounts,verbs=get;list;watch
|
||||
|
||||
func (r *JobReconciler) Reconcile(ctx context.Context, request ctrl.Request) (ctrl.Result, error) {
|
||||
logger := log.FromContext(ctx)
|
||||
job := &executionv1alpha1.Job{}
|
||||
if err := r.Get(ctx, request.NamespacedName, job); err != nil {
|
||||
return ctrl.Result{}, client.IgnoreNotFound(err)
|
||||
}
|
||||
|
||||
if !job.DeletionTimestamp.IsZero() {
|
||||
return ctrl.Result{}, r.finalize(ctx, job)
|
||||
}
|
||||
if isTerminal(job) {
|
||||
return ctrl.Result{}, nil
|
||||
}
|
||||
if job.Spec.DesiredState == executionv1alpha1.JobDesiredStateCancelled {
|
||||
return ctrl.Result{}, r.cancel(ctx, job)
|
||||
}
|
||||
|
||||
if !containsString(job.Finalizers, jobFinalizer) {
|
||||
job.Finalizers = append(job.Finalizers, jobFinalizer)
|
||||
if err := r.Update(ctx, job); err != nil {
|
||||
return ctrl.Result{}, err
|
||||
}
|
||||
return ctrl.Result{}, nil
|
||||
}
|
||||
if job.Status.Execution != nil {
|
||||
return ctrl.Result{}, r.observeExisting(ctx, job)
|
||||
}
|
||||
|
||||
class, parameters, resources, waiting, err := r.resolve(ctx, job)
|
||||
if err != nil {
|
||||
return ctrl.Result{}, err
|
||||
}
|
||||
if waiting {
|
||||
return ctrl.Result{RequeueAfter: 30 * time.Second}, nil
|
||||
}
|
||||
|
||||
backend := &batchv1.Job{}
|
||||
key := types.NamespacedName{Namespace: job.Namespace, Name: job.Name}
|
||||
err = r.Get(ctx, key, backend)
|
||||
if apierrors.IsNotFound(err) {
|
||||
backend = kubernetesadapter.BuildJob(job, parameters, resources)
|
||||
if err := r.Create(ctx, backend); err != nil {
|
||||
return ctrl.Result{}, err
|
||||
}
|
||||
logger.Info("Created Kubernetes backend Job", "backend", key)
|
||||
return ctrl.Result{}, r.markScheduled(ctx, job, class, parameters, resources, backend)
|
||||
}
|
||||
if err != nil {
|
||||
return ctrl.Result{}, err
|
||||
}
|
||||
if err := kubernetesadapter.ValidateOwnership(job, backend); err != nil {
|
||||
return ctrl.Result{}, r.setCondition(ctx, job, metav1.Condition{
|
||||
Type: executionv1alpha1.JobConditionScheduled, Status: metav1.ConditionFalse,
|
||||
Reason: "BackendConflict", Message: err.Error(),
|
||||
})
|
||||
}
|
||||
if !conditionTrue(job.Status.Conditions, executionv1alpha1.JobConditionScheduled) {
|
||||
return ctrl.Result{}, r.markScheduled(ctx, job, class, parameters, resources, backend)
|
||||
}
|
||||
return ctrl.Result{}, r.observe(ctx, job, backend)
|
||||
}
|
||||
|
||||
func (r *JobReconciler) observeExisting(ctx context.Context, job *executionv1alpha1.Job) error {
|
||||
if job.Status.Execution.Adapter != "kubernetes" {
|
||||
return r.setCondition(ctx, job, metav1.Condition{
|
||||
Type: executionv1alpha1.JobConditionSucceeded, Status: metav1.ConditionUnknown,
|
||||
Reason: reasonResultUnknown, Message: fmt.Sprintf("adapter %q is not available", job.Status.Execution.Adapter),
|
||||
})
|
||||
}
|
||||
backend := &batchv1.Job{}
|
||||
key := types.NamespacedName{Namespace: job.Namespace, Name: job.Name}
|
||||
if err := r.Get(ctx, key, backend); err != nil {
|
||||
if apierrors.IsNotFound(err) {
|
||||
return r.setCondition(ctx, job, metav1.Condition{
|
||||
Type: executionv1alpha1.JobConditionSucceeded, Status: metav1.ConditionUnknown,
|
||||
Reason: reasonResultUnknown, Message: "Kubernetes backend Job is missing",
|
||||
})
|
||||
}
|
||||
return err
|
||||
}
|
||||
if err := kubernetesadapter.ValidateOwnership(job, backend); err != nil {
|
||||
return r.setCondition(ctx, job, metav1.Condition{
|
||||
Type: executionv1alpha1.JobConditionSucceeded, Status: metav1.ConditionUnknown,
|
||||
Reason: reasonResultUnknown, Message: err.Error(),
|
||||
})
|
||||
}
|
||||
return r.observe(ctx, job, backend)
|
||||
}
|
||||
|
||||
func (r *JobReconciler) resolve(
|
||||
ctx context.Context,
|
||||
job *executionv1alpha1.Job,
|
||||
) (*executionv1alpha1.JobClass, *executionv1alpha1.KubernetesExecutionParameters, executionv1alpha1.ExecutionResourceRequirements, bool, error) {
|
||||
if job.Spec.JobClassName == "" {
|
||||
return nil, nil, executionv1alpha1.ExecutionResourceRequirements{}, true, r.reject(ctx, job, "NoDefaultJobClass", "spec.jobClassName is required in the first implementation slice")
|
||||
}
|
||||
|
||||
class := &executionv1alpha1.JobClass{}
|
||||
if err := r.Get(ctx, types.NamespacedName{Name: job.Spec.JobClassName}, class); err != nil {
|
||||
if apierrors.IsNotFound(err) {
|
||||
return nil, nil, executionv1alpha1.ExecutionResourceRequirements{}, true, r.reject(ctx, job, "JobClassNotFound", fmt.Sprintf("JobClass %q does not exist", job.Spec.JobClassName))
|
||||
}
|
||||
return nil, nil, executionv1alpha1.ExecutionResourceRequirements{}, false, err
|
||||
}
|
||||
if class.Spec.ControllerName != kubernetesadapter.ControllerName {
|
||||
return nil, nil, executionv1alpha1.ExecutionResourceRequirements{}, true, r.reject(ctx, job, "UnsupportedController", fmt.Sprintf("controller %q is not supported", class.Spec.ControllerName))
|
||||
}
|
||||
ref := class.Spec.ParametersRef
|
||||
if ref.Group != executionv1alpha1.GroupVersion.Group || ref.Kind != "KubernetesExecutionParameters" {
|
||||
return nil, nil, executionv1alpha1.ExecutionResourceRequirements{}, true, r.reject(ctx, job, "InvalidParametersReference", "JobClass must reference KubernetesExecutionParameters")
|
||||
}
|
||||
if allowed, err := r.namespaceAllowed(ctx, job.Namespace, class.Spec.AllowedNamespaces); err != nil {
|
||||
return nil, nil, executionv1alpha1.ExecutionResourceRequirements{}, false, err
|
||||
} else if !allowed {
|
||||
return nil, nil, executionv1alpha1.ExecutionResourceRequirements{}, true, r.reject(ctx, job, "NamespaceNotAllowed", fmt.Sprintf("namespace %q is not allowed by JobClass %q", job.Namespace, class.Name))
|
||||
}
|
||||
|
||||
parameters := &executionv1alpha1.KubernetesExecutionParameters{}
|
||||
if err := r.Get(ctx, types.NamespacedName{Name: ref.Name}, parameters); err != nil {
|
||||
if apierrors.IsNotFound(err) {
|
||||
return nil, nil, executionv1alpha1.ExecutionResourceRequirements{}, true, r.reject(ctx, job, "ParametersNotFound", fmt.Sprintf("KubernetesExecutionParameters %q does not exist", ref.Name))
|
||||
}
|
||||
return nil, nil, executionv1alpha1.ExecutionResourceRequirements{}, false, err
|
||||
}
|
||||
serviceAccount := &corev1.ServiceAccount{}
|
||||
if err := r.Get(ctx, types.NamespacedName{Namespace: job.Namespace, Name: parameters.Spec.ServiceAccountName}, serviceAccount); err != nil {
|
||||
if apierrors.IsNotFound(err) {
|
||||
return nil, nil, executionv1alpha1.ExecutionResourceRequirements{}, true, r.reject(ctx, job, "ServiceAccountNotFound", fmt.Sprintf("ServiceAccount %q does not exist", parameters.Spec.ServiceAccountName))
|
||||
}
|
||||
return nil, nil, executionv1alpha1.ExecutionResourceRequirements{}, false, err
|
||||
}
|
||||
|
||||
resources := applyResourceDefaults(job.Spec.Resources, class.Spec.Resources.Defaults)
|
||||
if err := validateResources(resources); err != nil {
|
||||
return nil, nil, executionv1alpha1.ExecutionResourceRequirements{}, true, r.reject(ctx, job, "InvalidResources", err.Error())
|
||||
}
|
||||
if err := r.accept(ctx, job, class, parameters, resources); err != nil {
|
||||
return nil, nil, executionv1alpha1.ExecutionResourceRequirements{}, false, err
|
||||
}
|
||||
return class, parameters, resources, false, nil
|
||||
}
|
||||
|
||||
func (r *JobReconciler) namespaceAllowed(ctx context.Context, namespace string, selector *metav1.LabelSelector) (bool, error) {
|
||||
if selector == nil {
|
||||
return true, nil
|
||||
}
|
||||
ns := &corev1.Namespace{}
|
||||
if err := r.Get(ctx, types.NamespacedName{Name: namespace}, ns); err != nil {
|
||||
return false, err
|
||||
}
|
||||
compiled, err := metav1.LabelSelectorAsSelector(selector)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
return compiled.Matches(labels.Set(ns.Labels)), nil
|
||||
}
|
||||
|
||||
func (r *JobReconciler) accept(ctx context.Context, job *executionv1alpha1.Job, class *executionv1alpha1.JobClass, parameters *executionv1alpha1.KubernetesExecutionParameters, resources executionv1alpha1.ExecutionResourceRequirements) error {
|
||||
job.Status.ResolvedJobClass = &executionv1alpha1.ResolvedJobClassReference{
|
||||
Name: class.Name, UID: class.UID, ControllerName: class.Spec.ControllerName,
|
||||
ParametersRef: executionv1alpha1.ParametersReference{
|
||||
Group: class.Spec.ParametersRef.Group, Kind: class.Spec.ParametersRef.Kind,
|
||||
Name: parameters.Name, UID: parameters.UID,
|
||||
},
|
||||
}
|
||||
job.Status.EffectiveResources = resources
|
||||
return r.setCondition(ctx, job, metav1.Condition{
|
||||
Type: executionv1alpha1.JobConditionAccepted, Status: metav1.ConditionTrue,
|
||||
Reason: "Accepted", Message: fmt.Sprintf("JobClass %q accepted", class.Name),
|
||||
})
|
||||
}
|
||||
|
||||
func (r *JobReconciler) reject(ctx context.Context, job *executionv1alpha1.Job, reason, message string) error {
|
||||
return r.setCondition(ctx, job, metav1.Condition{
|
||||
Type: executionv1alpha1.JobConditionAccepted, Status: metav1.ConditionFalse,
|
||||
Reason: reason, Message: message,
|
||||
})
|
||||
}
|
||||
|
||||
func (r *JobReconciler) markScheduled(ctx context.Context, job *executionv1alpha1.Job, class *executionv1alpha1.JobClass, parameters *executionv1alpha1.KubernetesExecutionParameters, resources executionv1alpha1.ExecutionResourceRequirements, backend *batchv1.Job) error {
|
||||
job.Status.ResolvedJobClass = &executionv1alpha1.ResolvedJobClassReference{
|
||||
Name: class.Name, UID: class.UID, ControllerName: class.Spec.ControllerName,
|
||||
ParametersRef: executionv1alpha1.ParametersReference{Group: class.Spec.ParametersRef.Group, Kind: class.Spec.ParametersRef.Kind, Name: parameters.Name, UID: parameters.UID},
|
||||
}
|
||||
job.Status.EffectiveResources = resources
|
||||
job.Status.Execution = &executionv1alpha1.ExecutionStatus{
|
||||
Adapter: "kubernetes",
|
||||
References: []executionv1alpha1.ExecutionReference{{Type: kubernetesadapter.ReferenceType, ID: string(backend.UID)}},
|
||||
}
|
||||
meta.SetStatusCondition(&job.Status.Conditions, condition(job, executionv1alpha1.JobConditionAccepted, metav1.ConditionTrue, "Accepted", "Job accepted"))
|
||||
meta.SetStatusCondition(&job.Status.Conditions, condition(job, executionv1alpha1.JobConditionScheduled, metav1.ConditionTrue, "BackendCreated", "Kubernetes Job created"))
|
||||
meta.SetStatusCondition(&job.Status.Conditions, condition(job, executionv1alpha1.JobConditionSucceeded, metav1.ConditionUnknown, "Pending", "Waiting for task to start"))
|
||||
job.Status.ObservedGeneration = job.Generation
|
||||
return r.Status().Update(ctx, job)
|
||||
}
|
||||
|
||||
func (r *JobReconciler) observe(ctx context.Context, job *executionv1alpha1.Job, backend *batchv1.Job) error {
|
||||
if job.Status.StartTime == nil && backend.Status.StartTime != nil {
|
||||
job.Status.StartTime = backend.Status.StartTime.DeepCopy()
|
||||
}
|
||||
for _, backendCondition := range backend.Status.Conditions {
|
||||
switch {
|
||||
case backendCondition.Type == batchv1.JobComplete && backendCondition.Status == corev1.ConditionTrue:
|
||||
completion := backend.Status.CompletionTime
|
||||
if completion == nil {
|
||||
now := metav1.NewTime(r.now())
|
||||
completion = &now
|
||||
}
|
||||
job.Status.CompletionTime = completion.DeepCopy()
|
||||
job.Status.Result = &executionv1alpha1.JobResult{Reason: "Completed"}
|
||||
return r.setCondition(ctx, job, metav1.Condition{Type: executionv1alpha1.JobConditionSucceeded, Status: metav1.ConditionTrue, Reason: "Completed", Message: backendCondition.Message})
|
||||
case backendCondition.Type == batchv1.JobFailed && backendCondition.Status == corev1.ConditionTrue:
|
||||
completion := metav1.NewTime(r.now())
|
||||
job.Status.CompletionTime = &completion
|
||||
job.Status.Result = &executionv1alpha1.JobResult{Reason: "ProcessFailed"}
|
||||
return r.setCondition(ctx, job, metav1.Condition{Type: executionv1alpha1.JobConditionSucceeded, Status: metav1.ConditionFalse, Reason: "ProcessFailed", Message: backendCondition.Message})
|
||||
}
|
||||
}
|
||||
reason := "Pending"
|
||||
message := "Waiting for task to start"
|
||||
if backend.Status.StartTime != nil || backend.Status.Active > 0 {
|
||||
reason = "Running"
|
||||
message = "Task is running"
|
||||
}
|
||||
return r.setCondition(ctx, job, metav1.Condition{Type: executionv1alpha1.JobConditionSucceeded, Status: metav1.ConditionUnknown, Reason: reason, Message: message})
|
||||
}
|
||||
|
||||
func (r *JobReconciler) cancel(ctx context.Context, job *executionv1alpha1.Job) error {
|
||||
backend := &batchv1.Job{}
|
||||
key := types.NamespacedName{Namespace: job.Namespace, Name: job.Name}
|
||||
err := r.Get(ctx, key, backend)
|
||||
if err == nil {
|
||||
if err := kubernetesadapter.ValidateOwnership(job, backend); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, backendCondition := range backend.Status.Conditions {
|
||||
if (backendCondition.Type == batchv1.JobComplete || backendCondition.Type == batchv1.JobFailed) &&
|
||||
backendCondition.Status == corev1.ConditionTrue {
|
||||
return r.observe(ctx, job, backend)
|
||||
}
|
||||
}
|
||||
if err := r.Delete(ctx, backend, client.PropagationPolicy(metav1.DeletePropagationBackground)); err != nil && !apierrors.IsNotFound(err) {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
if !apierrors.IsNotFound(err) {
|
||||
return err
|
||||
}
|
||||
now := metav1.NewTime(r.now())
|
||||
job.Status.CompletionTime = &now
|
||||
job.Status.Result = &executionv1alpha1.JobResult{Reason: "Cancelled"}
|
||||
return r.setCondition(ctx, job, metav1.Condition{Type: executionv1alpha1.JobConditionSucceeded, Status: metav1.ConditionFalse, Reason: "Cancelled", Message: "Execution cancelled"})
|
||||
}
|
||||
|
||||
func (r *JobReconciler) finalize(ctx context.Context, job *executionv1alpha1.Job) error {
|
||||
if !containsString(job.Finalizers, jobFinalizer) {
|
||||
return nil
|
||||
}
|
||||
backend := &batchv1.Job{}
|
||||
key := types.NamespacedName{Namespace: job.Namespace, Name: job.Name}
|
||||
if err := r.Get(ctx, key, backend); err == nil {
|
||||
if err := kubernetesadapter.ValidateOwnership(job, backend); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := r.Delete(ctx, backend, client.PropagationPolicy(metav1.DeletePropagationBackground)); err != nil && !apierrors.IsNotFound(err) {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
} else if !apierrors.IsNotFound(err) {
|
||||
return err
|
||||
}
|
||||
job.Finalizers = removeString(job.Finalizers, jobFinalizer)
|
||||
return r.Update(ctx, job)
|
||||
}
|
||||
|
||||
func (r *JobReconciler) setCondition(ctx context.Context, job *executionv1alpha1.Job, next metav1.Condition) error {
|
||||
meta.SetStatusCondition(&job.Status.Conditions, condition(job, next.Type, next.Status, next.Reason, next.Message))
|
||||
job.Status.ObservedGeneration = job.Generation
|
||||
return r.Status().Update(ctx, job)
|
||||
}
|
||||
|
||||
func condition(job *executionv1alpha1.Job, conditionType string, status metav1.ConditionStatus, reason, message string) metav1.Condition {
|
||||
return metav1.Condition{Type: conditionType, Status: status, Reason: reason, Message: message, ObservedGeneration: job.Generation}
|
||||
}
|
||||
|
||||
func conditionTrue(conditions []metav1.Condition, conditionType string) bool {
|
||||
current := meta.FindStatusCondition(conditions, conditionType)
|
||||
return current != nil && current.Status == metav1.ConditionTrue
|
||||
}
|
||||
|
||||
func isTerminal(job *executionv1alpha1.Job) bool {
|
||||
current := meta.FindStatusCondition(job.Status.Conditions, executionv1alpha1.JobConditionSucceeded)
|
||||
return current != nil && (current.Status == metav1.ConditionTrue || current.Status == metav1.ConditionFalse)
|
||||
}
|
||||
|
||||
func applyResourceDefaults(requested, defaults executionv1alpha1.ExecutionResourceRequirements) executionv1alpha1.ExecutionResourceRequirements {
|
||||
result := requested.DeepCopy()
|
||||
if result.Requests.CPU == nil && defaults.Requests.CPU != nil {
|
||||
result.Requests.CPU = copyQuantity(defaults.Requests.CPU)
|
||||
}
|
||||
if result.Requests.Memory == nil && defaults.Requests.Memory != nil {
|
||||
result.Requests.Memory = copyQuantity(defaults.Requests.Memory)
|
||||
}
|
||||
if result.Limits.CPU == nil && defaults.Limits.CPU != nil {
|
||||
result.Limits.CPU = copyQuantity(defaults.Limits.CPU)
|
||||
}
|
||||
if result.Limits.Memory == nil && defaults.Limits.Memory != nil {
|
||||
result.Limits.Memory = copyQuantity(defaults.Limits.Memory)
|
||||
}
|
||||
return *result
|
||||
}
|
||||
|
||||
func copyQuantity(value *resource.Quantity) *resource.Quantity {
|
||||
copy := value.DeepCopy()
|
||||
return ©
|
||||
}
|
||||
|
||||
func validateResources(resources executionv1alpha1.ExecutionResourceRequirements) error {
|
||||
if resources.Requests.CPU != nil && resources.Limits.CPU != nil && resources.Requests.CPU.Cmp(*resources.Limits.CPU) > 0 {
|
||||
return fmt.Errorf("CPU request must not exceed limit")
|
||||
}
|
||||
if resources.Requests.Memory != nil && resources.Limits.Memory != nil && resources.Requests.Memory.Cmp(*resources.Limits.Memory) > 0 {
|
||||
return fmt.Errorf("memory request must not exceed limit")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func containsString(values []string, target string) bool {
|
||||
return slices.Contains(values, target)
|
||||
}
|
||||
|
||||
func removeString(values []string, target string) []string {
|
||||
result := values[:0]
|
||||
for _, value := range values {
|
||||
if value != target {
|
||||
result = append(result, value)
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
func (r *JobReconciler) now() time.Time {
|
||||
if r.Now != nil {
|
||||
return r.Now()
|
||||
}
|
||||
return time.Now()
|
||||
}
|
||||
|
||||
func (r *JobReconciler) SetupWithManager(manager ctrl.Manager) error {
|
||||
return ctrl.NewControllerManagedBy(manager).
|
||||
For(&executionv1alpha1.Job{}).
|
||||
Owns(&batchv1.Job{}).
|
||||
Named("execution-job").
|
||||
Complete(r)
|
||||
}
|
||||
@@ -1,202 +0,0 @@
|
||||
package controller
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
executionv1alpha1 "git.ddupan.top/panxiao81/ayatori/api/execution/v1alpha1"
|
||||
kubernetesadapter "git.ddupan.top/panxiao81/ayatori/internal/adapter/kubernetes"
|
||||
batchv1 "k8s.io/api/batch/v1"
|
||||
corev1 "k8s.io/api/core/v1"
|
||||
"k8s.io/apimachinery/pkg/api/meta"
|
||||
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
||||
"k8s.io/apimachinery/pkg/runtime"
|
||||
"k8s.io/apimachinery/pkg/types"
|
||||
ctrl "sigs.k8s.io/controller-runtime"
|
||||
"sigs.k8s.io/controller-runtime/pkg/client"
|
||||
"sigs.k8s.io/controller-runtime/pkg/envtest"
|
||||
metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server"
|
||||
)
|
||||
|
||||
const (
|
||||
integrationNamespace = "controller-integration"
|
||||
integrationClass = "integration"
|
||||
)
|
||||
|
||||
//nolint:modernize // Kubernetes API structs expose ObjectMeta through embedded TypeMeta fields.
|
||||
func TestJobControllerIntegration(t *testing.T) {
|
||||
if os.Getenv("KUBEBUILDER_ASSETS") == "" {
|
||||
t.Skip("KUBEBUILDER_ASSETS is unset; run make test to execute controller integration tests")
|
||||
}
|
||||
|
||||
scheme := runtime.NewScheme()
|
||||
for _, addToScheme := range []func(*runtime.Scheme) error{
|
||||
corev1.AddToScheme,
|
||||
batchv1.AddToScheme,
|
||||
executionv1alpha1.AddToScheme,
|
||||
} {
|
||||
if err := addToScheme(scheme); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
crdPath, err := filepath.Abs("../../config/crd/bases")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
environment := &envtest.Environment{CRDDirectoryPaths: []string{crdPath}}
|
||||
config, err := environment.Start()
|
||||
if err != nil {
|
||||
t.Fatalf("start envtest: %v", err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
if err := environment.Stop(); err != nil {
|
||||
t.Errorf("stop envtest: %v", err)
|
||||
}
|
||||
})
|
||||
|
||||
manager, err := ctrl.NewManager(config, ctrl.Options{
|
||||
Scheme: scheme,
|
||||
Metrics: metricsserver.Options{BindAddress: "0"},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := (&JobReconciler{Client: manager.GetClient()}).SetupWithManager(manager); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
managerContext, cancelManager := context.WithCancel(context.Background())
|
||||
t.Cleanup(cancelManager)
|
||||
managerErrors := make(chan error, 1)
|
||||
go func() {
|
||||
managerErrors <- manager.Start(managerContext)
|
||||
}()
|
||||
if !manager.GetCache().WaitForCacheSync(managerContext) {
|
||||
t.Fatal("manager cache did not synchronize")
|
||||
}
|
||||
|
||||
directClient, err := client.New(config, client.Options{Scheme: scheme})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
ctx := context.Background()
|
||||
objects := []client.Object{
|
||||
&corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: integrationNamespace, Labels: map[string]string{testLabelKey: testLabelEnabled}}},
|
||||
&corev1.ServiceAccount{ObjectMeta: metav1.ObjectMeta{Name: testSAName, Namespace: integrationNamespace}},
|
||||
&executionv1alpha1.KubernetesExecutionParameters{
|
||||
ObjectMeta: metav1.ObjectMeta{Name: integrationClass},
|
||||
Spec: executionv1alpha1.KubernetesExecutionParametersSpec{
|
||||
ServiceAccountName: testSAName,
|
||||
ImagePullPolicy: corev1.PullIfNotPresent,
|
||||
},
|
||||
},
|
||||
&executionv1alpha1.JobClass{
|
||||
ObjectMeta: metav1.ObjectMeta{Name: integrationClass},
|
||||
Spec: executionv1alpha1.JobClassSpec{
|
||||
ControllerName: kubernetesadapter.ControllerName,
|
||||
ParametersRef: executionv1alpha1.ParametersReference{
|
||||
Group: executionv1alpha1.GroupVersion.Group,
|
||||
Kind: "KubernetesExecutionParameters",
|
||||
Name: integrationClass,
|
||||
},
|
||||
AllowedNamespaces: &metav1.LabelSelector{MatchLabels: map[string]string{testLabelKey: testLabelEnabled}},
|
||||
},
|
||||
},
|
||||
}
|
||||
for _, object := range objects {
|
||||
if err := directClient.Create(ctx, object); err != nil {
|
||||
t.Fatalf("create %T: %v", object, err)
|
||||
}
|
||||
}
|
||||
|
||||
job := &executionv1alpha1.Job{
|
||||
ObjectMeta: metav1.ObjectMeta{Name: testJobName, Namespace: integrationNamespace},
|
||||
Spec: executionv1alpha1.JobSpec{
|
||||
JobClassName: integrationClass,
|
||||
DesiredState: executionv1alpha1.JobDesiredStateRunning,
|
||||
Task: executionv1alpha1.TaskSpec{Image: "alpine:3.22", Command: []string{"true"}},
|
||||
},
|
||||
}
|
||||
if err := directClient.Create(ctx, job); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
backend := &batchv1.Job{}
|
||||
eventually(t, 10*time.Second, func() (bool, error) {
|
||||
err := directClient.Get(ctx, types.NamespacedName{Namespace: job.Namespace, Name: job.Name}, backend)
|
||||
return err == nil, client.IgnoreNotFound(err)
|
||||
})
|
||||
if backend.Labels[kubernetesadapter.JobUIDLabel] != string(job.UID) {
|
||||
t.Fatalf("backend identity label = %q, want %q", backend.Labels[kubernetesadapter.JobUIDLabel], job.UID)
|
||||
}
|
||||
|
||||
eventually(t, 10*time.Second, func() (bool, error) {
|
||||
if err := directClient.Get(ctx, types.NamespacedName{Namespace: job.Namespace, Name: job.Name}, job); err != nil {
|
||||
return false, err
|
||||
}
|
||||
return conditionStatus(job, executionv1alpha1.JobConditionScheduled) == metav1.ConditionTrue, nil
|
||||
})
|
||||
|
||||
completed := metav1.Now()
|
||||
if err := directClient.Get(ctx, types.NamespacedName{Namespace: job.Namespace, Name: job.Name}, backend); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
backend.Status.StartTime = &completed
|
||||
backend.Status.CompletionTime = &completed
|
||||
backend.Status.Conditions = []batchv1.JobCondition{
|
||||
{Type: batchv1.JobSuccessCriteriaMet, Status: corev1.ConditionTrue, Reason: "CompletionsReached"},
|
||||
{Type: batchv1.JobComplete, Status: corev1.ConditionTrue, Reason: "Completed"},
|
||||
}
|
||||
if err := directClient.Status().Update(ctx, backend); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
eventually(t, 10*time.Second, func() (bool, error) {
|
||||
if err := directClient.Get(ctx, types.NamespacedName{Namespace: job.Namespace, Name: job.Name}, job); err != nil {
|
||||
return false, err
|
||||
}
|
||||
return conditionStatus(job, executionv1alpha1.JobConditionSucceeded) == metav1.ConditionTrue, nil
|
||||
})
|
||||
if job.Status.StartTime == nil || job.Status.CompletionTime == nil || job.Status.Execution == nil {
|
||||
t.Fatalf("controller did not persist execution status: %#v", job.Status)
|
||||
}
|
||||
|
||||
cancelManager()
|
||||
select {
|
||||
case err := <-managerErrors:
|
||||
if err != nil {
|
||||
t.Fatalf("manager stopped with error: %v", err)
|
||||
}
|
||||
case <-time.After(5 * time.Second):
|
||||
t.Fatal("manager did not stop")
|
||||
}
|
||||
}
|
||||
|
||||
func eventually(t *testing.T, timeout time.Duration, check func() (bool, error)) {
|
||||
t.Helper()
|
||||
deadline := time.Now().Add(timeout)
|
||||
for time.Now().Before(deadline) {
|
||||
ready, err := check()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if ready {
|
||||
return
|
||||
}
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
}
|
||||
t.Fatal(fmt.Errorf("condition was not met within %s", timeout))
|
||||
}
|
||||
|
||||
func conditionStatus(job *executionv1alpha1.Job, conditionType string) metav1.ConditionStatus {
|
||||
condition := meta.FindStatusCondition(job.Status.Conditions, conditionType)
|
||||
if condition == nil {
|
||||
return metav1.ConditionUnknown
|
||||
}
|
||||
return condition.Status
|
||||
}
|
||||
@@ -1,245 +0,0 @@
|
||||
package controller
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
executionv1alpha1 "git.ddupan.top/panxiao81/ayatori/api/execution/v1alpha1"
|
||||
kubernetesadapter "git.ddupan.top/panxiao81/ayatori/internal/adapter/kubernetes"
|
||||
batchv1 "k8s.io/api/batch/v1"
|
||||
corev1 "k8s.io/api/core/v1"
|
||||
"k8s.io/apimachinery/pkg/api/meta"
|
||||
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
||||
"k8s.io/apimachinery/pkg/runtime"
|
||||
"k8s.io/apimachinery/pkg/types"
|
||||
ctrl "sigs.k8s.io/controller-runtime"
|
||||
"sigs.k8s.io/controller-runtime/pkg/client"
|
||||
"sigs.k8s.io/controller-runtime/pkg/client/fake"
|
||||
)
|
||||
|
||||
const (
|
||||
defaultClassName = "default"
|
||||
testJobName = "hello"
|
||||
testSAName = "runner"
|
||||
testLabelKey = "execution"
|
||||
testLabelEnabled = "enabled"
|
||||
)
|
||||
|
||||
//nolint:modernize // controller-runtime and Kubernetes API structs expose promoted embedded fields.
|
||||
func TestJobReconcilerKubernetesLifecycle(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
now := time.Unix(1_700_000_000, 0)
|
||||
reconciler, kubeClient := testReconciler(t, now, validObjects()...)
|
||||
request := ctrl.Request{}
|
||||
request.NamespacedName = types.NamespacedName{Namespace: "ci", Name: testJobName}
|
||||
|
||||
if _, err := reconciler.Reconcile(ctx, request); err != nil {
|
||||
t.Fatalf("add finalizer: %v", err)
|
||||
}
|
||||
if _, err := reconciler.Reconcile(ctx, request); err != nil {
|
||||
t.Fatalf("create backend: %v", err)
|
||||
}
|
||||
|
||||
backend := &batchv1.Job{}
|
||||
if err := kubeClient.Get(ctx, request.NamespacedName, backend); err != nil {
|
||||
t.Fatalf("backend Job was not created: %v", err)
|
||||
}
|
||||
if backend.Labels[kubernetesadapter.JobUIDLabel] != "ayatori-job-uid" {
|
||||
t.Fatalf("backend UID label = %q", backend.Labels[kubernetesadapter.JobUIDLabel])
|
||||
}
|
||||
|
||||
job := getJob(t, ctx, kubeClient, request.NamespacedName)
|
||||
if !conditionIs(job, executionv1alpha1.JobConditionAccepted, metav1.ConditionTrue) ||
|
||||
!conditionIs(job, executionv1alpha1.JobConditionScheduled, metav1.ConditionTrue) {
|
||||
t.Fatalf("Job was not accepted and scheduled: %#v", job.Status.Conditions)
|
||||
}
|
||||
|
||||
started := metav1.NewTime(now.Add(time.Minute))
|
||||
backend.Status.StartTime = &started
|
||||
backend.Status.Active = 1
|
||||
if err := kubeClient.Status().Update(ctx, backend); err != nil {
|
||||
t.Fatalf("set backend running: %v", err)
|
||||
}
|
||||
if _, err := reconciler.Reconcile(ctx, request); err != nil {
|
||||
t.Fatalf("observe running backend: %v", err)
|
||||
}
|
||||
job = getJob(t, ctx, kubeClient, request.NamespacedName)
|
||||
if job.Status.StartTime == nil || !conditionIs(job, executionv1alpha1.JobConditionSucceeded, metav1.ConditionUnknown) {
|
||||
t.Fatalf("running state was not observed: %#v", job.Status)
|
||||
}
|
||||
|
||||
completed := metav1.NewTime(now.Add(2 * time.Minute))
|
||||
backend = &batchv1.Job{}
|
||||
if err := kubeClient.Get(ctx, request.NamespacedName, backend); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
backend.Status.Active = 0
|
||||
backend.Status.CompletionTime = &completed
|
||||
backend.Status.Conditions = []batchv1.JobCondition{{Type: batchv1.JobComplete, Status: corev1.ConditionTrue, Reason: "Completed"}}
|
||||
if err := kubeClient.Status().Update(ctx, backend); err != nil {
|
||||
t.Fatalf("set backend complete: %v", err)
|
||||
}
|
||||
if _, err := reconciler.Reconcile(ctx, request); err != nil {
|
||||
t.Fatalf("observe completed backend: %v", err)
|
||||
}
|
||||
job = getJob(t, ctx, kubeClient, request.NamespacedName)
|
||||
if !conditionIs(job, executionv1alpha1.JobConditionSucceeded, metav1.ConditionTrue) || job.Status.CompletionTime == nil {
|
||||
t.Fatalf("terminal state was not observed: %#v", job.Status)
|
||||
}
|
||||
}
|
||||
|
||||
//nolint:modernize // controller-runtime Request exposes NamespacedName as a promoted embedded field.
|
||||
func TestJobReconcilerRejectsMissingClass(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
job := validObjects()[3].(*executionv1alpha1.Job).DeepCopy()
|
||||
job.Spec.JobClassName = "missing"
|
||||
reconciler, kubeClient := testReconciler(t, time.Now(), validObjects()[0], validObjects()[1], job)
|
||||
request := ctrl.Request{}
|
||||
request.NamespacedName = types.NamespacedName{Namespace: job.Namespace, Name: job.Name}
|
||||
|
||||
if _, err := reconciler.Reconcile(ctx, request); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
result, err := reconciler.Reconcile(ctx, request)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if result.RequeueAfter == 0 {
|
||||
t.Fatal("missing JobClass did not schedule a retry")
|
||||
}
|
||||
stored := getJob(t, ctx, kubeClient, request.NamespacedName)
|
||||
accepted := meta.FindStatusCondition(stored.Status.Conditions, executionv1alpha1.JobConditionAccepted)
|
||||
if accepted == nil || accepted.Status != metav1.ConditionFalse || accepted.Reason != "JobClassNotFound" {
|
||||
t.Fatalf("unexpected Accepted condition: %#v", accepted)
|
||||
}
|
||||
}
|
||||
|
||||
//nolint:modernize // controller-runtime Request exposes NamespacedName as a promoted embedded field.
|
||||
func TestJobReconcilerObservesExistingExecutionWithoutJobClass(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
now := time.Unix(1_700_000_000, 0)
|
||||
job := validObjects()[3].(*executionv1alpha1.Job).DeepCopy()
|
||||
job.Finalizers = []string{jobFinalizer}
|
||||
job.Status.Execution = &executionv1alpha1.ExecutionStatus{Adapter: "kubernetes"}
|
||||
backend := kubernetesadapter.BuildJob(job, validObjects()[4].(*executionv1alpha1.KubernetesExecutionParameters), executionv1alpha1.ExecutionResourceRequirements{})
|
||||
backend.Status.StartTime = &metav1.Time{Time: now}
|
||||
backend.Status.Active = 1
|
||||
reconciler, kubeClient := testReconciler(t, now, job, backend)
|
||||
request := ctrl.Request{NamespacedName: types.NamespacedName{Namespace: job.Namespace, Name: job.Name}}
|
||||
|
||||
if _, err := reconciler.Reconcile(ctx, request); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
stored := getJob(t, ctx, kubeClient, request.NamespacedName)
|
||||
if stored.Status.StartTime == nil || !conditionIs(stored, executionv1alpha1.JobConditionSucceeded, metav1.ConditionUnknown) {
|
||||
t.Fatalf("existing execution was not observed without its JobClass: %#v", stored.Status)
|
||||
}
|
||||
}
|
||||
|
||||
//nolint:modernize // controller-runtime Request exposes NamespacedName as a promoted embedded field.
|
||||
func TestJobReconcilerCancelsBeforeScheduling(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
job := validObjects()[3].(*executionv1alpha1.Job).DeepCopy()
|
||||
job.Spec.DesiredState = executionv1alpha1.JobDesiredStateCancelled
|
||||
reconciler, kubeClient := testReconciler(t, time.Unix(1_700_000_000, 0), job)
|
||||
request := ctrl.Request{NamespacedName: types.NamespacedName{Namespace: job.Namespace, Name: job.Name}}
|
||||
|
||||
if _, err := reconciler.Reconcile(ctx, request); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
stored := getJob(t, ctx, kubeClient, request.NamespacedName)
|
||||
condition := meta.FindStatusCondition(stored.Status.Conditions, executionv1alpha1.JobConditionSucceeded)
|
||||
if condition == nil || condition.Status != metav1.ConditionFalse || condition.Reason != "Cancelled" {
|
||||
t.Fatalf("unexpected cancellation condition: %#v", condition)
|
||||
}
|
||||
if stored.Status.CompletionTime == nil {
|
||||
t.Fatal("cancelled Job has no completionTime")
|
||||
}
|
||||
}
|
||||
|
||||
//nolint:modernize // controller-runtime Request exposes NamespacedName as a promoted embedded field.
|
||||
func TestJobReconcilerKeepsConfirmedSuccessDuringCancellation(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
now := time.Unix(1_700_000_000, 0)
|
||||
job := validObjects()[3].(*executionv1alpha1.Job).DeepCopy()
|
||||
job.Spec.DesiredState = executionv1alpha1.JobDesiredStateCancelled
|
||||
job.Finalizers = []string{jobFinalizer}
|
||||
backend := kubernetesadapter.BuildJob(job, validObjects()[4].(*executionv1alpha1.KubernetesExecutionParameters), executionv1alpha1.ExecutionResourceRequirements{})
|
||||
backend.Status.CompletionTime = &metav1.Time{Time: now}
|
||||
backend.Status.Conditions = []batchv1.JobCondition{{Type: batchv1.JobComplete, Status: corev1.ConditionTrue}}
|
||||
reconciler, kubeClient := testReconciler(t, now, job, backend)
|
||||
request := ctrl.Request{NamespacedName: types.NamespacedName{Namespace: job.Namespace, Name: job.Name}}
|
||||
|
||||
if _, err := reconciler.Reconcile(ctx, request); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
stored := getJob(t, ctx, kubeClient, request.NamespacedName)
|
||||
if !conditionIs(stored, executionv1alpha1.JobConditionSucceeded, metav1.ConditionTrue) {
|
||||
t.Fatalf("confirmed success was overwritten by cancellation: %#v", stored.Status.Conditions)
|
||||
}
|
||||
if err := kubeClient.Get(ctx, request.NamespacedName, &batchv1.Job{}); err != nil {
|
||||
t.Fatalf("successful backend was deleted: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
//nolint:modernize // Kubernetes API structs expose ObjectMeta through embedded TypeMeta fields.
|
||||
func validObjects() []client.Object {
|
||||
return []client.Object{
|
||||
&corev1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: "ci", Labels: map[string]string{testLabelKey: testLabelEnabled}}},
|
||||
&corev1.ServiceAccount{ObjectMeta: metav1.ObjectMeta{Name: testSAName, Namespace: "ci"}},
|
||||
&executionv1alpha1.JobClass{
|
||||
ObjectMeta: metav1.ObjectMeta{Name: defaultClassName, UID: types.UID("class-uid")},
|
||||
Spec: executionv1alpha1.JobClassSpec{
|
||||
ControllerName: kubernetesadapter.ControllerName,
|
||||
ParametersRef: executionv1alpha1.ParametersReference{Group: executionv1alpha1.GroupVersion.Group, Kind: "KubernetesExecutionParameters", Name: defaultClassName},
|
||||
AllowedNamespaces: &metav1.LabelSelector{MatchLabels: map[string]string{testLabelKey: testLabelEnabled}},
|
||||
},
|
||||
},
|
||||
&executionv1alpha1.Job{
|
||||
ObjectMeta: metav1.ObjectMeta{Name: testJobName, Namespace: "ci", UID: types.UID("ayatori-job-uid")},
|
||||
Spec: executionv1alpha1.JobSpec{
|
||||
JobClassName: defaultClassName, DesiredState: executionv1alpha1.JobDesiredStateRunning,
|
||||
Task: executionv1alpha1.TaskSpec{Image: "alpine:3.22", Command: []string{"true"}},
|
||||
},
|
||||
},
|
||||
&executionv1alpha1.KubernetesExecutionParameters{
|
||||
ObjectMeta: metav1.ObjectMeta{Name: defaultClassName, UID: types.UID("parameters-uid")},
|
||||
Spec: executionv1alpha1.KubernetesExecutionParametersSpec{ServiceAccountName: testSAName, ImagePullPolicy: corev1.PullIfNotPresent},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func testReconciler(t *testing.T, now time.Time, objects ...client.Object) (*JobReconciler, client.Client) {
|
||||
t.Helper()
|
||||
scheme := runtime.NewScheme()
|
||||
if err := corev1.AddToScheme(scheme); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := batchv1.AddToScheme(scheme); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := executionv1alpha1.AddToScheme(scheme); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
kubeClient := fake.NewClientBuilder().
|
||||
WithScheme(scheme).
|
||||
WithStatusSubresource(&executionv1alpha1.Job{}, &batchv1.Job{}).
|
||||
WithObjects(objects...).
|
||||
Build()
|
||||
return &JobReconciler{Client: kubeClient, Now: func() time.Time { return now }}, kubeClient
|
||||
}
|
||||
|
||||
func getJob(t *testing.T, ctx context.Context, kubeClient client.Client, key types.NamespacedName) *executionv1alpha1.Job {
|
||||
t.Helper()
|
||||
job := &executionv1alpha1.Job{}
|
||||
if err := kubeClient.Get(ctx, key, job); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return job
|
||||
}
|
||||
|
||||
func conditionIs(job *executionv1alpha1.Job, conditionType string, status metav1.ConditionStatus) bool {
|
||||
condition := meta.FindStatusCondition(job.Status.Conditions, conditionType)
|
||||
return condition != nil && condition.Status == status
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
/*
|
||||
Copyright 2026.
|
||||
|
||||
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 instance
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"regexp"
|
||||
)
|
||||
|
||||
// CredentialReferenceValues contains effective field mappings, not secret data.
|
||||
// The application supplies defaults and fixes the namespace to the controller's.
|
||||
// Namespace and provider-specific paths are deliberately not selectable here.
|
||||
type CredentialReferenceValues struct {
|
||||
Name string
|
||||
UsernameKey string
|
||||
PasswordKey string
|
||||
}
|
||||
|
||||
// CredentialReference is an immutable reference to a management Secret.
|
||||
// Its zero value is invalid; aggregate construction must Validate incoming values.
|
||||
type CredentialReference struct {
|
||||
values CredentialReferenceValues
|
||||
}
|
||||
|
||||
// Instance and Secret names share the DNS subdomain syntax and 253-character limit.
|
||||
var dnsSubdomainName = regexp.MustCompile(`^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$`)
|
||||
|
||||
func NewCredentialReference(values CredentialReferenceValues) (CredentialReference, error) {
|
||||
reference := CredentialReference{values: values}
|
||||
if err := reference.Validate(); err != nil {
|
||||
return CredentialReference{}, err
|
||||
}
|
||||
return reference, nil
|
||||
}
|
||||
|
||||
// Values returns a copy of the reference, never secret contents.
|
||||
func (r CredentialReference) Values() CredentialReferenceValues { return r.values }
|
||||
|
||||
// Validate enforces reference invariants without accessing Kubernetes or OpenBao.
|
||||
// Checking that the referenced Secret contains nonempty credentials is an application
|
||||
// responsibility. Errors omit input values and no implicit defaults are applied.
|
||||
func (r CredentialReference) Validate() error {
|
||||
if len(r.values.Name) > 253 || !dnsSubdomainName.MatchString(r.values.Name) {
|
||||
return errors.New("management Secret name must be a valid DNS subdomain of at most 253 characters")
|
||||
}
|
||||
if r.values.UsernameKey == "" {
|
||||
return errors.New("management Secret username field is required")
|
||||
}
|
||||
if r.values.PasswordKey == "" {
|
||||
return errors.New("management Secret password field is required")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
/*
|
||||
Copyright 2026.
|
||||
|
||||
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 instance_test
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.ddupan.top/panxiao81/ayatori/internal/database/domain/instance"
|
||||
)
|
||||
|
||||
func validCredentialReference() instance.CredentialReferenceValues {
|
||||
return instance.CredentialReferenceValues{
|
||||
Name: "shared-postgresql-admin", UsernameKey: "username", PasswordKey: "password",
|
||||
}
|
||||
}
|
||||
|
||||
// Acceptance: docs/database/domain-instance.md §2. References carry names, never credentials or IO.
|
||||
func TestCredentialReferenceRejectsInvalidValues(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
change func(*instance.CredentialReferenceValues)
|
||||
}{
|
||||
{"empty name", func(v *instance.CredentialReferenceValues) { v.Name = "" }},
|
||||
{"uppercase", func(v *instance.CredentialReferenceValues) { v.Name = "Admin" }},
|
||||
{"underscore", func(v *instance.CredentialReferenceValues) { v.Name = "pg_admin" }},
|
||||
{"leading hyphen", func(v *instance.CredentialReferenceValues) { v.Name = "-admin" }},
|
||||
{"trailing hyphen", func(v *instance.CredentialReferenceValues) { v.Name = "admin-" }},
|
||||
{"empty label", func(v *instance.CredentialReferenceValues) { v.Name = "pg..admin" }},
|
||||
{"trailing dot", func(v *instance.CredentialReferenceValues) { v.Name = "pg." }},
|
||||
{"namespace or path", func(v *instance.CredentialReferenceValues) { v.Name = "system/admin" }},
|
||||
{"whitespace", func(v *instance.CredentialReferenceValues) { v.Name = " admin" }},
|
||||
{"too long", func(v *instance.CredentialReferenceValues) { v.Name = strings.Repeat("a", 254) }},
|
||||
{"empty username key", func(v *instance.CredentialReferenceValues) { v.UsernameKey = "" }},
|
||||
{"empty password key", func(v *instance.CredentialReferenceValues) { v.PasswordKey = "" }},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
values := validCredentialReference()
|
||||
tc.change(&values)
|
||||
reference, err := instance.NewCredentialReference(values)
|
||||
if err == nil {
|
||||
t.Fatal("invalid credential reference accepted")
|
||||
}
|
||||
if reference != (instance.CredentialReference{}) {
|
||||
t.Fatal("constructor returned a partial reference on failure")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCredentialReferencePreservesExplicitValues(t *testing.T) {
|
||||
for _, name := range []string{"a", "1", "pg.admin-1", strings.Repeat("a", 253)} {
|
||||
values := validCredentialReference()
|
||||
values.Name = name
|
||||
values.UsernameKey = "PG_USER"
|
||||
values.PasswordKey = "pg.password"
|
||||
reference, err := instance.NewCredentialReference(values)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if reference.Values() != values {
|
||||
t.Fatal("constructor changed the explicit field mapping")
|
||||
}
|
||||
if err := reference.Validate(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestCredentialReferenceIsAnImmutableComparableValue(t *testing.T) {
|
||||
values := validCredentialReference()
|
||||
reference, err := instance.NewCredentialReference(values)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
same, err := instance.NewCredentialReference(values)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if reference != same {
|
||||
t.Fatal("identical references must compare equal")
|
||||
}
|
||||
values.Name = "different"
|
||||
snapshot := reference.Values()
|
||||
snapshot.PasswordKey = "different-key"
|
||||
if reference.Values() != validCredentialReference() {
|
||||
t.Fatal("caller mutated reference through a copy")
|
||||
}
|
||||
if err := (instance.CredentialReference{}).Validate(); err == nil {
|
||||
t.Fatal("zero reference must be invalid")
|
||||
}
|
||||
}
|
||||
|
||||
func TestCredentialReferenceErrorOmitsInput(t *testing.T) {
|
||||
values := validCredentialReference()
|
||||
values.Name = "canary-sensitive/input"
|
||||
_, err := instance.NewCredentialReference(values)
|
||||
if err == nil {
|
||||
t.Fatal("invalid reference accepted")
|
||||
}
|
||||
if strings.Contains(err.Error(), "canary") {
|
||||
t.Fatal("error included input")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
/*
|
||||
Copyright 2026.
|
||||
|
||||
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 instance contains the pure domain model of a registered PostgreSQL instance.
|
||||
// It does not depend on Kubernetes types, database drivers or credential providers.
|
||||
package instance
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/netip"
|
||||
"regexp"
|
||||
)
|
||||
|
||||
// TLSMode is an explicit transport policy, not a driver-specific default.
|
||||
type TLSMode string
|
||||
|
||||
const (
|
||||
TLSDisable TLSMode = "disable"
|
||||
TLSRequire TLSMode = "require"
|
||||
TLSVerifyCA TLSMode = "verify-ca"
|
||||
TLSVerifyFull TLSMode = "verify-full"
|
||||
)
|
||||
|
||||
// EndpointValues carries explicit, effective values across the application boundary.
|
||||
// Defaults are supplied by the API/application mapping, never silently by the domain.
|
||||
type EndpointValues struct {
|
||||
Host string
|
||||
HostAddr string
|
||||
Port int
|
||||
ManagementDatabase string
|
||||
TLSMode TLSMode
|
||||
}
|
||||
|
||||
// Endpoint is an immutable connection target. Equality compares its declared values,
|
||||
// not physical server identity. Its zero value is invalid; aggregate construction
|
||||
// must Validate incoming endpoints, even if callers bypass NewEndpoint.
|
||||
type Endpoint struct {
|
||||
values EndpointValues
|
||||
}
|
||||
|
||||
var identifier = regexp.MustCompile(`^[a-z][a-z0-9_]{0,62}$`)
|
||||
|
||||
func NewEndpoint(values EndpointValues) (Endpoint, error) {
|
||||
endpoint := Endpoint{values: values}
|
||||
if err := endpoint.Validate(); err != nil {
|
||||
return Endpoint{}, err
|
||||
}
|
||||
return endpoint, nil
|
||||
}
|
||||
|
||||
// Values returns a copy, without exposing mutable state.
|
||||
func (e Endpoint) Values() EndpointValues { return e.values }
|
||||
|
||||
// Validate checks local invariants only; it does not resolve DNS or perform IO.
|
||||
// Errors intentionally omit input values.
|
||||
func (e Endpoint) Validate() error {
|
||||
if e.values.Host == "" {
|
||||
return errors.New("endpoint host is required")
|
||||
}
|
||||
address, err := netip.ParseAddr(e.values.HostAddr)
|
||||
if err != nil || address.Zone() != "" {
|
||||
return errors.New("endpoint host address must be an IPv4 or IPv6 address")
|
||||
}
|
||||
if e.values.Port < 1 || e.values.Port > 65535 {
|
||||
return errors.New("endpoint port must be between 1 and 65535")
|
||||
}
|
||||
if !identifier.MatchString(e.values.ManagementDatabase) {
|
||||
return errors.New("endpoint management database must be a valid PostgreSQL identifier")
|
||||
}
|
||||
switch e.values.TLSMode {
|
||||
case TLSDisable, TLSRequire, TLSVerifyCA, TLSVerifyFull:
|
||||
return nil
|
||||
default:
|
||||
return errors.New("endpoint TLS mode must be explicitly supported")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
/*
|
||||
Copyright 2026.
|
||||
|
||||
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 instance_test
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.ddupan.top/panxiao81/ayatori/internal/database/domain/instance"
|
||||
)
|
||||
|
||||
func validEndpoint() instance.EndpointValues {
|
||||
return instance.EndpointValues{
|
||||
Host: "postgres.home.arpa", HostAddr: "192.0.2.10", Port: 5432,
|
||||
ManagementDatabase: "postgres", TLSMode: instance.TLSVerifyFull,
|
||||
}
|
||||
}
|
||||
|
||||
// Acceptance: docs/database/domain-instance.md §2, explicit values and no implicit TLS downgrade.
|
||||
func TestEndpointRejectsInvalidValues(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
change func(*instance.EndpointValues)
|
||||
}{
|
||||
{"empty host", func(v *instance.EndpointValues) { v.Host = "" }},
|
||||
{"missing address", func(v *instance.EndpointValues) { v.HostAddr = "" }},
|
||||
{"DNS instead of IP", func(v *instance.EndpointValues) { v.HostAddr = "postgres.home.arpa" }},
|
||||
{"invalid IP", func(v *instance.EndpointValues) { v.HostAddr = "192.0.2.999" }},
|
||||
{"address with port", func(v *instance.EndpointValues) { v.HostAddr = "192.0.2.10:5432" }},
|
||||
{"scoped address", func(v *instance.EndpointValues) { v.HostAddr = "fe80::1%eth0" }},
|
||||
{"zero port", func(v *instance.EndpointValues) { v.Port = 0 }},
|
||||
{"negative port", func(v *instance.EndpointValues) { v.Port = -1 }},
|
||||
{"large port", func(v *instance.EndpointValues) { v.Port = 65536 }},
|
||||
{"empty database", func(v *instance.EndpointValues) { v.ManagementDatabase = "" }},
|
||||
{"uppercase database", func(v *instance.EndpointValues) { v.ManagementDatabase = "Postgres" }},
|
||||
{"leading digit", func(v *instance.EndpointValues) { v.ManagementDatabase = "1postgres" }},
|
||||
{"punctuation", func(v *instance.EndpointValues) { v.ManagementDatabase = "post-gres" }},
|
||||
{"NUL", func(v *instance.EndpointValues) { v.ManagementDatabase = "post\x00gres" }},
|
||||
{"long identifier", func(v *instance.EndpointValues) { v.ManagementDatabase = strings.Repeat("a", 64) }},
|
||||
{"missing TLS mode", func(v *instance.EndpointValues) { v.TLSMode = "" }},
|
||||
{"unsupported TLS mode", func(v *instance.EndpointValues) { v.TLSMode = "prefer" }},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
values := validEndpoint()
|
||||
tc.change(&values)
|
||||
endpoint, err := instance.NewEndpoint(values)
|
||||
if err == nil {
|
||||
t.Fatal("invalid endpoint accepted")
|
||||
}
|
||||
if endpoint != (instance.Endpoint{}) {
|
||||
t.Fatal("constructor returned a partial endpoint on failure")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEndpointPreservesValidValues(t *testing.T) {
|
||||
for _, mode := range []instance.TLSMode{
|
||||
instance.TLSDisable, instance.TLSRequire, instance.TLSVerifyCA, instance.TLSVerifyFull,
|
||||
} {
|
||||
for _, address := range []string{"192.0.2.10", "2001:db8::10"} {
|
||||
for _, port := range []int{1, 65535} {
|
||||
values := validEndpoint()
|
||||
values.TLSMode, values.HostAddr, values.Port = mode, address, port
|
||||
values.ManagementDatabase = "a" + strings.Repeat("_", 62)
|
||||
endpoint, err := instance.NewEndpoint(values)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if endpoint.Values() != values {
|
||||
t.Fatal("constructor changed explicit values")
|
||||
}
|
||||
if err := endpoint.Validate(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestEndpointIsAnImmutableComparableValue(t *testing.T) {
|
||||
values := validEndpoint()
|
||||
endpoint, err := instance.NewEndpoint(values)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
same, err := instance.NewEndpoint(values)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if endpoint != same {
|
||||
t.Fatal("identical endpoint values must compare equal")
|
||||
}
|
||||
values.Host = "changed.example"
|
||||
snapshot := endpoint.Values()
|
||||
snapshot.Host = values.Host
|
||||
if endpoint.Values().Host == snapshot.Host {
|
||||
t.Fatal("caller mutated endpoint through a copy")
|
||||
}
|
||||
if err := (instance.Endpoint{}).Validate(); err == nil {
|
||||
t.Fatal("zero endpoint must not be valid")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
/*
|
||||
Copyright 2026.
|
||||
|
||||
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 instance
|
||||
|
||||
import "slices"
|
||||
|
||||
// ExtensionSet is an immutable set of exact names. Zero represents the empty set.
|
||||
// It does not impose identifier syntax or claim that a server supports any name.
|
||||
type ExtensionSet struct {
|
||||
names []string
|
||||
}
|
||||
|
||||
func NewExtensionSet(names []string) ExtensionSet {
|
||||
copied := slices.Clone(names)
|
||||
slices.Sort(copied)
|
||||
return ExtensionSet{names: slices.Compact(copied)}
|
||||
}
|
||||
|
||||
// Names returns a sorted, deduplicated copy.
|
||||
func (s ExtensionSet) Names() []string { return slices.Clone(s.names) }
|
||||
|
||||
type ExtensionDecision string
|
||||
|
||||
const (
|
||||
ExtensionsAccepted ExtensionDecision = "Accepted"
|
||||
ExtensionsUnsupported ExtensionDecision = "ExtensionsUnsupported"
|
||||
ExtensionSupportUnobserved ExtensionDecision = "ExtensionSupportUnobserved"
|
||||
)
|
||||
|
||||
// ExtensionCheck reports support only, not readiness or permission to install.
|
||||
// Unsupported is a detached, sorted list and is populated only for known support.
|
||||
type ExtensionCheck struct {
|
||||
Decision ExtensionDecision
|
||||
Unsupported []string
|
||||
}
|
||||
|
||||
// ExtensionSupport is the extension-list component of an Instance observation.
|
||||
// Zero means unobserved, not an observed empty list. Target/revision binding and
|
||||
// invalidation belong to the containing Instance observation, not this set value.
|
||||
type ExtensionSupport struct {
|
||||
observed bool
|
||||
available ExtensionSet
|
||||
}
|
||||
|
||||
// ObserveExtensionSupport records a successfully read list, including an empty one.
|
||||
// A failed query must not call this constructor with an empty list: the application
|
||||
// must propagate the dependency failure and leave support unobserved.
|
||||
func ObserveExtensionSupport(available []string) ExtensionSupport {
|
||||
return ExtensionSupport{observed: true, available: NewExtensionSet(available)}
|
||||
}
|
||||
|
||||
// Check performs no IO and cannot install or remove extensions.
|
||||
func (s ExtensionSupport) Check(requested ExtensionSet) ExtensionCheck {
|
||||
if len(requested.names) == 0 {
|
||||
return ExtensionCheck{Decision: ExtensionsAccepted}
|
||||
}
|
||||
if !s.observed {
|
||||
return ExtensionCheck{Decision: ExtensionSupportUnobserved}
|
||||
}
|
||||
var unsupported []string
|
||||
for _, name := range requested.names {
|
||||
if _, found := slices.BinarySearch(s.available.names, name); !found {
|
||||
unsupported = append(unsupported, name)
|
||||
}
|
||||
}
|
||||
if len(unsupported) != 0 {
|
||||
return ExtensionCheck{Decision: ExtensionsUnsupported, Unsupported: unsupported}
|
||||
}
|
||||
return ExtensionCheck{Decision: ExtensionsAccepted}
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
/*
|
||||
Copyright 2026.
|
||||
|
||||
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 instance_test
|
||||
|
||||
import (
|
||||
"slices"
|
||||
"testing"
|
||||
|
||||
"git.ddupan.top/panxiao81/ayatori/internal/database/domain/instance"
|
||||
)
|
||||
|
||||
const (
|
||||
testUUID = "uuid-ossp"
|
||||
testTrigram = "pg_trgm"
|
||||
testVector = "vector"
|
||||
testChanged = "changed"
|
||||
)
|
||||
|
||||
// Acceptance: docs/database/domain-instance.md, extension support is based on observations,
|
||||
// not a name regexp or an administrator allowlist.
|
||||
func TestExtensionSupportDecisions(t *testing.T) {
|
||||
available := instance.ObserveExtensionSupport([]string{testTrigram, testUUID})
|
||||
cases := []struct {
|
||||
name string
|
||||
support instance.ExtensionSupport
|
||||
requested []string
|
||||
want instance.ExtensionDecision
|
||||
unsupported []string
|
||||
}{
|
||||
{"unobserved", instance.ExtensionSupport{}, []string{testTrigram}, instance.ExtensionSupportUnobserved, nil},
|
||||
{"observed empty", instance.ObserveExtensionSupport(nil), []string{testTrigram}, instance.ExtensionsUnsupported, []string{testTrigram}},
|
||||
{"empty request", instance.ExtensionSupport{}, nil, instance.ExtensionsAccepted, nil},
|
||||
{"supported", available, []string{testUUID, testTrigram, testTrigram}, instance.ExtensionsAccepted, nil},
|
||||
{"unsupported", available, []string{testVector, "hstore", testVector, testTrigram},
|
||||
instance.ExtensionsUnsupported, []string{"hstore", testVector}},
|
||||
{"exact names", available, []string{"PG_TRGM"}, instance.ExtensionsUnsupported, []string{"PG_TRGM"}},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
result := tc.support.Check(instance.NewExtensionSet(tc.requested))
|
||||
if result.Decision != tc.want || !slices.Equal(result.Unsupported, tc.unsupported) {
|
||||
t.Fatalf("Check() = %v, want %v / %v", result, tc.want, tc.unsupported)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestExtensionSetCopiesAndCanonicalizesNames(t *testing.T) {
|
||||
input := []string{testUUID, testTrigram, testUUID}
|
||||
set := instance.NewExtensionSet(input)
|
||||
input[0] = testChanged
|
||||
names := set.Names()
|
||||
want := []string{testTrigram, testUUID}
|
||||
if !slices.Equal(names, want) {
|
||||
t.Fatalf("Names() = %v, want %v", names, want)
|
||||
}
|
||||
names[0] = testChanged
|
||||
if !slices.Equal(set.Names(), want) {
|
||||
t.Fatal("returned slice mutated set")
|
||||
}
|
||||
if len((instance.ExtensionSet{}).Names()) != 0 {
|
||||
t.Fatal("zero set must be empty")
|
||||
}
|
||||
// Names are preserved exactly; actual server support, not a local regexp, is decisive.
|
||||
unusual := []string{"Vendor.Extension", testUUID}
|
||||
if result := instance.ObserveExtensionSupport(unusual).Check(instance.NewExtensionSet(unusual)); result.Decision != instance.ExtensionsAccepted {
|
||||
t.Fatal("imposed a local name restriction")
|
||||
}
|
||||
}
|
||||
|
||||
func TestExtensionSupportCopiesObservationAndResults(t *testing.T) {
|
||||
input := []string{testTrigram}
|
||||
support := instance.ObserveExtensionSupport(input)
|
||||
input[0] = testVector
|
||||
requested := instance.NewExtensionSet([]string{testTrigram, testVector})
|
||||
result := support.Check(requested)
|
||||
if !slices.Equal(result.Unsupported, []string{testVector}) {
|
||||
t.Fatal("input mutation changed observation")
|
||||
}
|
||||
result.Unsupported[0] = testChanged
|
||||
again := support.Check(requested)
|
||||
if !slices.Equal(again.Unsupported, []string{testVector}) {
|
||||
t.Fatal("result mutation changed subsequent decision")
|
||||
}
|
||||
// Replacing an observation does not mutate the old value or produce uninstall actions.
|
||||
empty := instance.ObserveExtensionSupport(nil)
|
||||
if empty.Check(requested).Decision != instance.ExtensionsUnsupported {
|
||||
t.Fatal("empty observation ignored")
|
||||
}
|
||||
if support.Check(instance.NewExtensionSet([]string{testTrigram})).Decision != instance.ExtensionsAccepted {
|
||||
t.Fatal("new observation mutated old value")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
/*
|
||||
Copyright 2026.
|
||||
|
||||
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 instance
|
||||
|
||||
import "errors"
|
||||
|
||||
// Identity identifies one registration, not a physical PostgreSQL server.
|
||||
// UID is opaque; a recreated resource with the same name has a different identity.
|
||||
// Its zero value is invalid and must be rejected when constructing an aggregate.
|
||||
type Identity struct {
|
||||
uid string
|
||||
name string
|
||||
}
|
||||
|
||||
func NewIdentity(uid, name string) (Identity, error) {
|
||||
identity := Identity{uid: uid, name: name}
|
||||
if err := identity.Validate(); err != nil {
|
||||
return Identity{}, err
|
||||
}
|
||||
return identity, nil
|
||||
}
|
||||
|
||||
func (i Identity) UID() string { return i.uid }
|
||||
func (i Identity) Name() string { return i.name }
|
||||
|
||||
// Validate checks registration values without looking up any external identity.
|
||||
func (i Identity) Validate() error {
|
||||
if i.uid == "" {
|
||||
return errors.New("instance UID is required")
|
||||
}
|
||||
if len(i.name) > 253 || !dnsSubdomainName.MatchString(i.name) {
|
||||
return errors.New("instance name must be a valid DNS subdomain of at most 253 characters")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Revision is a positive configuration generation, separate from Identity.
|
||||
// Zero is invalid for desired configuration; an unobserved status generation of
|
||||
// zero must be represented separately when the aggregate is implemented.
|
||||
type Revision struct {
|
||||
value int64
|
||||
}
|
||||
|
||||
func NewRevision(value int64) (Revision, error) {
|
||||
revision := Revision{value: value}
|
||||
if err := revision.Validate(); err != nil {
|
||||
return Revision{}, err
|
||||
}
|
||||
return revision, nil
|
||||
}
|
||||
|
||||
func (r Revision) Value() int64 { return r.value }
|
||||
|
||||
func (r Revision) Validate() error {
|
||||
if r.value <= 0 {
|
||||
return errors.New("instance revision must be positive")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,102 @@
|
||||
/*
|
||||
Copyright 2026.
|
||||
|
||||
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 instance_test
|
||||
|
||||
import (
|
||||
"math"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"git.ddupan.top/panxiao81/ayatori/internal/database/domain/instance"
|
||||
)
|
||||
|
||||
// Acceptance: docs/database/domain-instance.md §2: registration identity is UID + name,
|
||||
// independent of the configuration revision or physical PostgreSQL server.
|
||||
func TestIdentityDistinguishesRecreatedInstances(t *testing.T) {
|
||||
first, err := instance.NewIdentity("opaque-uid-1", "shared")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
same, err := instance.NewIdentity("opaque-uid-1", "shared")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
recreated, err := instance.NewIdentity("opaque-uid-2", "shared")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if first != same || first == recreated {
|
||||
t.Fatal("identity must distinguish same-name registrations by UID")
|
||||
}
|
||||
if first.UID() != "opaque-uid-1" || first.Name() != "shared" {
|
||||
t.Fatal("identity changed declared values")
|
||||
}
|
||||
if err := first.Validate(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIdentityValidation(t *testing.T) {
|
||||
for _, name := range []string{"", "Shared", "shared_name", "ns/shared", "-shared", "pg..shared", strings.Repeat("a", 254)} {
|
||||
identity, err := instance.NewIdentity("uid", name)
|
||||
if err == nil || identity != (instance.Identity{}) {
|
||||
t.Fatal("invalid name accepted or partial identity returned")
|
||||
}
|
||||
}
|
||||
if _, err := instance.NewIdentity("", "shared"); err == nil {
|
||||
t.Fatal("empty UID accepted")
|
||||
}
|
||||
if err := (instance.Identity{}).Validate(); err == nil {
|
||||
t.Fatal("zero identity accepted")
|
||||
}
|
||||
for _, name := range []string{"a", "1", "pg.shared-1", strings.Repeat("a", 253)} {
|
||||
if _, err := instance.NewIdentity("opaque-not-a-uuid", name); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestRevisionRequiresPositiveValue(t *testing.T) {
|
||||
for _, value := range []int64{math.MinInt64, -1, 0} {
|
||||
revision, err := instance.NewRevision(value)
|
||||
if err == nil || revision != (instance.Revision{}) {
|
||||
t.Fatal("invalid revision accepted or partial value returned")
|
||||
}
|
||||
}
|
||||
for _, value := range []int64{1, 2, math.MaxInt64} {
|
||||
revision, err := instance.NewRevision(value)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if revision.Value() != value {
|
||||
t.Fatal("revision changed declared value")
|
||||
}
|
||||
if err := revision.Validate(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
same, err := instance.NewRevision(value)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if revision != same {
|
||||
t.Fatal("identical revisions must compare equal")
|
||||
}
|
||||
}
|
||||
if err := (instance.Revision{}).Validate(); err == nil {
|
||||
t.Fatal("zero revision accepted")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,125 @@
|
||||
/*
|
||||
Copyright 2026.
|
||||
|
||||
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 instance
|
||||
|
||||
import "errors"
|
||||
|
||||
// Phase is a workflow checkpoint, never evidence of external resource state.
|
||||
type Phase string
|
||||
|
||||
const (
|
||||
PhasePending Phase = "Pending"
|
||||
PhaseValidating Phase = "Validating"
|
||||
PhaseInitializingRegistry Phase = "InitializingRegistry"
|
||||
PhaseReady Phase = "Ready"
|
||||
PhaseDeleting Phase = "Deleting"
|
||||
)
|
||||
|
||||
type Readiness string
|
||||
|
||||
const (
|
||||
Unknown Readiness = "Unknown"
|
||||
Ready Readiness = "Ready"
|
||||
NotReady Readiness = "NotReady"
|
||||
)
|
||||
|
||||
// Snapshot contains persisted observations only, without credentials or live evidence.
|
||||
// Failure detail mapping will be added with capability assessment, not intent transitions.
|
||||
type Snapshot struct {
|
||||
Phase Phase
|
||||
ObservedRevision int64
|
||||
Readiness Readiness
|
||||
ReportedVersion string
|
||||
}
|
||||
|
||||
// Instance protects registration state and pure lifecycle transitions.
|
||||
// Reconstitution does not establish live capability evidence, even for a Ready snapshot.
|
||||
// This initial slice deliberately exposes no operation that authorizes provisioning.
|
||||
type Instance struct {
|
||||
target ObservationTarget
|
||||
snapshot Snapshot
|
||||
deleting bool
|
||||
extensions ExtensionSupport
|
||||
}
|
||||
|
||||
func Reconstitute(target ObservationTarget, snapshot Snapshot, deleting bool) (*Instance, error) {
|
||||
if err := target.Validate(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
switch snapshot.Phase {
|
||||
case PhasePending, PhaseValidating, PhaseInitializingRegistry, PhaseReady, PhaseDeleting:
|
||||
default:
|
||||
snapshot.Phase = PhasePending
|
||||
snapshot.Readiness = Unknown
|
||||
}
|
||||
return &Instance{target: target, snapshot: snapshot, deleting: deleting}, nil
|
||||
}
|
||||
|
||||
func (i *Instance) Target() ObservationTarget { return i.target }
|
||||
|
||||
// Snapshot returns a detached value. Persisting it remains the application's job.
|
||||
func (i *Instance) Snapshot() Snapshot { return i.snapshot }
|
||||
|
||||
// BeginValidation records intent only; it does not claim a concluded observation.
|
||||
func (i *Instance) BeginValidation() error {
|
||||
if err := i.target.Validate(); err != nil {
|
||||
return err
|
||||
}
|
||||
if i.deleting {
|
||||
return errors.New("cannot begin validation after deletion was requested")
|
||||
}
|
||||
i.snapshot.Phase = PhaseValidating
|
||||
i.snapshot.Readiness = Unknown
|
||||
i.extensions = ExtensionSupport{}
|
||||
return nil
|
||||
}
|
||||
|
||||
// BeginDeletion stops the lifecycle from accepting validation. It does not delete
|
||||
// resources, inspect Tenant references, close connections or modify finalizers.
|
||||
func (i *Instance) BeginDeletion() error {
|
||||
if err := i.target.Validate(); err != nil {
|
||||
return err
|
||||
}
|
||||
if !i.deleting {
|
||||
return errors.New("cannot begin deletion without a deletion request")
|
||||
}
|
||||
i.snapshot.Phase = PhaseDeleting
|
||||
i.snapshot.Readiness = Unknown
|
||||
i.extensions = ExtensionSupport{}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ObserveExtensions accepts facts only for this registration and configuration.
|
||||
// Unobserved support clears a previous list after a failed read; the application
|
||||
// reports the dependency failure separately. This does not establish readiness.
|
||||
// Same-target freshness and Secret refresh are enforced by the application.
|
||||
func (i *Instance) ObserveExtensions(target ObservationTarget, support ExtensionSupport) error {
|
||||
if !i.target.Matches(target) {
|
||||
return errors.New("extension observation target does not match instance")
|
||||
}
|
||||
if i.deleting {
|
||||
return errors.New("cannot accept extension observations after deletion was requested")
|
||||
}
|
||||
i.extensions = support
|
||||
return nil
|
||||
}
|
||||
|
||||
// CheckExtensions checks support only; Accepted is not authorization to provision.
|
||||
// The aggregate does not perform IO, mutate its snapshot or uninstall extensions.
|
||||
func (i *Instance) CheckExtensions(requested ExtensionSet) ExtensionCheck {
|
||||
return i.extensions.Check(requested)
|
||||
}
|
||||
@@ -0,0 +1,105 @@
|
||||
/*
|
||||
Copyright 2026.
|
||||
|
||||
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 instance_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"git.ddupan.top/panxiao81/ayatori/internal/database/domain/instance"
|
||||
)
|
||||
|
||||
// Acceptance: docs/database/domain-instance.md §2/§3, extension observations are
|
||||
// bound to the current registration and definition and never authorize provisioning.
|
||||
func TestInstanceAcceptsExtensionObservationForCurrentTarget(t *testing.T) {
|
||||
value := lifecycleInstance(t, instance.Snapshot{Phase: instance.PhaseValidating}, false)
|
||||
target := value.Target()
|
||||
snapshot := value.Snapshot()
|
||||
|
||||
if err := value.ObserveExtensions(target, instance.ObserveExtensionSupport([]string{"pg_trgm"})); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := value.CheckExtensions(instance.NewExtensionSet([]string{"pg_trgm"})); got.Decision != instance.ExtensionsAccepted {
|
||||
t.Fatalf("CheckExtensions() = %v, want accepted", got)
|
||||
}
|
||||
if value.Snapshot() != snapshot {
|
||||
t.Fatal("extension observation changed the persisted lifecycle snapshot")
|
||||
}
|
||||
}
|
||||
|
||||
func TestInstanceRejectsExtensionObservationForDifferentTarget(t *testing.T) {
|
||||
value := lifecycleInstance(t, instance.Snapshot{Phase: instance.PhaseValidating}, false)
|
||||
identity, _, definition := targetParts(t)
|
||||
revision, err := instance.NewRevision(value.Target().Revision().Value() + 1)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
different, err := instance.NewObservationTarget(identity, revision, definition)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
if err := value.ObserveExtensions(different, instance.ObserveExtensionSupport([]string{"pg_trgm"})); err == nil {
|
||||
t.Fatal("observation for a different target was accepted")
|
||||
}
|
||||
if got := value.CheckExtensions(instance.NewExtensionSet([]string{"pg_trgm"})); got.Decision != instance.ExtensionSupportUnobserved {
|
||||
t.Fatalf("rejected observation changed support: %v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInstanceClearsExtensionObservationAcrossLifecycleBoundaries(t *testing.T) {
|
||||
requested := instance.NewExtensionSet([]string{"pg_trgm"})
|
||||
|
||||
t.Run("validation", func(t *testing.T) {
|
||||
value := lifecycleInstance(t, instance.Snapshot{Phase: instance.PhaseReady}, false)
|
||||
if err := value.ObserveExtensions(value.Target(), instance.ObserveExtensionSupport([]string{"pg_trgm"})); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := value.BeginValidation(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := value.CheckExtensions(requested); got.Decision != instance.ExtensionSupportUnobserved {
|
||||
t.Fatalf("validation retained stale support: %v", got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("deletion", func(t *testing.T) {
|
||||
value := lifecycleInstance(t, instance.Snapshot{Phase: instance.PhaseReady}, true)
|
||||
if err := value.ObserveExtensions(value.Target(), instance.ObserveExtensionSupport([]string{"pg_trgm"})); err == nil {
|
||||
t.Fatal("deleting instance accepted a new observation")
|
||||
}
|
||||
if err := value.BeginDeletion(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := value.CheckExtensions(requested); got.Decision != instance.ExtensionSupportUnobserved {
|
||||
t.Fatalf("deletion retained extension support: %v", got)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func TestInstanceCanExplicitlyInvalidateExtensionObservation(t *testing.T) {
|
||||
value := lifecycleInstance(t, instance.Snapshot{Phase: instance.PhaseValidating}, false)
|
||||
requested := instance.NewExtensionSet([]string{"pg_trgm"})
|
||||
if err := value.ObserveExtensions(value.Target(), instance.ObserveExtensionSupport([]string{"pg_trgm"})); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := value.ObserveExtensions(value.Target(), instance.ExtensionSupport{}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := value.CheckExtensions(requested); got.Decision != instance.ExtensionSupportUnobserved {
|
||||
t.Fatalf("explicit invalidation retained stale support: %v", got)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,134 @@
|
||||
/*
|
||||
Copyright 2026.
|
||||
|
||||
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 instance_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"git.ddupan.top/panxiao81/ayatori/internal/database/domain/instance"
|
||||
)
|
||||
|
||||
func lifecycleInstance(t *testing.T, snapshot instance.Snapshot, deleting bool) *instance.Instance {
|
||||
t.Helper()
|
||||
identity, revision, definition := targetParts(t)
|
||||
target, err := instance.NewObservationTarget(identity, revision, definition)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
value, err := instance.Reconstitute(target, snapshot, deleting)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return value
|
||||
}
|
||||
|
||||
// Acceptance: docs/database/domain-instance.md §3, checkpoint reconstruction and intent-only transitions.
|
||||
func TestReconstituteCheckpoints(t *testing.T) {
|
||||
for _, phase := range []instance.Phase{
|
||||
instance.PhasePending, instance.PhaseValidating, instance.PhaseInitializingRegistry,
|
||||
instance.PhaseReady, instance.PhaseDeleting,
|
||||
} {
|
||||
snapshot := instance.Snapshot{Phase: phase, ObservedRevision: 1, Readiness: instance.Ready, ReportedVersion: "17"}
|
||||
value := lifecycleInstance(t, snapshot, false)
|
||||
if value.Snapshot() != snapshot {
|
||||
t.Fatal("known checkpoint was not preserved")
|
||||
}
|
||||
// A snapshot is detached; it is not a setter on the aggregate.
|
||||
copy := value.Snapshot()
|
||||
copy.Phase = instance.PhasePending
|
||||
copy.ReportedVersion = "changed"
|
||||
if value.Snapshot() != snapshot {
|
||||
t.Fatal("snapshot mutation changed aggregate")
|
||||
}
|
||||
}
|
||||
for _, phase := range []instance.Phase{"", "unknown"} {
|
||||
value := lifecycleInstance(t, instance.Snapshot{Phase: phase, Readiness: instance.Ready}, false)
|
||||
if value.Snapshot().Phase != instance.PhasePending || value.Snapshot().Readiness != instance.Unknown {
|
||||
t.Fatal("missing or unknown checkpoint did not restart conservatively")
|
||||
}
|
||||
}
|
||||
if value, err := instance.Reconstitute(instance.ObservationTarget{}, instance.Snapshot{}, false); err == nil || value != nil {
|
||||
t.Fatal("invalid target reconstructed an aggregate")
|
||||
}
|
||||
}
|
||||
|
||||
func TestBeginValidationPreservesObservedRevision(t *testing.T) {
|
||||
snapshot := instance.Snapshot{
|
||||
Phase: instance.PhaseReady, ObservedRevision: 0, Readiness: instance.Ready, ReportedVersion: "17",
|
||||
}
|
||||
value := lifecycleInstance(t, snapshot, false)
|
||||
target := value.Target()
|
||||
for range 2 {
|
||||
if err := value.BeginValidation(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
got := value.Snapshot()
|
||||
if got.Phase != instance.PhaseValidating || got.Readiness != instance.Unknown ||
|
||||
got.ObservedRevision != snapshot.ObservedRevision || got.ReportedVersion != snapshot.ReportedVersion {
|
||||
t.Fatal("recording validation intent claimed a completed observation or erased diagnostic version")
|
||||
}
|
||||
}
|
||||
if value.Target() != target {
|
||||
t.Fatal("lifecycle action mutated identity or configuration")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDeletionRequiresRequestAndPreventsValidation(t *testing.T) {
|
||||
snapshot := instance.Snapshot{Phase: instance.PhaseReady, Readiness: instance.Ready, ObservedRevision: 1}
|
||||
active := lifecycleInstance(t, snapshot, false)
|
||||
if err := active.BeginDeletion(); err == nil {
|
||||
t.Fatal("deletion without a request accepted")
|
||||
}
|
||||
if active.Snapshot() != snapshot {
|
||||
t.Fatal("rejected deletion mutated state")
|
||||
}
|
||||
for _, phase := range []instance.Phase{
|
||||
instance.PhasePending, instance.PhaseValidating, instance.PhaseInitializingRegistry,
|
||||
instance.PhaseReady, instance.PhaseDeleting,
|
||||
} {
|
||||
snapshot.Phase = phase
|
||||
value := lifecycleInstance(t, snapshot, true)
|
||||
if err := value.BeginValidation(); err == nil {
|
||||
t.Fatal("validation accepted after deletion request")
|
||||
}
|
||||
if value.Snapshot() != snapshot {
|
||||
t.Fatal("rejected validation mutated state")
|
||||
}
|
||||
for range 2 {
|
||||
if err := value.BeginDeletion(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := value.Snapshot(); got.Phase != instance.PhaseDeleting || got.Readiness != instance.Unknown ||
|
||||
got.ObservedRevision != snapshot.ObservedRevision {
|
||||
t.Fatal("incorrect deletion checkpoint")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestZeroInstanceCannotTransition(t *testing.T) {
|
||||
var value instance.Instance
|
||||
if err := value.BeginValidation(); err == nil {
|
||||
t.Fatal("zero instance started validation")
|
||||
}
|
||||
if err := value.BeginDeletion(); err == nil {
|
||||
t.Fatal("zero instance started deletion")
|
||||
}
|
||||
if value.Snapshot() != (instance.Snapshot{}) {
|
||||
t.Fatal("invalid transition changed zero instance")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
/*
|
||||
Copyright 2026.
|
||||
|
||||
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 instance
|
||||
|
||||
// Definition is the immutable effective configuration of an Instance.
|
||||
// Available extensions are observations, not part of the declared configuration.
|
||||
type Definition struct {
|
||||
endpoint Endpoint
|
||||
adminCredential CredentialReference
|
||||
}
|
||||
|
||||
func NewDefinition(endpoint Endpoint, adminCredential CredentialReference) (Definition, error) {
|
||||
definition := Definition{endpoint: endpoint, adminCredential: adminCredential}
|
||||
if err := definition.Validate(); err != nil {
|
||||
return Definition{}, err
|
||||
}
|
||||
return definition, nil
|
||||
}
|
||||
|
||||
func (d Definition) Endpoint() Endpoint { return d.endpoint }
|
||||
func (d Definition) AdminCredential() CredentialReference { return d.adminCredential }
|
||||
|
||||
// Validate rejects invalid zero-value components even when constructors were bypassed.
|
||||
func (d Definition) Validate() error {
|
||||
if err := d.endpoint.Validate(); err != nil {
|
||||
return err
|
||||
}
|
||||
return d.adminCredential.Validate()
|
||||
}
|
||||
|
||||
// ObservationTarget binds facts to a registration and its declared configuration.
|
||||
// It does not identify a physical PostgreSQL server or prove observation freshness.
|
||||
// Secret content refresh and same-target observation freshness remain application
|
||||
// responsibilities; no credentials or Secret contents are carried by this value.
|
||||
type ObservationTarget struct {
|
||||
identity Identity
|
||||
revision Revision
|
||||
definition Definition
|
||||
}
|
||||
|
||||
func NewObservationTarget(identity Identity, revision Revision, definition Definition) (ObservationTarget, error) {
|
||||
target := ObservationTarget{identity: identity, revision: revision, definition: definition}
|
||||
if err := target.Validate(); err != nil {
|
||||
return ObservationTarget{}, err
|
||||
}
|
||||
return target, nil
|
||||
}
|
||||
|
||||
func (t ObservationTarget) Identity() Identity { return t.identity }
|
||||
func (t ObservationTarget) Revision() Revision { return t.revision }
|
||||
func (t ObservationTarget) Definition() Definition { return t.definition }
|
||||
|
||||
func (t ObservationTarget) Validate() error {
|
||||
if err := t.identity.Validate(); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := t.revision.Validate(); err != nil {
|
||||
return err
|
||||
}
|
||||
return t.definition.Validate()
|
||||
}
|
||||
|
||||
// Matches rejects invalid targets before comparing values. Matching is necessary,
|
||||
// but not sufficient, for the aggregate to accept a fresh capability observation.
|
||||
func (t ObservationTarget) Matches(other ObservationTarget) bool {
|
||||
return t.Validate() == nil && other.Validate() == nil && t == other
|
||||
}
|
||||
@@ -0,0 +1,165 @@
|
||||
/*
|
||||
Copyright 2026.
|
||||
|
||||
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 instance_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"git.ddupan.top/panxiao81/ayatori/internal/database/domain/instance"
|
||||
)
|
||||
|
||||
func targetParts(t *testing.T) (instance.Identity, instance.Revision, instance.Definition) {
|
||||
t.Helper()
|
||||
identity, err := instance.NewIdentity("uid-1", "shared")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
revision, err := instance.NewRevision(1)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
endpoint, err := instance.NewEndpoint(validEndpoint())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
credential, err := instance.NewCredentialReference(validCredentialReference())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
definition, err := instance.NewDefinition(endpoint, credential)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return identity, revision, definition
|
||||
}
|
||||
|
||||
func TestDefinitionRejectsInvalidComponents(t *testing.T) {
|
||||
_, _, definition := targetParts(t)
|
||||
cases := []struct {
|
||||
endpoint instance.Endpoint
|
||||
credential instance.CredentialReference
|
||||
}{
|
||||
{instance.Endpoint{}, definition.AdminCredential()},
|
||||
{definition.Endpoint(), instance.CredentialReference{}},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
value, err := instance.NewDefinition(tc.endpoint, tc.credential)
|
||||
if err == nil || value != (instance.Definition{}) {
|
||||
t.Fatal("invalid component accepted or partial value returned")
|
||||
}
|
||||
}
|
||||
if err := (instance.Definition{}).Validate(); err == nil {
|
||||
t.Fatal("zero definition accepted")
|
||||
}
|
||||
}
|
||||
|
||||
func TestObservationTargetRejectsInvalidComponents(t *testing.T) {
|
||||
identity, revision, definition := targetParts(t)
|
||||
cases := []struct {
|
||||
identity instance.Identity
|
||||
revision instance.Revision
|
||||
definition instance.Definition
|
||||
}{
|
||||
{instance.Identity{}, revision, definition},
|
||||
{identity, instance.Revision{}, definition},
|
||||
{identity, revision, instance.Definition{}},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
value, err := instance.NewObservationTarget(tc.identity, tc.revision, tc.definition)
|
||||
if err == nil || value != (instance.ObservationTarget{}) {
|
||||
t.Fatal("invalid component accepted or partial target returned")
|
||||
}
|
||||
}
|
||||
zero := instance.ObservationTarget{}
|
||||
if err := zero.Validate(); err == nil {
|
||||
t.Fatal("zero target accepted")
|
||||
}
|
||||
if zero.Matches(zero) {
|
||||
t.Fatal("two invalid targets must not authorize observation reuse")
|
||||
}
|
||||
}
|
||||
|
||||
// Acceptance: docs/database/domain-instance.md §2/§6, observations cannot cross target bindings.
|
||||
func TestObservationTargetMatchesOnlySameBinding(t *testing.T) {
|
||||
identity, revision, definition := targetParts(t)
|
||||
original, err := instance.NewObservationTarget(identity, revision, definition)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
same, err := instance.NewObservationTarget(identity, revision, definition)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !original.Matches(same) || original.Identity() != identity ||
|
||||
original.Revision() != revision || original.Definition() != definition {
|
||||
t.Fatal("target did not preserve its declared binding")
|
||||
}
|
||||
changedIdentity, err := instance.NewIdentity("uid-2", identity.Name())
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
changedRevision, err := instance.NewRevision(2)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, parts := range []struct {
|
||||
identity instance.Identity
|
||||
revision instance.Revision
|
||||
}{{changedIdentity, revision}, {identity, changedRevision}} {
|
||||
changed, err := instance.NewObservationTarget(parts.identity, parts.revision, definition)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if original.Matches(changed) || changed.Matches(original) {
|
||||
t.Fatal("different registration or revision matched")
|
||||
}
|
||||
}
|
||||
endpointValues := definition.Endpoint().Values()
|
||||
endpointValues.Host = "other.example"
|
||||
endpoint, err := instance.NewEndpoint(endpointValues)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
credentialValues := definition.AdminCredential().Values()
|
||||
credentialValues.PasswordKey = "replacement"
|
||||
credential, err := instance.NewCredentialReference(credentialValues)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, components := range []struct {
|
||||
endpoint instance.Endpoint
|
||||
credential instance.CredentialReference
|
||||
}{{endpoint, definition.AdminCredential()}, {definition.Endpoint(), credential}} {
|
||||
changedDefinition, err := instance.NewDefinition(components.endpoint, components.credential)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
changed, err := instance.NewObservationTarget(identity, revision, changedDefinition)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if original.Matches(changed) {
|
||||
t.Fatal("changed definition matched even with the same revision")
|
||||
}
|
||||
}
|
||||
if original.Matches(instance.ObservationTarget{}) {
|
||||
t.Fatal("valid target matched zero target")
|
||||
}
|
||||
if !original.Matches(same) {
|
||||
t.Fatal("constructing changed targets mutated the original")
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user