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