136 lines
3.8 KiB
Go
136 lines
3.8 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"errors"
|
|
"flag"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"pageswiki/internal/db"
|
|
"pageswiki/internal/dr"
|
|
"pageswiki/internal/store"
|
|
)
|
|
|
|
func runPostgreSQLMigration(args []string, out io.Writer) error {
|
|
f := flag.NewFlagSet("migrate-postgres", flag.ContinueOnError)
|
|
f.SetOutput(out)
|
|
defaultDir := os.Getenv("PAGESWIKI_DATA_DIR")
|
|
if defaultDir == "" {
|
|
defaultDir = "./data"
|
|
}
|
|
dir := f.String("data-dir", defaultDir, "stopped instance data directory; existing files are retained in place")
|
|
apply := f.Bool("apply", false, "copy into an empty PostgreSQL schema after source preflight")
|
|
insecure := f.Bool("allow-insecure", false, "allow unverified PostgreSQL TLS for isolated testing only")
|
|
timeout := f.Duration("timeout", 30*time.Minute, "migration timeout")
|
|
if err := f.Parse(args); err != nil {
|
|
if errors.Is(err, flag.ErrHelp) {
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
if f.NArg() != 0 || *timeout <= 0 {
|
|
return errors.New("invalid migration arguments")
|
|
}
|
|
if info, err := os.Stat(*dir); err != nil || !info.IsDir() {
|
|
return errors.New("existing data directory required")
|
|
}
|
|
lock, err := dr.Lock(*dir, true)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer lock.Close()
|
|
if node, err := dr.Load(*dir); err != nil {
|
|
return err
|
|
} else if node != nil {
|
|
return errors.New("PostgreSQL migration does not support a configured DR instance")
|
|
}
|
|
source, err := db.OpenReadOnly(filepath.Join(*dir, "pages.db"))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer source.Close()
|
|
ctx, cancel := context.WithTimeout(context.Background(), *timeout)
|
|
defer cancel()
|
|
tables, err := store.InspectSQLiteApplicationImport(ctx, source)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !*apply {
|
|
return json.NewEncoder(out).Encode(map[string]any{"mode": "preflight", "tables": tables, "copied": false})
|
|
}
|
|
target, err := db.OpenPostgreSQL(ctx, db.PostgreSQLOptions{DSN: os.Getenv("PAGESWIKI_POSTGRES_DSN"), AllowInsecure: *insecure})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer target.Close()
|
|
root := filepath.Join(*dir, "documents")
|
|
if err = store.PreparePostgreSQLImport(ctx, target, root); err != nil {
|
|
return err
|
|
}
|
|
report, err := store.ImportSQLiteApplication(ctx, source, target, root)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return json.NewEncoder(out).Encode(report)
|
|
}
|
|
|
|
func configuredDatabaseBackend() (string, error) {
|
|
b := strings.ToLower(strings.TrimSpace(os.Getenv("PAGESWIKI_DB_BACKEND")))
|
|
switch b {
|
|
case "", "sqlite":
|
|
return "sqlite", nil
|
|
case "postgresql":
|
|
return b, nil
|
|
default:
|
|
return "", errors.New("PAGESWIKI_DB_BACKEND must be sqlite or postgresql")
|
|
}
|
|
}
|
|
|
|
func openApplicationStore(ctx context.Context, dataDir string) (database *sql.DB, st *store.Store, err error) {
|
|
backend, err := configuredDatabaseBackend()
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
defer func() {
|
|
if err != nil && database != nil {
|
|
database.Close()
|
|
database = nil
|
|
}
|
|
}()
|
|
if backend == "postgresql" {
|
|
database, err = db.OpenPostgreSQL(ctx, db.PostgreSQLOptions{DSN: os.Getenv("PAGESWIKI_POSTGRES_DSN")})
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
root := filepath.Join(dataDir, "documents")
|
|
if err = store.VerifyPostgreSQLImport(ctx, database, root); err != nil {
|
|
return database, nil, err
|
|
}
|
|
st, err = store.NewPostgreSQLWithDocumentRoot(ctx, database, root)
|
|
return database, st, err
|
|
}
|
|
database, err = db.Open(filepath.Join(dataDir, "pages.db"))
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if err = db.Migrate(database); err != nil {
|
|
return database, nil, err
|
|
}
|
|
root, err := store.MigrateLegacyDocumentRoot(dataDir)
|
|
if err != nil {
|
|
return database, nil, err
|
|
}
|
|
st = store.NewWithDocumentRoot(database, root)
|
|
if err = st.EnsureConfigTable(); err != nil {
|
|
return database, nil, err
|
|
}
|
|
err = st.EnsurePathLinkColumns()
|
|
return database, st, err
|
|
}
|