lib/install/init.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 package install
   6
   7 import (
   8         "context"
   9         "crypto/rand"
  10         "crypto/rsa"
  11         "crypto/x509"
  12         "encoding/pem"
  13         "flag"
  14         "fmt"
  15         "io"
  16         "os"
  17         "os/exec"
  18         "os/user"
  19         "regexp"
  20         "strconv"
  21         "text/template"
  22
  23         "git.arvados.org/arvados.git/lib/cmd"
  24         "git.arvados.org/arvados.git/lib/config"
  25         "git.arvados.org/arvados.git/sdk/go/arvados"
  26         "git.arvados.org/arvados.git/sdk/go/ctxlog"
  27         "github.com/lib/pq"
  28 )
  29
  30 var InitCommand cmd.Handler = &initCommand{}
  31
  32 type initCommand struct {
  33         ClusterID          string
  34         Domain             string
  35         PostgreSQLPassword string
  36         Login              string
  37         TLS                string
  38         Start              bool
  39 }
  40
  41 func (initcmd *initCommand) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
  42         logger := ctxlog.New(stderr, "text", "info")
  43         ctx := ctxlog.Context(context.Background(), logger)
  44         ctx, cancel := context.WithCancel(ctx)
  45         defer cancel()
  46
  47         var err error
  48         defer func() {
  49                 if err != nil {
  50                         logger.WithError(err).Info("exiting")
  51                 }
  52         }()
  53
  54         hostname, err := os.Hostname()
  55         if err != nil {
  56                 err = fmt.Errorf("Hostname(): %w", err)
  57                 return 1
  58         }
  59
  60         flags := flag.NewFlagSet(prog, flag.ContinueOnError)
  61         flags.SetOutput(stderr)
  62         versionFlag := flags.Bool("version", false, "Write version information to stdout and exit 0")
  63         flags.StringVar(&initcmd.ClusterID, "cluster-id", "", "cluster `id`, like x1234 for a dev cluster")
  64         flags.StringVar(&initcmd.Domain, "domain", hostname, "cluster public DNS `name`, like x1234.arvadosapi.com")
  65         flags.StringVar(&initcmd.Login, "login", "", "login `backend`: test, pam, or ''")
  66         flags.StringVar(&initcmd.TLS, "tls", "none", "tls certificate `source`: acme, auto, insecure, or none")
  67         flags.BoolVar(&initcmd.Start, "start", true, "start systemd service after creating config")
  68         if ok, code := cmd.ParseFlags(flags, prog, args, "", stderr); !ok {
  69                 return code
  70         } else if *versionFlag {
  71                 return cmd.Version.RunCommand(prog, args, stdin, stdout, stderr)
  72         } else if !regexp.MustCompile(`^[a-z][a-z0-9]{4}`).MatchString(initcmd.ClusterID) {
  73                 err = fmt.Errorf("cluster ID %q is invalid; must be an ASCII letter followed by 4 alphanumerics (try -help)", initcmd.ClusterID)
  74                 return 1
  75         }
  76
  77         confdir := "/etc/arvados"
  78         conffile := confdir + "/config.yml"
  79         if _, err = os.Stat(conffile); err == nil {
  80                 err = fmt.Errorf("config file %s already exists; delete it first if you really want to start over", conffile)
  81                 return 1
  82         }
  83
  84         wwwuser, err := user.Lookup("www-data")
  85         if err != nil {
  86                 err = fmt.Errorf("user.Lookup(%q): %w", "www-data", err)
  87                 return 1
  88         }
  89         wwwgid, err := strconv.Atoi(wwwuser.Gid)
  90         if err != nil {
  91                 return 1
  92         }
  93         initcmd.PostgreSQLPassword = initcmd.RandomHex(32)
  94
  95         err = os.Mkdir("/var/lib/arvados/keep", 0600)
  96         if err != nil && !os.IsExist(err) {
  97                 err = fmt.Errorf("mkdir /var/lib/arvados/keep: %w", err)
  98                 return 1
  99         }
 100         fmt.Fprintln(stderr, "created /var/lib/arvados/keep")
 101
 102         err = os.Mkdir(confdir, 0750)
 103         if err != nil && !os.IsExist(err) {
 104                 err = fmt.Errorf("mkdir %s: %w", confdir, err)
 105                 return 1
 106         }
 107         err = os.Chown(confdir, 0, wwwgid)
 108         if err != nil {
 109                 err = fmt.Errorf("chown 0:%d %s: %w", wwwgid, confdir, err)
 110                 return 1
 111         }
 112         f, err := os.OpenFile(conffile, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0644)
 113         if err != nil {
 114                 err = fmt.Errorf("open %s: %w", conffile, err)
 115                 return 1
 116         }
 117         tmpl, err := template.New("config").Parse(`Clusters:
 118   {{.ClusterID}}:
 119     Services:
 120       Controller:
 121         InternalURLs:
 122           "http://0.0.0.0:9000/": {}
 123         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4440/" ) }}
 124       RailsAPI:
 125         InternalURLs:
 126           "http://0.0.0.0:9001/": {}
 127       Websocket:
 128         InternalURLs:
 129           "http://0.0.0.0:8005/": {}
 130         ExternalURL: {{printf "%q" ( print "wss://" .Domain ":4436/" ) }}
 131       Keepbalance:
 132         InternalURLs:
 133           "http://0.0.0.0:9019/": {}
 134       GitHTTP:
 135         InternalURLs:
 136           "http://0.0.0.0:9005/": {}
 137         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4445/" ) }}
 138       DispatchCloud:
 139         InternalURLs:
 140           "http://0.0.0.0:9006/": {}
 141       Keepproxy:
 142         InternalURLs:
 143           "http://0.0.0.0:9007/": {}
 144         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4447/" ) }}
 145       WebDAV:
 146         InternalURLs:
 147           "http://0.0.0.0:9008/": {}
 148         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4448/" ) }}
 149       WebDAVDownload:
 150         InternalURLs:
 151           "http://0.0.0.0:9009/": {}
 152         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4449/" ) }}
 153       Keepstore:
 154         InternalURLs:
 155           "http://0.0.0.0:9010/": {}
 156       Composer:
 157         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4459/composer" ) }}
 158       Workbench1:
 159         InternalURLs:
 160           "http://0.0.0.0:9002/": {}
 161         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4442/" ) }}
 162       Workbench2:
 163         InternalURLs:
 164           "http://0.0.0.0:9003/": {}
 165         ExternalURL: {{printf "%q" ( print "https://" .Domain "/" ) }}
 166       Health:
 167         InternalURLs:
 168           "http://0.0.0.0:9011/": {}
 169     Collections:
 170       BlobSigningKey: {{printf "%q" ( .RandomHex 50 )}}
 171       {{if eq .TLS "insecure"}}
 172       TrustAllContent: true
 173       {{end}}
 174     Containers:
 175       DispatchPrivateKey: {{printf "%q" .GenerateSSHPrivateKey}}
 176       CloudVMs:
 177         Enable: true
 178         Driver: loopback
 179     ManagementToken: {{printf "%q" ( .RandomHex 50 )}}
 180     PostgreSQL:
 181       Connection:
 182         dbname: arvados_production
 183         host: localhost
 184         user: arvados
 185         password: {{printf "%q" .PostgreSQLPassword}}
 186     SystemRootToken: {{printf "%q" ( .RandomHex 50 )}}
 187     TLS:
 188       {{if eq .TLS "insecure"}}
 189       Insecure: true
 190       {{else if eq .TLS "auto"}}
 191       Automatic: true
 192       {{else if eq .TLS "acme"}}
 193       Certificate: {{printf "%q" (print "/var/lib/acme/live/" .Domain "/cert")}}
 194       Key: {{printf "%q" (print "/var/lib/acme/live/" .Domain "/privkey")}}
 195       {{else}}
 196       {}
 197       {{end}}
 198     Volumes:
 199       {{.ClusterID}}-nyw5e-000000000000000:
 200         Driver: Directory
 201         DriverParameters:
 202           Root: /var/lib/arvados/keep
 203         Replication: 2
 204     Workbench:
 205       SecretKeyBase: {{printf "%q" ( .RandomHex 50 )}}
 206     Login:
 207       {{if eq .Login "pam"}}
 208       PAM:
 209         Enable: true
 210       {{else if eq .Login "test"}}
 211       Test:
 212         Enable: true
 213         Users:
 214           admin:
 215             Email: admin@example.com
 216             Password: admin
 217       {{else}}
 218       {}
 219       {{end}}
 220     Users:
 221       {{if eq .Login "test"}}
 222       AutoAdminUserWithEmail: admin@example.com
 223       {{else}}
 224       {}
 225       {{end}}
 226 `)
 227         if err != nil {
 228                 return 1
 229         }
 230         err = tmpl.Execute(f, initcmd)
 231         if err != nil {
 232                 err = fmt.Errorf("%s: tmpl.Execute: %w", conffile, err)
 233                 return 1
 234         }
 235         err = f.Close()
 236         if err != nil {
 237                 err = fmt.Errorf("%s: close: %w", conffile, err)
 238                 return 1
 239         }
 240         fmt.Fprintln(stderr, "created", conffile)
 241
 242         ldr := config.NewLoader(nil, logger)
 243         ldr.SkipLegacy = true
 244         cfg, err := ldr.Load()
 245         if err != nil {
 246                 err = fmt.Errorf("%s: %w", conffile, err)
 247                 return 1
 248         }
 249         cluster, err := cfg.GetCluster("")
 250         if err != nil {
 251                 return 1
 252         }
 253
 254         err = initcmd.createDB(ctx, cluster.PostgreSQL.Connection, stderr)
 255         if err != nil {
 256                 return 1
 257         }
 258
 259         cmd := exec.CommandContext(ctx, "sudo", "-u", "www-data", "-E", "HOME=/var/www", "PATH=/var/lib/arvados/bin:"+os.Getenv("PATH"), "/var/lib/arvados/bin/bundle", "exec", "rake", "db:setup")
 260         cmd.Dir = "/var/lib/arvados/railsapi"
 261         cmd.Stdout = stderr
 262         cmd.Stderr = stderr
 263         err = cmd.Run()
 264         if err != nil {
 265                 err = fmt.Errorf("rake db:setup failed: %w", err)
 266                 return 1
 267         }
 268         fmt.Fprintln(stderr, "initialized database")
 269
 270         if initcmd.Start {
 271                 fmt.Fprintln(stderr, "starting systemd service")
 272                 cmd := exec.CommandContext(ctx, "systemctl", "start", "--no-block", "arvados")
 273                 cmd.Dir = "/"
 274                 cmd.Stdout = stderr
 275                 cmd.Stderr = stderr
 276                 err = cmd.Run()
 277                 if err != nil {
 278                         err = fmt.Errorf("%v: %w", cmd.Args, err)
 279                         return 1
 280                 }
 281         }
 282
 283         return 0
 284 }
 285
 286 func (initcmd *initCommand) GenerateSSHPrivateKey() (string, error) {
 287         privkey, err := rsa.GenerateKey(rand.Reader, 4096)
 288         if err != nil {
 289                 return "", err
 290         }
 291         err = privkey.Validate()
 292         if err != nil {
 293                 return "", err
 294         }
 295         return string(pem.EncodeToMemory(&pem.Block{
 296                 Type:  "RSA PRIVATE KEY",
 297                 Bytes: x509.MarshalPKCS1PrivateKey(privkey),
 298         })), nil
 299 }
 300
 301 func (initcmd *initCommand) RandomHex(chars int) string {
 302         b := make([]byte, chars/2)
 303         _, err := rand.Read(b)
 304         if err != nil {
 305                 panic(err)
 306         }
 307         return fmt.Sprintf("%x", b)
 308 }
 309
 310 func (initcmd *initCommand) createDB(ctx context.Context, dbconn arvados.PostgreSQLConnection, stderr io.Writer) error {
 311         for _, sql := range []string{
 312                 `CREATE USER ` + pq.QuoteIdentifier(dbconn["user"]) + ` WITH SUPERUSER ENCRYPTED PASSWORD ` + pq.QuoteLiteral(dbconn["password"]),
 313                 `CREATE DATABASE ` + pq.QuoteIdentifier(dbconn["dbname"]) + ` WITH TEMPLATE template0 ENCODING 'utf8'`,
 314                 `CREATE EXTENSION IF NOT EXISTS pg_trgm`,
 315         } {
 316                 cmd := exec.CommandContext(ctx, "sudo", "-u", "postgres", "psql", "-c", sql)
 317                 cmd.Stdout = stderr
 318                 cmd.Stderr = stderr
 319                 err := cmd.Run()
 320                 if err != nil {
 321                         return fmt.Errorf("error setting up arvados user/database: %w", err)
 322                 }
 323         }
 324         return nil
 325 }