lib/boot/postgresql.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 package boot
   6
   7 import (
   8         "bytes"
   9         "context"
  10         "database/sql"
  11         "fmt"
  12         "os"
  13         "os/exec"
  14         "os/user"
  15         "path/filepath"
  16         "strconv"
  17         "strings"
  18         "time"
  19
  20         "git.arvados.org/arvados.git/sdk/go/arvados"
  21         "github.com/lib/pq"
  22 )
  23
  24 // Run a postgresql server in a private data directory. Set up a db
  25 // user, database, and TCP listener that match the supervisor's
  26 // configured database connection info.
  27 type runPostgreSQL struct{}
  28
  29 func (runPostgreSQL) String() string {
  30         return "postgresql"
  31 }
  32
  33 func (runPostgreSQL) Run(ctx context.Context, fail func(error), super *Supervisor) error {
  34         err := super.wait(ctx, createCertificates{})
  35         if err != nil {
  36                 return err
  37         }
  38
  39         if super.ClusterType == "production" {
  40                 return nil
  41         }
  42
  43         iamroot := false
  44         if u, err := user.Current(); err != nil {
  45                 return fmt.Errorf("user.Current(): %w", err)
  46         } else if u.Uid == "0" {
  47                 iamroot = true
  48         }
  49
  50         buf := bytes.NewBuffer(nil)
  51         err = super.RunProgram(ctx, super.tempdir, buf, nil, "pg_config", "--bindir")
  52         if err != nil {
  53                 return err
  54         }
  55         bindir := strings.TrimSpace(buf.String())
  56
  57         datadir := filepath.Join(super.tempdir, "pgdata")
  58         err = os.Mkdir(datadir, 0700)
  59         if err != nil {
  60                 return err
  61         }
  62         prog, args := filepath.Join(bindir, "initdb"), []string{"-D", datadir, "-E", "utf8"}
  63         if iamroot {
  64                 postgresUser, err := user.Lookup("postgres")
  65                 if err != nil {
  66                         return fmt.Errorf("user.Lookup(\"postgres\"): %s", err)
  67                 }
  68                 postgresUID, err := strconv.Atoi(postgresUser.Uid)
  69                 if err != nil {
  70                         return fmt.Errorf("user.Lookup(\"postgres\"): non-numeric uid?: %q", postgresUser.Uid)
  71                 }
  72                 postgresGid, err := strconv.Atoi(postgresUser.Gid)
  73                 if err != nil {
  74                         return fmt.Errorf("user.Lookup(\"postgres\"): non-numeric gid?: %q", postgresUser.Gid)
  75                 }
  76                 err = os.Chown(super.tempdir, 0, postgresGid)
  77                 if err != nil {
  78                         return err
  79                 }
  80                 err = os.Chmod(super.tempdir, 0710)
  81                 if err != nil {
  82                         return err
  83                 }
  84                 err = os.Chown(datadir, postgresUID, 0)
  85                 if err != nil {
  86                         return err
  87                 }
  88                 // We can't use "sudo -u" here because it creates an
  89                 // intermediate process that interferes with our
  90                 // ability to reliably kill postgres. The setuidgid
  91                 // program just calls exec without forking, so it
  92                 // doesn't have this problem.
  93                 args = append([]string{"postgres", prog}, args...)
  94                 prog = "setuidgid"
  95         }
  96         err = super.RunProgram(ctx, super.tempdir, nil, nil, prog, args...)
  97         if err != nil {
  98                 return err
  99         }
 100
 101         err = super.RunProgram(ctx, super.tempdir, nil, nil, "cp", "server.crt", "server.key", datadir)
 102         if err != nil {
 103                 return err
 104         }
 105         if iamroot {
 106                 err = super.RunProgram(ctx, super.tempdir, nil, nil, "chown", "postgres", datadir+"/server.crt", datadir+"/server.key")
 107                 if err != nil {
 108                         return err
 109                 }
 110         }
 111
 112         port := super.cluster.PostgreSQL.Connection["port"]
 113
 114         super.waitShutdown.Add(1)
 115         go func() {
 116                 defer super.waitShutdown.Done()
 117                 prog, args := filepath.Join(bindir, "postgres"), []string{
 118                         "-l",          // enable ssl
 119                         "-D", datadir, // data dir
 120                         "-k", datadir, // socket dir
 121                         "-p", super.cluster.PostgreSQL.Connection["port"],
 122                 }
 123                 if iamroot {
 124                         args = append([]string{"postgres", prog}, args...)
 125                         prog = "setuidgid"
 126                 }
 127                 fail(super.RunProgram(ctx, super.tempdir, nil, nil, prog, args...))
 128         }()
 129
 130         for {
 131                 if ctx.Err() != nil {
 132                         return ctx.Err()
 133                 }
 134                 if exec.CommandContext(ctx, "pg_isready", "--timeout=10", "--host="+super.cluster.PostgreSQL.Connection["host"], "--port="+port).Run() == nil {
 135                         break
 136                 }
 137                 time.Sleep(time.Second / 2)
 138         }
 139         pgconn := arvados.PostgreSQLConnection{
 140                 "host":   datadir,
 141                 "port":   port,
 142                 "dbname": "postgres",
 143         }
 144         if iamroot {
 145                 pgconn["user"] = "postgres"
 146         }
 147         db, err := sql.Open("postgres", pgconn.String())
 148         if err != nil {
 149                 return fmt.Errorf("db open failed: %s", err)
 150         }
 151         defer db.Close()
 152         conn, err := db.Conn(ctx)
 153         if err != nil {
 154                 return fmt.Errorf("db conn failed: %s", err)
 155         }
 156         defer conn.Close()
 157         _, err = conn.ExecContext(ctx, `CREATE USER `+pq.QuoteIdentifier(super.cluster.PostgreSQL.Connection["user"])+` WITH SUPERUSER ENCRYPTED PASSWORD `+pq.QuoteLiteral(super.cluster.PostgreSQL.Connection["password"]))
 158         if err != nil {
 159                 return fmt.Errorf("createuser failed: %s", err)
 160         }
 161         _, err = conn.ExecContext(ctx, `CREATE DATABASE `+pq.QuoteIdentifier(super.cluster.PostgreSQL.Connection["dbname"])+` WITH TEMPLATE template0 ENCODING 'utf8'`)
 162         if err != nil {
 163                 return fmt.Errorf("createdb failed: %s", err)
 164         }
 165         return nil
 166 }