150 lines
3.5 KiB
Go
150 lines
3.5 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"net/url"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
func ensurePostgresDatabaseExists(dsn string) error {
|
|
dsn = strings.TrimSpace(dsn)
|
|
if dsn == "" {
|
|
return errors.New("databaseUrl ist leer")
|
|
}
|
|
|
|
u, err := url.Parse(dsn)
|
|
if err != nil {
|
|
return fmt.Errorf("databaseUrl ungueltig: %w", err)
|
|
}
|
|
|
|
dbName, err := postgresDatabaseNameFromURL(u)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := pingPostgresDSN(u.String()); err == nil {
|
|
return nil
|
|
} else if !isMissingPostgresDatabaseError(err) {
|
|
return err
|
|
}
|
|
|
|
var lastErr error
|
|
for _, maintenanceDB := range []string{"postgres", "template1"} {
|
|
if strings.EqualFold(maintenanceDB, dbName) {
|
|
continue
|
|
}
|
|
|
|
maintenanceURL := *u
|
|
maintenanceURL.Path = "/" + maintenanceDB
|
|
maintenanceURL.RawPath = ""
|
|
|
|
if err := createPostgresDatabaseIfMissing(maintenanceURL.String(), dbName); err != nil {
|
|
lastErr = err
|
|
continue
|
|
}
|
|
|
|
return pingPostgresDSN(u.String())
|
|
}
|
|
|
|
if lastErr != nil {
|
|
return lastErr
|
|
}
|
|
return fmt.Errorf("Datenbank %s existiert nicht und konnte nicht angelegt werden", dbName)
|
|
}
|
|
|
|
func postgresDatabaseNameFromURL(u *url.URL) (string, error) {
|
|
if u == nil {
|
|
return "", errors.New("databaseUrl ist leer")
|
|
}
|
|
|
|
switch strings.ToLower(strings.TrimSpace(u.Scheme)) {
|
|
case "postgres", "postgresql":
|
|
default:
|
|
return "", errors.New("databaseUrl muss postgres:// oder postgresql:// verwenden")
|
|
}
|
|
|
|
dbName, err := url.PathUnescape(strings.TrimPrefix(u.EscapedPath(), "/"))
|
|
if err != nil {
|
|
return "", fmt.Errorf("Datenbankname ungueltig: %w", err)
|
|
}
|
|
dbName = strings.TrimSpace(dbName)
|
|
if dbName == "" {
|
|
return "", errors.New("Datenbankname fehlt in databaseUrl")
|
|
}
|
|
if strings.ContainsRune(dbName, 0) {
|
|
return "", errors.New("Datenbankname enthaelt ungueltige Zeichen")
|
|
}
|
|
return dbName, nil
|
|
}
|
|
|
|
func pingPostgresDSN(dsn string) error {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
|
|
db, err := sql.Open("pgx", dsn)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer db.Close()
|
|
|
|
return db.PingContext(ctx)
|
|
}
|
|
|
|
func createPostgresDatabaseIfMissing(maintenanceDSN string, dbName string) error {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
|
|
defer cancel()
|
|
|
|
db, err := sql.Open("pgx", maintenanceDSN)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer db.Close()
|
|
|
|
if err := db.PingContext(ctx); err != nil {
|
|
return err
|
|
}
|
|
|
|
var exists bool
|
|
if err := db.QueryRowContext(ctx, `SELECT EXISTS (SELECT 1 FROM pg_database WHERE datname=$1)`, dbName).Scan(&exists); err != nil {
|
|
return err
|
|
}
|
|
if exists {
|
|
return nil
|
|
}
|
|
|
|
_, err = db.ExecContext(ctx, `CREATE DATABASE `+quotePostgresIdentifier(dbName))
|
|
if err != nil && isDuplicatePostgresDatabaseError(err) {
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
|
|
func quotePostgresIdentifier(v string) string {
|
|
return `"` + strings.ReplaceAll(v, `"`, `""`) + `"`
|
|
}
|
|
|
|
func isMissingPostgresDatabaseError(err error) bool {
|
|
if err == nil {
|
|
return false
|
|
}
|
|
msg := strings.ToLower(err.Error())
|
|
return strings.Contains(msg, "sqlstate 3d000") ||
|
|
strings.Contains(msg, "sqlstate 30000") ||
|
|
strings.Contains(msg, "database") && strings.Contains(msg, "does not exist") ||
|
|
strings.Contains(msg, "datenbank") && strings.Contains(msg, "existiert nicht")
|
|
}
|
|
|
|
func isDuplicatePostgresDatabaseError(err error) bool {
|
|
if err == nil {
|
|
return false
|
|
}
|
|
msg := strings.ToLower(err.Error())
|
|
return strings.Contains(msg, "sqlstate 42p04") ||
|
|
strings.Contains(msg, "already exists") ||
|
|
strings.Contains(msg, "existiert bereits")
|
|
}
|