Files
pages/internal/store/application_import.go
T
2026-11-15 05:47:14 +09:00

826 lines
25 KiB
Go

package store
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"os"
"path/filepath"
"sort"
"strings"
"time"
"pageswiki/internal/calendar"
"pageswiki/internal/metadata"
)
type ImportedTable struct {
Name string `json:"name"`
Rows int64 `json:"rows"`
SHA256 string `json:"sha256"`
}
type applicationImportRefusal struct{ reason string }
func (e *applicationImportRefusal) Error() string { return e.reason }
func importRefuse(reason string) error { return &applicationImportRefusal{reason} }
func importRefusef(format string, args ...any) error {
return importRefuse(fmt.Sprintf(format, args...))
}
type ApplicationImportReport struct {
Tables []ImportedTable `json:"tables"`
Omitted []string `json:"omitted"`
Documents int64 `json:"documents"`
Fingerprint string `json:"fingerprint"`
Sequences map[string]int64 `json:"sequences"`
Transforms []string `json:"transforms"`
}
// ImportSQLiteApplication imports into an EMPTY, already prepared PostgreSQL
// schema. The caller holds an exclusive data-directory lock and stops all
// writers. Files stay at documentRoot; no source rows or canonical files are
// changed. This is not a merge or an online migration.
func ImportSQLiteApplication(ctx context.Context, source, target *sql.DB, documentRoot string) (report ApplicationImportReport, err error) {
key, err := existingAuthKey(documentRoot)
if err != nil {
return report, err
}
root, err := filepath.Abs(documentRoot)
if err != nil {
return report, err
}
if info, e := os.Stat(root); e != nil || !info.IsDir() {
return report, ErrDocumentStoreRequired
}
s := &Store{DB: target, sqlBackend: storePostgreSQL, DocumentRoot: root}
defer func() {
if err != nil {
var refused *applicationImportRefusal
if errors.As(err, &refused) {
return
}
err = s.sqlError("application import", err)
}
}()
from, err := source.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
if err != nil {
return report, err
}
defer from.Rollback()
tables, err := inspectApplicationImportSource(ctx, from)
if err != nil {
return report, err
}
to, err := target.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelSerializable})
if err != nil {
return report, err
}
defer to.Rollback()
if err = inspectApplicationImportTarget(ctx, to); err != nil {
return report, err
}
if _, err = to.ExecContext(ctx, `SELECT pg_advisory_xact_lock(1885431653,1853058931)`); err != nil {
return report, err
}
var completed bool
if err = to.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM application_import_receipts)`).Scan(&completed); err != nil {
return report, err
}
if completed {
return report, importRefuse("application import already completed; overwrite is forbidden")
}
names := make([]string, 0, len(applicationImportColumns))
for name := range applicationImportColumns {
names = append(names, name)
}
sort.Strings(names)
// Validate all destination columns and take table locks before emptiness
// checks. Only exact schema-provided seed rows may be removed.
for _, name := range names {
if _, err = to.ExecContext(ctx, `LOCK TABLE `+importIdent(name)+` IN ACCESS EXCLUSIVE MODE`); err != nil {
return report, err
}
var n int64
if err = to.QueryRowContext(ctx, `SELECT count(*) FROM `+importIdent(name)).Scan(&n); err != nil {
return report, err
}
if n > 0 {
predicate, ok := importSeedPredicates[name]
if !ok {
return report, importRefusef("import destination is not empty: %s", name)
}
var valid bool
if err = to.QueryRowContext(ctx, `SELECT count(*)=1 AND bool_and(`+predicate+`) FROM `+importIdent(name)).Scan(&valid); err != nil {
return report, err
}
if !valid {
return report, importRefusef("import destination seed has changed: %s", name)
}
}
// User triggers derive state or revoke publication on normal writes.
// Suspend them only inside this transaction while restoring exact state.
// Foreign keys and CHECK/UNIQUE constraints stay enabled throughout.
if _, err = to.ExecContext(ctx, `ALTER TABLE `+importIdent(name)+` DISABLE TRIGGER USER`); err != nil {
return report, err
}
}
for name := range importSeedPredicates {
if _, err = to.ExecContext(ctx, `DELETE FROM `+importIdent(name)); err != nil {
return report, err
}
}
order, err := importTableOrder(ctx, to, names)
if err != nil {
return report, err
}
for _, name := range order {
columns := applicationImportColumns[name]
if !tables[name] {
if !strings.HasPrefix(name, "calendar_") {
return report, importRefusef("missing source table: %s", name)
}
continue
}
fingerprint, err := copyImportTable(ctx, from, to, name, strings.Split(columns, ","))
if err != nil {
return report, err
}
report.Tables = append(report.Tables, fingerprint)
}
// Source-only structures are explicitly classified, not inferred by prefix.
for name := range tables {
if _, ok := applicationImportOmissions[name]; ok {
report.Omitted = append(report.Omitted, name)
}
}
sort.Strings(report.Omitted)
report.Transforms = []string{"task DAV index keys: SQLite NUL-separated to native v1 base64url (resources and deletion tombstones)"}
// Verify every retained Document reference before committing metadata.
docs, err := s.documentStorage()
if err != nil {
return report, err
}
refs, err := to.QueryContext(ctx, `SELECT document_hash FROM revisions UNION SELECT head_document_hash FROM assets UNION SELECT document_hash FROM revision_document_refs UNION SELECT document_hash FROM asset_head_history`)
if err != nil {
return report, err
}
for refs.Next() {
var hash string
if err = refs.Scan(&hash); err != nil {
refs.Close()
return report, err
}
if err = docs.Verify(ctx, hash); err != nil {
refs.Close()
return report, importRefuse("canonical Document missing or hash mismatch; import rolled back")
}
report.Documents++
}
err = refs.Err()
refs.Close()
if err != nil {
return report, err
}
if err = validateImportedBindings(ctx, to); err != nil {
return report, err
}
for _, name := range names {
if _, err = to.ExecContext(ctx, `ALTER TABLE `+importIdent(name)+` ENABLE TRIGGER USER`); err != nil {
return report, err
}
}
// Sequence reset uses transactional ALTER, not non-transactional setval.
report.Sequences, err = sourceImportSequences(ctx, from)
if err != nil {
return report, err
}
if err = resetImportIdentities(ctx, to, report.Sequences); err != nil {
return report, err
}
sort.Slice(report.Tables, func(i, j int) bool { return report.Tables[i].Name < report.Tables[j].Name })
b, _ := json.Marshal(report)
sum := sha256.Sum256(b)
report.Fingerprint = hex.EncodeToString(sum[:])
b, _ = json.Marshal(report)
ks := sha256.Sum256(key)
if _, err = to.ExecContext(ctx, `INSERT INTO application_import_receipts VALUES(1,$1,$2,$3,$4,$5)`, report.Fingerprint, root, hex.EncodeToString(ks[:]), string(b), time.Now().UnixMilli()); err != nil {
return report, err
}
if err = ctx.Err(); err != nil {
return report, err
}
err = to.Commit()
return report, err
}
var importSeedPredicates = map[string]string{
"organizer_contact_epoch": `id=1 AND value ~ '^[a-f0-9]{64}$'`,
"organizer_activity_bridge": `id=1 AND last_sequence=0`,
"navigation_generation": `id=1 AND version=1`,
"event_queue_settings": `id=1 AND concurrency=1 AND max_depth=10000 AND paused=0 AND retry_base_seconds=30 AND retention_hours=168`,
"event_log_policies": `event_type='*' AND retention_hours=168 AND aggregate_after_hours=24 AND bucket_seconds=60 AND max_rows=5000`,
}
func importIdent(s string) string { return `"` + strings.ReplaceAll(s, `"`, `""`) + `"` }
func inspectApplicationImportSource(ctx context.Context, tx *sql.Tx) (map[string]bool, error) {
rows, err := tx.QueryContext(ctx, `SELECT name FROM sqlite_master WHERE type='table' AND substr(name,1,7)!='sqlite_' ORDER BY name`)
if err != nil {
return nil, err
}
names := map[string]bool{}
for rows.Next() {
var n string
if err = rows.Scan(&n); err != nil {
rows.Close()
return nil, err
}
names[n] = true
}
err = rows.Err()
rows.Close()
if err != nil {
return nil, err
}
for name := range names {
expected, ok := applicationImportColumns[name]
if !ok {
expected, ok = applicationImportOmissions[name]
}
if !ok {
return nil, importRefusef("unclassified source table: %s", name)
}
cols, err := tx.QueryContext(ctx, `SELECT name FROM pragma_table_info(?) ORDER BY name`, name)
if err != nil {
return nil, err
}
var got []string
for cols.Next() {
var n string
if err = cols.Scan(&n); err != nil {
cols.Close()
return nil, err
}
got = append(got, n)
}
err = cols.Err()
cols.Close()
if err != nil {
return nil, err
}
if strings.Join(got, ",") != expected {
return nil, importRefusef("source columns differ: %s", name)
}
}
for name := range applicationImportColumns {
if !names[name] && !strings.HasPrefix(name, "calendar_") {
return nil, importRefusef("missing source table: %s", name)
}
}
objects, err := tx.QueryContext(ctx, `SELECT type,name,sql FROM sqlite_master WHERE type IN ('trigger','view') ORDER BY name`)
if err != nil {
return nil, err
}
for objects.Next() {
var kind, name, ddl string
if err = objects.Scan(&kind, &name, &ddl); err != nil {
objects.Close()
return nil, err
}
sum := sha256.Sum256([]byte(ddl))
if applicationImportSourceObjects[name] != kind+":"+hex.EncodeToString(sum[:]) {
objects.Close()
return nil, importRefusef("unclassified or modified source %s: %s", kind, name)
}
}
err = objects.Err()
objects.Close()
if err != nil {
return nil, err
}
return names, nil
}
func inspectApplicationImportTarget(ctx context.Context, tx *sql.Tx) error {
rows, err := tx.QueryContext(ctx, `SELECT table_name,column_name FROM information_schema.columns WHERE table_schema=current_schema() ORDER BY table_name,column_name`)
if err != nil {
return err
}
got := map[string][]string{}
for rows.Next() {
var t, c string
if err = rows.Scan(&t, &c); err != nil {
rows.Close()
return err
}
got[t] = append(got[t], c)
}
err = rows.Err()
rows.Close()
if err != nil {
return err
}
for name, cols := range got {
if name == "schema_migration_steps" || name == "application_import_receipts" {
continue
}
expected, ok := applicationImportColumns[name]
if !ok {
return importRefusef("unclassified destination table: %s", name)
}
if name == "event_jobs" {
expected += ",claim_token"
p := strings.Split(expected, ",")
sort.Strings(p)
expected = strings.Join(p, ",")
}
if strings.Join(cols, ",") != expected {
return importRefusef("destination columns differ: %s", name)
}
}
for name := range applicationImportColumns {
if _, ok := got[name]; !ok {
return importRefusef("missing destination table: %s", name)
}
}
return nil
}
func importTableOrder(ctx context.Context, tx *sql.Tx, names []string) ([]string, error) {
deps := map[string][]string{}
rows, err := tx.QueryContext(ctx, `SELECT a.relname,b.relname FROM pg_constraint f JOIN pg_class a ON a.oid=f.conrelid JOIN pg_class b ON b.oid=f.confrelid JOIN pg_namespace n ON n.oid=a.relnamespace WHERE f.contype='f' AND n.nspname=current_schema()`)
if err != nil {
return nil, err
}
for rows.Next() {
var a, b string
if err = rows.Scan(&a, &b); err != nil {
rows.Close()
return nil, err
}
if a != b {
deps[a] = append(deps[a], b)
}
}
err = rows.Err()
rows.Close()
if err != nil {
return nil, err
}
var order []string
seen := map[string]bool{}
for len(order) < len(names) {
changed := false
for _, name := range names {
if seen[name] {
continue
}
ready := true
for _, dep := range deps[name] {
ready = ready && seen[dep]
}
if ready {
order = append(order, name)
seen[name] = true
changed = true
}
}
if !changed {
return nil, importRefuse("unsupported import foreign key dependency")
}
}
return order, nil
}
func importSelect(name string, columns []string, pg bool) string {
quoted := make([]string, len(columns))
for i, c := range columns {
quoted[i] = importIdent(c)
}
// All columns participate, including duplicate legacy tags. SQL collation
// is kept bytewise to produce the same deterministic row stream.
order := make([]string, len(columns))
for i, q := range quoted {
if pg {
order[i] = q + ` NULLS FIRST`
} else {
order[i] = q + ` COLLATE BINARY NULLS FIRST`
}
}
if name == "organizer_task_deletions" {
order = []string{`"domain_uuid" COLLATE BINARY`, `"item_uuid" COLLATE BINARY`}
if pg {
order = []string{`"domain_uuid" COLLATE "C"`, `"item_uuid" COLLATE "C"`}
}
}
return `SELECT ` + strings.Join(quoted, ",") + ` FROM ` + importIdent(name) + ` ORDER BY ` + strings.Join(order, ",")
}
func copyImportTable(ctx context.Context, from, to *sql.Tx, name string, columns []string) (ImportedTable, error) {
result := ImportedTable{Name: name}
hash := sha256.New()
rows, err := from.QueryContext(ctx, importSelect(name, columns, false))
if err != nil {
return result, err
}
defer rows.Close()
quoted := make([]string, len(columns))
for i, c := range columns {
quoted[i] = importIdent(c)
}
var batch [][]any
bytes := 0
flush := func() error {
if len(batch) == 0 {
return nil
}
args := make([]any, 0, len(batch)*len(columns))
values := make([]string, 0, len(batch))
for _, row := range batch {
p := make([]string, len(columns))
for i, v := range row {
args = append(args, v)
p[i] = fmt.Sprintf("$%d", len(args))
}
values = append(values, "("+strings.Join(p, ",")+")")
}
_, err := to.ExecContext(ctx, `INSERT INTO `+importIdent(name)+` (`+strings.Join(quoted, ",")+`) OVERRIDING SYSTEM VALUE VALUES `+strings.Join(values, ","), args...)
batch = nil
bytes = 0
return err
}
for rows.Next() {
v := make([]any, len(columns))
dest := make([]any, len(v))
for i := range v {
dest[i] = &v[i]
}
if err = rows.Scan(dest...); err != nil {
return result, err
}
if err = normalizeImportRow(name, columns, v); err != nil {
return result, err
}
b, err := importRowBytes(v)
if err != nil {
return result, err
}
if len(b) > 64<<20 {
return result, importRefuse("import row exceeds 64 MiB safety limit")
}
hash.Write(b)
hash.Write([]byte{'\n'})
result.Rows++
batch = append(batch, v)
bytes += len(b)
if len(batch) >= 100 || bytes >= 2<<20 {
if err = flush(); err != nil {
return result, err
}
}
}
if err = rows.Err(); err != nil {
return result, err
}
rows.Close()
if err = flush(); err != nil {
return result, err
}
result.SHA256 = hex.EncodeToString(hash.Sum(nil))
// Re-read retained values, not only row counts. Bytea/NULL/integer/text
// retain their JSON type tags, so conversion or loss fails the transaction.
selectSQL := importSelect(name, columns, true)
// Force bytewise ordering for TEXT regardless of the database default.
meta, err := to.QueryContext(ctx, `SELECT column_name FROM information_schema.columns WHERE table_schema=current_schema() AND table_name=$1 AND data_type IN ('text','character varying','character')`, name)
if err != nil {
return result, err
}
textCols := map[string]bool{}
for meta.Next() {
var c string
if err = meta.Scan(&c); err != nil {
meta.Close()
return result, err
}
textCols[c] = true
}
err = meta.Err()
meta.Close()
if err != nil {
return result, err
}
ordering := make([]string, len(columns))
for i, c := range columns {
ordering[i] = importIdent(c)
if textCols[c] {
ordering[i] += ` COLLATE "C"`
}
ordering[i] += " NULLS FIRST"
}
if name == "organizer_task_deletions" {
ordering = []string{`"domain_uuid" COLLATE "C"`, `"item_uuid" COLLATE "C"`}
}
selectSQL = selectSQL[:strings.Index(selectSQL, " ORDER BY ")] + " ORDER BY " + strings.Join(ordering, ",")
check, err := to.QueryContext(ctx, selectSQL)
if err != nil {
return result, err
}
defer check.Close()
h := sha256.New()
var count int64
for check.Next() {
v := make([]any, len(columns))
dest := make([]any, len(v))
for i := range v {
dest[i] = &v[i]
}
if err = check.Scan(dest...); err != nil {
return result, err
}
b, err := importRowBytes(v)
if err != nil {
return result, err
}
h.Write(b)
h.Write([]byte{'\n'})
count++
}
if err = check.Err(); err != nil {
return result, err
}
if count != result.Rows || hex.EncodeToString(h.Sum(nil)) != result.SHA256 {
return result, importRefusef("import content fingerprint differs: %s", name)
}
return result, nil
}
func normalizeImportRow(table string, columns []string, values []any) error {
for i, column := range columns {
// SQLite may scan a non-NULL zero-length BLOB as []byte(nil).
// pgx binds that slice as SQL NULL unless made explicitly non-nil.
if b, ok := values[i].([]byte); ok && b == nil {
values[i] = []byte{}
}
if !(table == "organizer_dav_resources" && (column == "name" || column == "uid")) &&
!(table == "organizer_task_deletions" && (column == "dav_name" || column == "dav_uid")) {
continue
}
value, ok := values[i].(string)
if !ok {
return importRefuse("invalid task DAV index scalar")
}
project := ""
if strings.HasPrefix(value, "\x00") {
parts := strings.Split(value, "\x00")
if len(parts) != 3 || parts[1] == "" || parts[2] == "" {
return importRefuse("invalid legacy task DAV index key")
}
project, value = parts[1], parts[2]
} else if strings.ContainsRune(value, 0) {
return importRefuse("invalid legacy task DAV index key")
}
values[i] = nativeTaskDAVIndexKey(project, value)
}
return nil
}
func resetImportIdentities(ctx context.Context, tx *sql.Tx, sourceSequences map[string]int64) error {
rows, err := tx.QueryContext(ctx, `SELECT table_name,column_name FROM information_schema.columns WHERE table_schema=current_schema() AND is_identity='YES'`)
if err != nil {
return err
}
var ids [][2]string
for rows.Next() {
var t, c string
if err = rows.Scan(&t, &c); err != nil {
rows.Close()
return err
}
ids = append(ids, [2]string{t, c})
}
err = rows.Err()
rows.Close()
if err != nil {
return err
}
for _, id := range ids {
if _, ok := applicationImportColumns[id[0]]; !ok {
return importRefuse("unclassified identity")
}
var next int64
if err = tx.QueryRowContext(ctx, `SELECT COALESCE(max(`+importIdent(id[1])+`),0)+1 FROM `+importIdent(id[0])).Scan(&next); err != nil {
return err
}
if next < 1 {
return importRefuse("identity overflow")
}
if previous := sourceSequences[id[0]]; previous >= next {
if previous == int64(^uint64(0)>>1) {
return importRefuse("identity exhausted")
}
next = previous + 1
}
if _, err = tx.ExecContext(ctx, `ALTER TABLE `+importIdent(id[0])+` ALTER COLUMN `+importIdent(id[1])+` RESTART WITH `+fmt.Sprint(next)); err != nil {
return err
}
}
return nil
}
func sourceImportSequences(ctx context.Context, tx *sql.Tx) (map[string]int64, error) {
out := map[string]int64{}
var exists bool
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE name='sqlite_sequence')`).Scan(&exists); err != nil {
return nil, err
}
if !exists {
return out, nil
}
rows, err := tx.QueryContext(ctx, `SELECT name,seq FROM sqlite_sequence`)
if err != nil {
return nil, err
}
defer rows.Close()
for rows.Next() {
var name string
var seq int64
if err = rows.Scan(&name, &seq); err != nil {
return nil, err
}
if _, ok := applicationImportColumns[name]; ok {
out[name] = seq
} else if _, ok := applicationImportOmissions[name]; !ok {
return nil, importRefusef("unclassified sequence: %s", name)
}
}
return out, rows.Err()
}
func validateImportedBindings(ctx context.Context, tx *sql.Tx) error {
var bad bool
err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM domains d LEFT JOIN campuses c ON c.uuid=d.campus_uuid WHERE c.uuid IS NULL) OR EXISTS(SELECT 1 FROM paths p LEFT JOIN domains d ON d.uuid=p.domain_uuid WHERE d.uuid IS NULL) OR EXISTS(SELECT 1 FROM domain_memberships m LEFT JOIN domains d ON d.uuid=m.domain_uuid LEFT JOIN principals p ON p.uuid=m.principal_uuid WHERE d.uuid IS NULL OR p.uuid IS NULL)`).Scan(&bad)
if err != nil {
return err
}
if bad {
return importRefuse("imported namespace or membership integrity failed")
}
return nil
}
// PreparePostgreSQLImport creates only schema in a dedicated empty database.
// It must not be used to adopt a populated or unversioned PostgreSQL schema.
func PreparePostgreSQLImport(ctx context.Context, target *sql.DB, root string) error {
if err := refusePopulatedImportTarget(ctx, target); err != nil {
return err
}
s := &Store{DB: target, sqlBackend: storePostgreSQL, DocumentRoot: root}
if err := s.ensurePostgreSQLNamespaces(ctx); err != nil {
return err
}
core, err := metadata.New(target, metadata.PostgreSQL)
if err != nil {
return err
}
if err = core.InitializeFresh(ctx); err != nil {
return err
}
if err = s.prepareNativeApplicationSchemas(ctx); err != nil {
return err
}
_, err = calendar.NewPostgreSQL(ctx, filepath.Join(root, "calendars"), target)
return err
}
// Preparation must not run migrations against an existing application. Failed
// attempts may leave versioned schema and exact default seeds, but no user rows.
func refusePopulatedImportTarget(ctx context.Context, target *sql.DB) error {
rows, err := target.QueryContext(ctx, `SELECT table_name FROM information_schema.tables WHERE table_schema=current_schema() AND table_type='BASE TABLE'`)
if err != nil {
return err
}
var names []string
for rows.Next() {
var name string
if err = rows.Scan(&name); err != nil {
rows.Close()
return err
}
names = append(names, name)
}
err = rows.Err()
rows.Close()
if err != nil {
return err
}
for _, name := range names {
if name == "schema_migration_steps" {
continue
}
if _, ok := applicationImportColumns[name]; !ok && name != "application_import_receipts" {
return importRefuse("import destination contains an unmanaged table")
}
var n int64
if err = target.QueryRowContext(ctx, `SELECT count(*) FROM `+importIdent(name)).Scan(&n); err != nil {
return err
}
if n == 0 {
continue
}
predicate, ok := importSeedPredicates[name]
if !ok {
return importRefusef("import destination is not empty: %s", name)
}
var valid bool
if err = target.QueryRowContext(ctx, `SELECT count(*)=1 AND bool_and(`+predicate+`) FROM `+importIdent(name)).Scan(&valid); err != nil {
return err
}
if !valid {
return importRefusef("import destination seed has changed: %s", name)
}
}
return nil
}
// JSON alone cannot distinguish a byte slice from its base64 text, nor an
// integer from an integral float. Explicit tags make conversion detectable.
func importRowBytes(values []any) ([]byte, error) {
type cell struct {
Type string
Value any
}
row := make([]cell, len(values))
for i, value := range values {
var kind string
switch value.(type) {
case nil:
kind = "null"
case string:
kind = "text"
case []byte:
kind = "bytes"
if value.([]byte) == nil {
value = []byte{}
}
case int64:
kind = "integer"
case float64:
kind = "float"
case bool:
kind = "boolean"
default:
return nil, importRefuse("unsupported import scalar type")
}
row[i] = cell{kind, value}
}
return json.Marshal(row)
}
// InspectSQLiteApplicationImport never writes or hydrates user content.
func InspectSQLiteApplicationImport(ctx context.Context, source *sql.DB) ([]string, error) {
tx, err := source.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
if err != nil {
return nil, err
}
defer tx.Rollback()
tables, err := inspectApplicationImportSource(ctx, tx)
if err != nil {
return nil, err
}
names := make([]string, 0, len(tables))
for name := range tables {
names = append(names, name)
}
sort.Strings(names)
return names, nil
}
// VerifyPostgreSQLImport gates the production selector. A successful core-only
// rehearsal is insufficient. The original key and the same canonical root are
// required; relocation/restore must preserve the configured mount path.
func VerifyPostgreSQLImport(ctx context.Context, target *sql.DB, root string) error {
key, err := existingAuthKey(root)
if err != nil {
return err
}
root, err = filepath.Abs(root)
if err != nil {
return err
}
var path, keyHash, fingerprint string
var completed int64
if err = target.QueryRowContext(ctx, `SELECT document_root,key_fingerprint,source_fingerprint,completed_at_ms FROM application_import_receipts WHERE id=1`).Scan(&path, &keyHash, &fingerprint, &completed); err != nil {
return importRefuse("PostgreSQL startup requires a completed full application import")
}
sum := sha256.Sum256(key)
if root != path || keyHash != hex.EncodeToString(sum[:]) || len(fingerprint) != 64 || completed <= 0 {
return importRefuse("PostgreSQL import root/key receipt mismatch")
}
return nil
}