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         wwwuser, err := user.Lookup("www-data")
  78         if err != nil {
  79                 err = fmt.Errorf("user.Lookup(%q): %w", "www-data", err)
  80                 return 1
  81         }
  82         wwwgid, err := strconv.Atoi(wwwuser.Gid)
  83         if err != nil {
  84                 return 1
  85         }
  86         initcmd.PostgreSQLPassword = initcmd.RandomHex(32)
  87
  88         err = os.Mkdir("/var/lib/arvados/keep", 0600)
  89         if err != nil && !os.IsExist(err) {
  90                 err = fmt.Errorf("mkdir /var/lib/arvados/keep: %w", err)
  91                 return 1
  92         }
  93         fmt.Fprintln(stderr, "created /var/lib/arvados/keep")
  94
  95         err = os.Mkdir("/etc/arvados", 0750)
  96         if err != nil && !os.IsExist(err) {
  97                 err = fmt.Errorf("mkdir /etc/arvados: %w", err)
  98                 return 1
  99         }
 100         err = os.Chown("/etc/arvados", 0, wwwgid)
 101         f, err := os.OpenFile("/etc/arvados/config.yml", os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0644)
 102         if err != nil {
 103                 err = fmt.Errorf("open /etc/arvados/config.yml: %w", err)
 104                 return 1
 105         }
 106         tmpl, err := template.New("config").Parse(`Clusters:
 107   {{.ClusterID}}:
 108     Services:
 109       Controller:
 110         InternalURLs:
 111           "http://0.0.0.0:9000/": {}
 112         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4440/" ) }}
 113       RailsAPI:
 114         InternalURLs:
 115           "http://0.0.0.0:9001/": {}
 116       Websocket:
 117         InternalURLs:
 118           "http://0.0.0.0:8005/": {}
 119         ExternalURL: {{printf "%q" ( print "wss://" .Domain ":4436/" ) }}
 120       Keepbalance:
 121         InternalURLs:
 122           "http://0.0.0.0:9019/": {}
 123       GitHTTP:
 124         InternalURLs:
 125           "http://0.0.0.0:9005/": {}
 126         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4445/" ) }}
 127       DispatchCloud:
 128         InternalURLs:
 129           "http://0.0.0.0:9006/": {}
 130       Keepproxy:
 131         InternalURLs:
 132           "http://0.0.0.0:9007/": {}
 133         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4447/" ) }}
 134       WebDAV:
 135         InternalURLs:
 136           "http://0.0.0.0:9008/": {}
 137         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4448/" ) }}
 138       WebDAVDownload:
 139         InternalURLs:
 140           "http://0.0.0.0:9009/": {}
 141         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4449/" ) }}
 142       Keepstore:
 143         InternalURLs:
 144           "http://0.0.0.0:9010/": {}
 145       Composer:
 146         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4459/composer" ) }}
 147       Workbench1:
 148         InternalURLs:
 149           "http://0.0.0.0:9002/": {}
 150         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4442/" ) }}
 151       Workbench2:
 152         InternalURLs:
 153           "http://0.0.0.0:9003/": {}
 154         ExternalURL: {{printf "%q" ( print "https://" .Domain "/" ) }}
 155       Health:
 156         InternalURLs:
 157           "http://0.0.0.0:9011/": {}
 158     Collections:
 159       BlobSigningKey: {{printf "%q" ( .RandomHex 50 )}}
 160       {{if eq .TLS "insecure"}}
 161       TrustAllContent: true
 162       {{end}}
 163     Containers:
 164       DispatchPrivateKey: {{printf "%q" .GenerateSSHPrivateKey}}
 165       CloudVMs:
 166         Enable: true
 167         Driver: loopback
 168     ManagementToken: {{printf "%q" ( .RandomHex 50 )}}
 169     PostgreSQL:
 170       Connection:
 171         dbname: arvados_production
 172         host: localhost
 173         user: arvados
 174         password: {{printf "%q" .PostgreSQLPassword}}
 175     SystemRootToken: {{printf "%q" ( .RandomHex 50 )}}
 176     TLS:
 177       {{if eq .TLS "insecure"}}
 178       Insecure: true
 179       {{else if eq .TLS "auto"}}
 180       Automatic: true
 181       {{else if eq .TLS "acme"}}
 182       Certificate: {{printf "%q" (print "/var/lib/acme/live/" .Domain "/cert")}}
 183       Key: {{printf "%q" (print "/var/lib/acme/live/" .Domain "/privkey")}}
 184       {{else}}
 185       {}
 186       {{end}}
 187     Volumes:
 188       {{.ClusterID}}-nyw5e-000000000000000:
 189         Driver: Directory
 190         DriverParameters:
 191           Root: /var/lib/arvados/keep
 192         Replication: 2
 193     Workbench:
 194       SecretKeyBase: {{printf "%q" ( .RandomHex 50 )}}
 195     Login:
 196       {{if eq .Login "pam"}}
 197       PAM:
 198         Enable: true
 199       {{else if eq .Login "test"}}
 200       Test:
 201         Enable: true
 202         Users:
 203           admin:
 204             Email: admin@example.com
 205             Password: admin
 206       {{else}}
 207       {}
 208       {{end}}
 209     Users:
 210       {{if eq .Login "test"}}
 211       AutoAdminUserWithEmail: admin@example.com
 212       {{else}}
 213       {}
 214       {{end}}
 215 `)
 216         if err != nil {
 217                 return 1
 218         }
 219         err = tmpl.Execute(f, initcmd)
 220         if err != nil {
 221                 err = fmt.Errorf("/etc/arvados/config.yml: tmpl.Execute: %w", err)
 222                 return 1
 223         }
 224         err = f.Close()
 225         if err != nil {
 226                 err = fmt.Errorf("/etc/arvados/config.yml: close: %w", err)
 227                 return 1
 228         }
 229         fmt.Fprintln(stderr, "created /etc/arvados/config.yml")
 230
 231         ldr := config.NewLoader(nil, logger)
 232         ldr.SkipLegacy = true
 233         cfg, err := ldr.Load()
 234         if err != nil {
 235                 err = fmt.Errorf("/etc/arvados/config.yml: %w", err)
 236                 return 1
 237         }
 238         cluster, err := cfg.GetCluster("")
 239         if err != nil {
 240                 return 1
 241         }
 242
 243         err = initcmd.createDB(ctx, cluster.PostgreSQL.Connection, stderr)
 244         if err != nil {
 245                 return 1
 246         }
 247
 248         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")
 249         cmd.Dir = "/var/lib/arvados/railsapi"
 250         cmd.Stdout = stderr
 251         cmd.Stderr = stderr
 252         err = cmd.Run()
 253         if err != nil {
 254                 err = fmt.Errorf("rake db:setup: %w", err)
 255                 return 1
 256         }
 257         fmt.Fprintln(stderr, "initialized database")
 258
 259         if initcmd.Start {
 260                 fmt.Fprintln(stderr, "starting systemd service")
 261                 cmd := exec.CommandContext(ctx, "systemctl", "start", "--no-block", "arvados")
 262                 cmd.Dir = "/"
 263                 cmd.Stdout = stderr
 264                 cmd.Stderr = stderr
 265                 err = cmd.Run()
 266                 if err != nil {
 267                         err = fmt.Errorf("%v: %w", cmd.Args, err)
 268                         return 1
 269                 }
 270         }
 271
 272         return 0
 273 }
 274
 275 func (initcmd *initCommand) GenerateSSHPrivateKey() (string, error) {
 276         privkey, err := rsa.GenerateKey(rand.Reader, 4096)
 277         if err != nil {
 278                 return "", err
 279         }
 280         err = privkey.Validate()
 281         if err != nil {
 282                 return "", err
 283         }
 284         return string(pem.EncodeToMemory(&pem.Block{
 285                 Type:  "RSA PRIVATE KEY",
 286                 Bytes: x509.MarshalPKCS1PrivateKey(privkey),
 287         })), nil
 288 }
 289
 290 func (initcmd *initCommand) RandomHex(chars int) string {
 291         b := make([]byte, chars/2)
 292         _, err := rand.Read(b)
 293         if err != nil {
 294                 panic(err)
 295         }
 296         return fmt.Sprintf("%x", b)
 297 }
 298
 299 func (initcmd *initCommand) createDB(ctx context.Context, dbconn arvados.PostgreSQLConnection, stderr io.Writer) error {
 300         for _, sql := range []string{
 301                 `CREATE USER ` + pq.QuoteIdentifier(dbconn["user"]) + ` WITH SUPERUSER ENCRYPTED PASSWORD ` + pq.QuoteLiteral(dbconn["password"]),
 302                 `CREATE DATABASE ` + pq.QuoteIdentifier(dbconn["dbname"]) + ` WITH TEMPLATE template0 ENCODING 'utf8'`,
 303                 `CREATE EXTENSION IF NOT EXISTS pg_trgm`,
 304         } {
 305                 cmd := exec.CommandContext(ctx, "sudo", "-u", "postgres", "psql", "-c", sql)
 306                 cmd.Stdout = stderr
 307                 cmd.Stderr = stderr
 308                 err := cmd.Run()
 309                 if err != nil {
 310                         return fmt.Errorf("error setting up arvados user/database: %w", err)
 311                 }
 312         }
 313         return nil
 314 }