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 }
  38
  39 func (initcmd *initCommand) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
  40         logger := ctxlog.New(stderr, "text", "info")
  41         ctx := ctxlog.Context(context.Background(), logger)
  42         ctx, cancel := context.WithCancel(ctx)
  43         defer cancel()
  44
  45         var err error
  46         defer func() {
  47                 if err != nil {
  48                         logger.WithError(err).Info("exiting")
  49                 }
  50         }()
  51
  52         hostname, err := os.Hostname()
  53         if err != nil {
  54                 err = fmt.Errorf("Hostname(): %w", err)
  55                 return 1
  56         }
  57
  58         flags := flag.NewFlagSet(prog, flag.ContinueOnError)
  59         flags.SetOutput(stderr)
  60         versionFlag := flags.Bool("version", false, "Write version information to stdout and exit 0")
  61         flags.StringVar(&initcmd.ClusterID, "cluster-id", "", "cluster `id`, like x1234 for a dev cluster")
  62         flags.StringVar(&initcmd.Domain, "domain", hostname, "cluster public DNS `name`, like x1234.arvadosapi.com")
  63         flags.StringVar(&initcmd.Login, "login", "", "login `backend`: test, pam, or ''")
  64         if ok, code := cmd.ParseFlags(flags, prog, args, "", stderr); !ok {
  65                 return code
  66         } else if *versionFlag {
  67                 return cmd.Version.RunCommand(prog, args, stdin, stdout, stderr)
  68         } else if !regexp.MustCompile(`^[a-z][a-z0-9]{4}`).MatchString(initcmd.ClusterID) {
  69                 err = fmt.Errorf("cluster ID %q is invalid; must be an ASCII letter followed by 4 alphanumerics (try -help)", initcmd.ClusterID)
  70                 return 1
  71         }
  72
  73         wwwuser, err := user.Lookup("www-data")
  74         if err != nil {
  75                 err = fmt.Errorf("user.Lookup(%q): %w", "www-data", err)
  76                 return 1
  77         }
  78         wwwgid, err := strconv.Atoi(wwwuser.Gid)
  79         if err != nil {
  80                 return 1
  81         }
  82         initcmd.PostgreSQLPassword = initcmd.RandomHex(32)
  83
  84         err = os.Mkdir("/var/lib/arvados/keep", 0600)
  85         if err != nil && !os.IsExist(err) {
  86                 err = fmt.Errorf("mkdir /var/lib/arvados/keep: %w", err)
  87                 return 1
  88         }
  89         fmt.Fprintln(stderr, "created /var/lib/arvados/keep")
  90
  91         err = os.Mkdir("/etc/arvados", 0750)
  92         if err != nil && !os.IsExist(err) {
  93                 err = fmt.Errorf("mkdir /etc/arvados: %w", err)
  94                 return 1
  95         }
  96         err = os.Chown("/etc/arvados", 0, wwwgid)
  97         f, err := os.OpenFile("/etc/arvados/config.yml", os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0644)
  98         if err != nil {
  99                 err = fmt.Errorf("open /etc/arvados/config.yml: %w", err)
 100                 return 1
 101         }
 102         tmpl, err := template.New("config").Parse(`Clusters:
 103   {{.ClusterID}}:
 104     Services:
 105       Controller:
 106         InternalURLs:
 107           "http://0.0.0.0:8003/": {}
 108         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4430/" ) }}
 109       RailsAPI:
 110         InternalURLs:
 111           "http://0.0.0.0:8004/": {}
 112       Websocket:
 113         InternalURLs:
 114           "http://0.0.0.0:8005/": {}
 115         ExternalURL: {{printf "%q" ( print "wss://." .Domain ":4436/" ) }}
 116       Keepbalance:
 117         InternalURLs:
 118           "http://0.0.0.0:9005/": {}
 119       GitHTTP:
 120         InternalURLs:
 121           "http://0.0.0.0:9001/": {}
 122         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4437/" ) }}
 123       DispatchCloud:
 124         InternalURLs:
 125           "http://0.0.0.0:9006/": {}
 126       Keepproxy:
 127         InternalURLs:
 128           "http://0.0.0.0:25108/": {}
 129         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4438/" ) }}
 130       WebDAV:
 131         InternalURLs:
 132           "http://0.0.0.0:9002/": {}
 133         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4439/" ) }}
 134       WebDAVDownload:
 135         InternalURLs:
 136           "http://0.0.0.0:8004/": {}
 137         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4439/" ) }}
 138       Keepstore:
 139         InternalURLs:
 140           "http://0.0.0.0:25107/": {}
 141       Composer:
 142         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4440/composer" ) }}
 143       Workbench1:
 144         InternalURLs:
 145           "http://0.0.0.0:8001/": {}
 146         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4441/" ) }}
 147       Workbench2:
 148         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4442/" ) }}
 149       Health:
 150         InternalURLs:
 151           "http://0.0.0.0:9007/": {}
 152     Collections:
 153       BlobSigningKey: {{printf "%q" ( .RandomHex 50 )}}
 154     Containers:
 155       DispatchPrivateKey: {{printf "%q" .GenerateSSHPrivateKey}}
 156     ManagementToken: {{printf "%q" ( .RandomHex 50 )}}
 157     PostgreSQL:
 158       Connection:
 159         dbname: arvados_production
 160         host: localhost
 161         user: arvados
 162         password: {{printf "%q" .PostgreSQLPassword}}
 163     SystemRootToken: {{printf "%q" ( .RandomHex 50 )}}
 164     TLS:
 165       Insecure: true
 166     Volumes:
 167       {{.ClusterID}}-nyw5e-000000000000000:
 168         Driver: Directory
 169         DriverParameters:
 170           Root: /var/lib/arvados/keep
 171         Replication: 2
 172     Workbench:
 173       SecretKeyBase: {{printf "%q" ( .RandomHex 50 )}}
 174     Login:
 175       {{if eq .Login "pam"}}
 176       PAM:
 177         Enable: true
 178       {{else if eq .Login "test"}}
 179       Test:
 180         Enable: true
 181         Users:
 182           admin:
 183             Email: admin@example.com
 184             Password: admin
 185       {{else}}
 186       {}
 187       {{end}}
 188     Users:
 189       {{if eq .Login "test"}}
 190       AutoAdminUserWithEmail: admin@example.com
 191       {{else}}
 192       {}
 193       {{end}}
 194 `)
 195         if err != nil {
 196                 return 1
 197         }
 198         err = tmpl.Execute(f, initcmd)
 199         if err != nil {
 200                 err = fmt.Errorf("/etc/arvados/config.yml: tmpl.Execute: %w", err)
 201                 return 1
 202         }
 203         err = f.Close()
 204         if err != nil {
 205                 err = fmt.Errorf("/etc/arvados/config.yml: close: %w", err)
 206                 return 1
 207         }
 208         fmt.Fprintln(stderr, "created /etc/arvados/config.yml")
 209
 210         ldr := config.NewLoader(nil, logger)
 211         ldr.SkipLegacy = true
 212         cfg, err := ldr.Load()
 213         if err != nil {
 214                 err = fmt.Errorf("/etc/arvados/config.yml: %w", err)
 215                 return 1
 216         }
 217         cluster, err := cfg.GetCluster("")
 218         if err != nil {
 219                 return 1
 220         }
 221
 222         err = initcmd.createDB(ctx, cluster.PostgreSQL.Connection, stderr)
 223         if err != nil {
 224                 return 1
 225         }
 226
 227         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")
 228         cmd.Dir = "/var/lib/arvados/railsapi"
 229         cmd.Stdout = stderr
 230         cmd.Stderr = stderr
 231         err = cmd.Run()
 232         if err != nil {
 233                 err = fmt.Errorf("rake db:setup: %w", err)
 234                 return 1
 235         }
 236         fmt.Fprintln(stderr, "initialized database")
 237
 238         return 0
 239 }
 240
 241 func (initcmd *initCommand) GenerateSSHPrivateKey() (string, error) {
 242         privkey, err := rsa.GenerateKey(rand.Reader, 4096)
 243         if err != nil {
 244                 return "", err
 245         }
 246         err = privkey.Validate()
 247         if err != nil {
 248                 return "", err
 249         }
 250         return string(pem.EncodeToMemory(&pem.Block{
 251                 Type:  "RSA PRIVATE KEY",
 252                 Bytes: x509.MarshalPKCS1PrivateKey(privkey),
 253         })), nil
 254 }
 255
 256 func (initcmd *initCommand) RandomHex(chars int) string {
 257         b := make([]byte, chars/2)
 258         _, err := rand.Read(b)
 259         if err != nil {
 260                 panic(err)
 261         }
 262         return fmt.Sprintf("%x", b)
 263 }
 264
 265 func (initcmd *initCommand) createDB(ctx context.Context, dbconn arvados.PostgreSQLConnection, stderr io.Writer) error {
 266         for _, sql := range []string{
 267                 `CREATE USER ` + pq.QuoteIdentifier(dbconn["user"]) + ` WITH SUPERUSER ENCRYPTED PASSWORD ` + pq.QuoteLiteral(dbconn["password"]),
 268                 `CREATE DATABASE ` + pq.QuoteIdentifier(dbconn["dbname"]) + ` WITH TEMPLATE template0 ENCODING 'utf8'`,
 269                 `CREATE EXTENSION IF NOT EXISTS pg_trgm`,
 270         } {
 271                 cmd := exec.CommandContext(ctx, "sudo", "-u", "postgres", "psql", "-c", sql)
 272                 cmd.Stdout = stderr
 273                 cmd.Stderr = stderr
 274                 err := cmd.Run()
 275                 if err != nil {
 276                         return fmt.Errorf("error setting up arvados user/database: %w", err)
 277                 }
 278         }
 279         return nil
 280 }