feat(storage): add native PostgreSQL runtime and verified offline application import
Build and publish container images / images (push) Failing after 12m29s
Build and publish container images / images (push) Failing after 12m29s
This commit is contained in:
1 parent
96065d1e89
commit
0ba1dcfef0
243 files changed
+21441
-3090
No files matched your search
@@ -0,0 +1,244 @@
|
||||
package metadata
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"database/sql"
|
||||
"encoding/hex"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// A core-compatible schema is a rehearsal scope, not an application readiness
|
||||
// claim. New application tables and security triggers always block core-only
|
||||
// copying; unknown data must never be silently dropped as a "cache".
|
||||
type PortabilityReport struct {
|
||||
Scope string `json:"scope"`
|
||||
ApplicationReady bool `json:"application_ready"`
|
||||
CoreCompatible bool `json:"core_compatible"`
|
||||
Tables []TablePortability `json:"tables"`
|
||||
Blockers []string `json:"blockers"`
|
||||
}
|
||||
type TablePortability struct {
|
||||
Name string `json:"name"`
|
||||
Component string `json:"component"`
|
||||
State string `json:"state"`
|
||||
}
|
||||
type tableSpec struct {
|
||||
name string
|
||||
columns []string
|
||||
keys []string
|
||||
identity bool
|
||||
}
|
||||
|
||||
// Explicit columns and primary-key order define an unambiguous streaming
|
||||
// fingerprint and an FK-safe copy order. Migration ledgers stay backend-local.
|
||||
var coreTables = []tableSpec{
|
||||
{"objects", strings.Split("uuid,kind,created_at", ","), []string{"uuid"}, false},
|
||||
{"object_origins", strings.Split("object_uuid,domain_uuid,created_at", ","), []string{"object_uuid"}, false},
|
||||
{"paths", strings.Split("domain_uuid,path,object_uuid,created_at,is_primary", ","), []string{"domain_uuid", "path"}, false},
|
||||
{"revisions", strings.Split(revisionColumns+",created_at,body", ","), []string{"uuid"}, false},
|
||||
{"assets", strings.Split(assetColumns, ","), []string{"domain_uuid", "address"}, false},
|
||||
{"asset_head_history", strings.Split("id,domain_uuid,address,action,document_hash,content_type,filename,size_bytes,actor_uuid,created_at_ms", ","), []string{"id"}, true},
|
||||
{"revision_document_refs", []string{"revision_uuid", "document_hash"}, []string{"revision_uuid", "document_hash"}, false},
|
||||
{"activity_outbox", strings.Split("uuid,domain_uuid,sequence,event_type,actor_uuid,target_kind,target_uuid,payload,idempotency_key,status,attempts,next_attempt_ms,last_error,created_at_ms,claimed_at_ms", ","), []string{"uuid"}, false},
|
||||
{"activity_outbox_heads", []string{"domain_uuid", "event_type", "last_sequence"}, []string{"domain_uuid", "event_type"}, false},
|
||||
}
|
||||
|
||||
func componentForTable(name string) string {
|
||||
for _, prefix := range []string{"auth", "principal", "group", "membership", "task", "calendar", "event", "notification", "activity", "federation", "domain", "campus", "config", "import", "resource", "adapter", "user", "profile", "contact", "feed", "periodical", "search", "locality", "city"} {
|
||||
if strings.HasPrefix(name, prefix) {
|
||||
return prefix
|
||||
}
|
||||
}
|
||||
if name == "zones" || name == "spots" || strings.HasPrefix(name, "spot_") || strings.HasPrefix(name, "street_") || name == "topology_events" {
|
||||
return "city"
|
||||
}
|
||||
return "unclassified"
|
||||
}
|
||||
|
||||
func (r *Repository) InspectPortability(ctx context.Context) (PortabilityReport, error) {
|
||||
tx, err := r.database.BeginTx(ctx, &sql.TxOptions{ReadOnly: true, Isolation: sql.LevelRepeatableRead})
|
||||
if err != nil {
|
||||
return PortabilityReport{}, r.failure(err)
|
||||
}
|
||||
defer tx.Rollback()
|
||||
return r.inspectPortability(ctx, tx)
|
||||
}
|
||||
|
||||
func (r *Repository) inspectPortability(ctx context.Context, tx *sql.Tx) (PortabilityReport, error) {
|
||||
report := PortabilityReport{Scope: "portable-core-rehearsal-only", Tables: []TablePortability{}, Blockers: []string{}}
|
||||
known := map[string]tableSpec{}
|
||||
for _, s := range coreTables {
|
||||
known[s.name] = s
|
||||
}
|
||||
query := `SELECT name,type FROM sqlite_master WHERE type IN ('table','view','trigger') AND substr(name,1,7)!='sqlite_' ORDER BY name`
|
||||
if r.backend == PostgreSQL {
|
||||
query = `SELECT c.relname,CASE WHEN c.relkind IN ('r','p') THEN 'table' ELSE 'view' END FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname=current_schema() AND c.relkind IN ('r','p','v','m','f')
|
||||
UNION ALL SELECT t.tgname,'trigger' FROM pg_trigger t JOIN pg_class c ON c.oid=t.tgrelid JOIN pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname=current_schema() AND NOT t.tgisinternal
|
||||
UNION ALL SELECT p.proname,'routine' FROM pg_proc p JOIN pg_namespace n ON n.oid=p.pronamespace WHERE n.nspname=current_schema()
|
||||
UNION ALL SELECT r.rulename,'rule' FROM pg_rewrite r JOIN pg_class c ON c.oid=r.ev_class JOIN pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname=current_schema() AND r.rulename!='_RETURN'
|
||||
UNION ALL SELECT c.relname,'sequence' FROM pg_class c JOIN pg_namespace n ON n.oid=c.relnamespace WHERE n.nspname=current_schema() AND c.relkind='S' AND NOT EXISTS(SELECT 1 FROM pg_depend d JOIN pg_class t ON t.oid=d.refobjid JOIN pg_namespace tn ON tn.oid=t.relnamespace WHERE d.objid=c.oid AND d.classid='pg_class'::regclass AND d.refclassid='pg_class'::regclass AND tn.nspname=current_schema() AND t.relname='asset_head_history' AND d.deptype='i') ORDER BY 1`
|
||||
}
|
||||
rows, err := tx.QueryContext(ctx, query)
|
||||
if err != nil {
|
||||
return report, r.failure(err)
|
||||
}
|
||||
types := map[string]string{}
|
||||
for rows.Next() {
|
||||
var name, kind string
|
||||
if err := rows.Scan(&name, &kind); err != nil {
|
||||
rows.Close()
|
||||
return report, r.failure(err)
|
||||
}
|
||||
if kind != "table" {
|
||||
report.Blockers = append(report.Blockers, fmt.Sprintf("unported %s: %s", kind, name))
|
||||
continue
|
||||
}
|
||||
types[name] = kind
|
||||
}
|
||||
err = rows.Err()
|
||||
rows.Close()
|
||||
if err != nil {
|
||||
return report, r.failure(err)
|
||||
}
|
||||
names := make([]string, 0, len(types))
|
||||
for name := range types {
|
||||
names = append(names, name)
|
||||
}
|
||||
sort.Strings(names)
|
||||
for _, name := range names {
|
||||
kind := types[name]
|
||||
if kind != "table" {
|
||||
report.Blockers = append(report.Blockers, fmt.Sprintf("unported %s: %s", kind, name))
|
||||
continue
|
||||
}
|
||||
if name == "schema_migration_steps" {
|
||||
continue
|
||||
}
|
||||
item := TablePortability{Name: name, Component: componentForTable(name), State: "unported"}
|
||||
if _, ok := known[name]; ok {
|
||||
item.Component = "core-metadata"
|
||||
item.State = "shape-pending"
|
||||
} else {
|
||||
report.Blockers = append(report.Blockers, "unported table: "+name)
|
||||
}
|
||||
report.Tables = append(report.Tables, item)
|
||||
}
|
||||
for _, spec := range coreTables {
|
||||
if types[spec.name] != "table" {
|
||||
report.Blockers = append(report.Blockers, "missing core table: "+spec.name)
|
||||
}
|
||||
}
|
||||
if types["schema_migration_steps"] != "table" {
|
||||
report.Blockers = append(report.Blockers, "missing portable migration ledger")
|
||||
} else {
|
||||
if err := r.inspectCoreHistory(ctx, tx, &report); err != nil {
|
||||
return report, err
|
||||
}
|
||||
}
|
||||
for i := range report.Tables {
|
||||
item := &report.Tables[i]
|
||||
spec, ok := known[item.Name]
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
columns, err := r.tableColumns(ctx, tx, item.Name)
|
||||
if err != nil {
|
||||
return report, err
|
||||
}
|
||||
actual := map[string]bool{}
|
||||
for _, c := range columns {
|
||||
actual[c] = true
|
||||
}
|
||||
matches := len(actual) == len(spec.columns)
|
||||
for _, c := range spec.columns {
|
||||
matches = matches && actual[c]
|
||||
}
|
||||
if !matches {
|
||||
item.State = "schema-drift"
|
||||
report.Blockers = append(report.Blockers, "column mismatch: "+item.Name)
|
||||
} else {
|
||||
item.State = "core-shape-compatible"
|
||||
}
|
||||
}
|
||||
if err := r.inspectCatalog(ctx, tx, &report); err != nil {
|
||||
return report, err
|
||||
}
|
||||
sort.Strings(report.Blockers)
|
||||
report.CoreCompatible = len(report.Blockers) == 0
|
||||
// This core-only report does not certify full-application readiness. Use
|
||||
// the Store application importer for the production migration inventory.
|
||||
// ApplicationReady intentionally remains false here because non-core
|
||||
// repositories, canonical files and worker state are outside this check.
|
||||
return report, nil
|
||||
}
|
||||
|
||||
func (r *Repository) tableColumns(ctx context.Context, tx *sql.Tx, table string) ([]string, error) {
|
||||
query := `SELECT name FROM pragma_table_info(` + r.p(1) + `) ORDER BY cid`
|
||||
if r.backend == PostgreSQL {
|
||||
query = `SELECT column_name FROM information_schema.columns WHERE table_schema=current_schema() AND table_name=$1 ORDER BY ordinal_position`
|
||||
}
|
||||
rows, err := tx.QueryContext(ctx, query, table)
|
||||
if err != nil {
|
||||
return nil, r.failure(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
var out []string
|
||||
for rows.Next() {
|
||||
var name string
|
||||
if err := rows.Scan(&name); err != nil {
|
||||
return nil, r.failure(err)
|
||||
}
|
||||
out = append(out, name)
|
||||
}
|
||||
return out, r.failure(rows.Err())
|
||||
}
|
||||
|
||||
func (r *Repository) inspectCoreHistory(ctx context.Context, tx *sql.Tx, report *PortabilityReport) error {
|
||||
sqliteSteps, pgSteps := r.migrationDefinitions()
|
||||
checksums := map[int]string{}
|
||||
names := map[int]string{}
|
||||
add := func(version int, name string, step any) {
|
||||
data, _ := json.Marshal(step)
|
||||
sum := sha256.Sum256(data)
|
||||
checksums[version] = hex.EncodeToString(sum[:])
|
||||
names[version] = name
|
||||
}
|
||||
for _, s := range sqliteSteps {
|
||||
add(s.Version, s.Name, s)
|
||||
}
|
||||
for _, s := range pgSteps {
|
||||
add(s.Version, s.Name, s)
|
||||
}
|
||||
rows, err := tx.QueryContext(ctx, `SELECT component,version,name,checksum FROM schema_migration_steps ORDER BY component,version`)
|
||||
if err != nil {
|
||||
return r.failure(err)
|
||||
}
|
||||
defer rows.Close()
|
||||
applied := 0
|
||||
for rows.Next() {
|
||||
var component, name, checksum string
|
||||
var version int
|
||||
if err := rows.Scan(&component, &version, &name, &checksum); err != nil {
|
||||
return r.failure(err)
|
||||
}
|
||||
if component != "core-metadata" {
|
||||
report.Blockers = append(report.Blockers, "unported migration component: "+component)
|
||||
continue
|
||||
}
|
||||
if version != applied+1 || names[version] != name || checksums[version] != checksum {
|
||||
report.Blockers = append(report.Blockers, "portable migration history mismatch")
|
||||
}
|
||||
applied++
|
||||
}
|
||||
if err := rows.Err(); err != nil {
|
||||
return r.failure(err)
|
||||
}
|
||||
if applied != len(checksums) {
|
||||
report.Blockers = append(report.Blockers, "portable migrations are not current")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
Reference in new issue
Block a user