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         "net"
  17         "net/http"
  18         "net/url"
  19         "os"
  20         "os/exec"
  21         "os/user"
  22         "regexp"
  23         "strconv"
  24         "strings"
  25         "sync/atomic"
  26         "text/template"
  27         "time"
  28
  29         "git.arvados.org/arvados.git/lib/cmd"
  30         "git.arvados.org/arvados.git/lib/config"
  31         "git.arvados.org/arvados.git/lib/controller/rpc"
  32         "git.arvados.org/arvados.git/sdk/go/arvados"
  33         "git.arvados.org/arvados.git/sdk/go/auth"
  34         "git.arvados.org/arvados.git/sdk/go/ctxlog"
  35         "github.com/lib/pq"
  36 )
  37
  38 var InitCommand cmd.Handler = &initCommand{}
  39
  40 type initCommand struct {
  41         ClusterID  string
  42         Domain     string
  43         CreateDB   bool
  44         Login      string
  45         TLS        string
  46         AdminEmail string
  47         Start      bool
  48
  49         PostgreSQL struct {
  50                 Host     string
  51                 User     string
  52                 Password string
  53                 DB       string
  54         }
  55         LoginPAM                bool
  56         LoginTest               bool
  57         LoginGoogle             bool
  58         LoginGoogleClientID     string
  59         LoginGoogleClientSecret string
  60         TLSDir                  string
  61 }
  62
  63 func (initcmd *initCommand) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
  64         logger := ctxlog.New(stderr, "text", "info")
  65         ctx := ctxlog.Context(context.Background(), logger)
  66         ctx, cancel := context.WithCancel(ctx)
  67         defer cancel()
  68
  69         var err error
  70         defer func() {
  71                 if err != nil {
  72                         logger.WithError(err).Info("exiting")
  73                 }
  74         }()
  75
  76         hostname, err := os.Hostname()
  77         if err != nil {
  78                 err = fmt.Errorf("Hostname(): %w", err)
  79                 return 1
  80         }
  81
  82         flags := flag.NewFlagSet(prog, flag.ContinueOnError)
  83         flags.SetOutput(stderr)
  84         versionFlag := flags.Bool("version", false, "Write version information to stdout and exit 0")
  85         flags.StringVar(&initcmd.ClusterID, "cluster-id", "", "cluster `id`, like x1234 for a dev cluster")
  86         flags.BoolVar(&initcmd.CreateDB, "create-db", true, "create an 'arvados' postgresql role and database using 'sudo -u postgres psql ...' (if false, use existing database specified by POSTGRES_HOST, POSTGRES_USER, POSTGRES_PASSWORD, and POSTGRES_DB env vars, and assume 'CREATE EXTENSION IF NOT EXISTS pg_trgm' has already been done)")
  87         flags.StringVar(&initcmd.Domain, "domain", hostname, "cluster public DNS `name`, like x1234.arvadosapi.com")
  88         flags.StringVar(&initcmd.Login, "login", "", "login `backend`: test, pam, 'google {client-id} {client-secret}', or ''")
  89         flags.StringVar(&initcmd.AdminEmail, "admin-email", "", "give admin privileges to user with given `email`")
  90         flags.StringVar(&initcmd.TLS, "tls", "none", "tls certificate `source`: acme, insecure, none, or /path/to/dir containing privkey and cert files")
  91         flags.BoolVar(&initcmd.Start, "start", true, "start systemd service after creating config")
  92         if ok, code := cmd.ParseFlags(flags, prog, args, "", stderr); !ok {
  93                 return code
  94         } else if *versionFlag {
  95                 return cmd.Version.RunCommand(prog, args, stdin, stdout, stderr)
  96         } else if !regexp.MustCompile(`^[a-z][a-z0-9]{4}`).MatchString(initcmd.ClusterID) {
  97                 err = fmt.Errorf("cluster ID %q is invalid; must be an ASCII letter followed by 4 alphanumerics (try -help)", initcmd.ClusterID)
  98                 return 1
  99         }
 100
 101         if fields := strings.Fields(initcmd.Login); len(fields) == 3 && fields[0] == "google" {
 102                 initcmd.LoginGoogle = true
 103                 initcmd.LoginGoogleClientID = fields[1]
 104                 initcmd.LoginGoogleClientSecret = fields[2]
 105         } else if initcmd.Login == "test" {
 106                 initcmd.LoginTest = true
 107                 if initcmd.AdminEmail == "" {
 108                         initcmd.AdminEmail = "admin@example.com"
 109                 }
 110         } else if initcmd.Login == "pam" {
 111                 initcmd.LoginPAM = true
 112         } else if initcmd.Login == "" {
 113                 // none; login will show an error page
 114         } else {
 115                 err = fmt.Errorf("invalid argument to -login: %q: should be 'test', 'pam', 'google {client-id} {client-secret}', or empty", initcmd.Login)
 116                 return 1
 117         }
 118
 119         switch initcmd.TLS {
 120         case "none", "acme", "insecure":
 121         default:
 122                 if !strings.HasPrefix(initcmd.TLS, "/") {
 123                         err = fmt.Errorf("invalid argument to -tls: %q; see %s -help", initcmd.TLS, prog)
 124                         return 1
 125                 }
 126                 initcmd.TLSDir = initcmd.TLS
 127         }
 128
 129         confdir := "/etc/arvados"
 130         conffile := confdir + "/config.yml"
 131         if _, err = os.Stat(conffile); err == nil {
 132                 err = fmt.Errorf("config file %s already exists; delete it first if you really want to start over", conffile)
 133                 return 1
 134         }
 135
 136         ports := []int{443}
 137         for i := 4440; i < 4460; i++ {
 138                 ports = append(ports, i)
 139         }
 140         if initcmd.TLS == "acme" {
 141                 ports = append(ports, 80)
 142         }
 143         for _, port := range ports {
 144                 err = initcmd.checkPort(ctx, fmt.Sprintf("%d", port))
 145                 if err != nil {
 146                         return 1
 147                 }
 148         }
 149
 150         if initcmd.CreateDB {
 151                 // Do the "create extension" thing early. This way, if
 152                 // there's no local postgresql server (a likely
 153                 // failure mode), we can bail out without any side
 154                 // effects, and the user can start over easily.
 155                 fmt.Fprintln(stderr, "installing pg_trgm postgresql extension...")
 156                 cmd := exec.CommandContext(ctx, "sudo", "-u", "postgres", "psql", "--quiet",
 157                         "-c", `CREATE EXTENSION IF NOT EXISTS pg_trgm`)
 158                 cmd.Dir = "/"
 159                 cmd.Stdout = stdout
 160                 cmd.Stderr = stderr
 161                 err = cmd.Run()
 162                 if err != nil {
 163                         err = fmt.Errorf("error preparing postgresql server: %w", err)
 164                         return 1
 165                 }
 166                 fmt.Fprintln(stderr, "...done")
 167                 initcmd.PostgreSQL.Host = "localhost"
 168                 initcmd.PostgreSQL.User = "arvados"
 169                 initcmd.PostgreSQL.Password = initcmd.RandomHex(32)
 170                 initcmd.PostgreSQL.DB = "arvados"
 171         } else {
 172                 initcmd.PostgreSQL.Host = os.Getenv("POSTGRES_HOST")
 173                 initcmd.PostgreSQL.User = os.Getenv("POSTGRES_USER")
 174                 initcmd.PostgreSQL.Password = os.Getenv("POSTGRES_PASSWORD")
 175                 initcmd.PostgreSQL.DB = os.Getenv("POSTGRES_DB")
 176                 if initcmd.PostgreSQL.Host == "" || initcmd.PostgreSQL.User == "" || initcmd.PostgreSQL.Password == "" || initcmd.PostgreSQL.DB == "" {
 177                         err = fmt.Errorf("missing $POSTGRES_* env var(s) for -create-db=false; see %s -help", prog)
 178                         return 1
 179                 }
 180         }
 181
 182         wwwuser, err := user.Lookup("www-data")
 183         if err != nil {
 184                 err = fmt.Errorf("user.Lookup(%q): %w", "www-data", err)
 185                 return 1
 186         }
 187         wwwgid, err := strconv.Atoi(wwwuser.Gid)
 188         if err != nil {
 189                 return 1
 190         }
 191
 192         fmt.Fprintln(stderr, "creating data storage directory /var/lib/arvados/keep ...")
 193         err = os.Mkdir("/var/lib/arvados/keep", 0600)
 194         if err != nil && !os.IsExist(err) {
 195                 err = fmt.Errorf("mkdir /var/lib/arvados/keep: %w", err)
 196                 return 1
 197         }
 198         fmt.Fprintln(stderr, "...done")
 199
 200         fmt.Fprintln(stderr, "creating config file", conffile, "...")
 201         err = os.Mkdir(confdir, 0750)
 202         if err != nil && !os.IsExist(err) {
 203                 err = fmt.Errorf("mkdir %s: %w", confdir, err)
 204                 return 1
 205         }
 206         err = os.Chown(confdir, 0, wwwgid)
 207         if err != nil {
 208                 err = fmt.Errorf("chown 0:%d %s: %w", wwwgid, confdir, err)
 209                 return 1
 210         }
 211         f, err := os.OpenFile(conffile+".tmp", os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0644)
 212         if err != nil {
 213                 err = fmt.Errorf("open %s: %w", conffile+".tmp", err)
 214                 return 1
 215         }
 216         tmpl, err := template.New("config").Parse(`Clusters:
 217   {{.ClusterID}}:
 218     Services:
 219       Controller:
 220         InternalURLs:
 221           "http://0.0.0.0:9000/": {}
 222         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4440/" ) }}
 223       RailsAPI:
 224         InternalURLs:
 225           "http://0.0.0.0:9001/": {}
 226       Websocket:
 227         InternalURLs:
 228           "http://0.0.0.0:8005/": {}
 229         ExternalURL: {{printf "%q" ( print "wss://" .Domain ":4446/" ) }}
 230       Keepbalance:
 231         InternalURLs:
 232           "http://0.0.0.0:9019/": {}
 233       GitHTTP:
 234         InternalURLs:
 235           "http://0.0.0.0:9005/": {}
 236         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4445/" ) }}
 237       DispatchCloud:
 238         InternalURLs:
 239           "http://0.0.0.0:9006/": {}
 240       Keepproxy:
 241         InternalURLs:
 242           "http://0.0.0.0:9007/": {}
 243         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4447/" ) }}
 244       WebDAV:
 245         InternalURLs:
 246           "http://0.0.0.0:9008/": {}
 247         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4448/" ) }}
 248       WebDAVDownload:
 249         InternalURLs:
 250           "http://0.0.0.0:9009/": {}
 251         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4449/" ) }}
 252       Keepstore:
 253         InternalURLs:
 254           "http://0.0.0.0:9010/": {}
 255       Composer:
 256         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4459/composer" ) }}
 257       Workbench1:
 258         InternalURLs:
 259           "http://0.0.0.0:9002/": {}
 260         ExternalURL: {{printf "%q" ( print "https://" .Domain ":4442/" ) }}
 261       Workbench2:
 262         InternalURLs:
 263           "http://0.0.0.0:9003/": {}
 264         ExternalURL: {{printf "%q" ( print "https://" .Domain "/" ) }}
 265       Health:
 266         InternalURLs:
 267           "http://0.0.0.0:9011/": {}
 268     Collections:
 269       BlobSigningKey: {{printf "%q" ( .RandomHex 50 )}}
 270       {{if eq .TLS "insecure"}}
 271       TrustAllContent: true
 272       {{end}}
 273     Containers:
 274       DispatchPrivateKey: {{printf "%q" .GenerateSSHPrivateKey}}
 275       CloudVMs:
 276         Enable: true
 277         Driver: loopback
 278     ManagementToken: {{printf "%q" ( .RandomHex 50 )}}
 279     PostgreSQL:
 280       Connection:
 281         dbname: {{printf "%q" .PostgreSQL.DB}}
 282         host: {{printf "%q" .PostgreSQL.Host}}
 283         user: {{printf "%q" .PostgreSQL.User}}
 284         password: {{printf "%q" .PostgreSQL.Password}}
 285     SystemRootToken: {{printf "%q" ( .RandomHex 50 )}}
 286     TLS:
 287       {{if eq .TLS "insecure"}}
 288       Insecure: true
 289       {{else if eq .TLS "acme"}}
 290       ACME:
 291         Server: LE
 292       {{else if ne .TLSDir ""}}
 293       Certificate: {{printf "%q" (print .TLSDir "/cert")}}
 294       Key: {{printf "%q" (print .TLSDir "/privkey")}}
 295       {{else}}
 296       {}
 297       {{end}}
 298     Volumes:
 299       {{.ClusterID}}-nyw5e-000000000000000:
 300         Driver: Directory
 301         DriverParameters:
 302           Root: /var/lib/arvados/keep
 303         Replication: 2
 304     Workbench:
 305       SecretKeyBase: {{printf "%q" ( .RandomHex 50 )}}
 306     {{if .LoginPAM}}
 307     Login:
 308       PAM:
 309         Enable: true
 310     {{else if .LoginTest}}
 311     Login:
 312       Test:
 313         Enable: true
 314         Users:
 315           admin:
 316             Email: {{printf "%q" .AdminEmail}}
 317             Password: admin
 318     {{else if .LoginGoogle}}
 319     Login:
 320       Google:
 321         Enable: true
 322         ClientID: {{printf "%q" .LoginGoogleClientID}}
 323         ClientSecret: {{printf "%q" .LoginGoogleClientSecret}}
 324     {{end}}
 325     Users:
 326       AutoAdminUserWithEmail: {{printf "%q" .AdminEmail}}
 327 `)
 328         if err != nil {
 329                 return 1
 330         }
 331         err = tmpl.Execute(f, initcmd)
 332         if err != nil {
 333                 err = fmt.Errorf("%s: tmpl.Execute: %w", conffile+".tmp", err)
 334                 return 1
 335         }
 336         err = f.Close()
 337         if err != nil {
 338                 err = fmt.Errorf("%s: close: %w", conffile+".tmp", err)
 339                 return 1
 340         }
 341         err = os.Rename(conffile+".tmp", conffile)
 342         if err != nil {
 343                 err = fmt.Errorf("rename %s -> %s: %w", conffile+".tmp", conffile, err)
 344                 return 1
 345         }
 346         fmt.Fprintln(stderr, "...done")
 347
 348         ldr := config.NewLoader(nil, logger)
 349         ldr.SkipLegacy = true
 350         ldr.Path = conffile // load the file we just wrote, even if $ARVADOS_CONFIG is set
 351         cfg, err := ldr.Load()
 352         if err != nil {
 353                 err = fmt.Errorf("%s: %w", conffile, err)
 354                 return 1
 355         }
 356         cluster, err := cfg.GetCluster("")
 357         if err != nil {
 358                 return 1
 359         }
 360
 361         fmt.Fprintln(stderr, "creating postresql user and database...")
 362         err = initcmd.createDB(ctx, cluster.PostgreSQL.Connection, stderr)
 363         if err != nil {
 364                 return 1
 365         }
 366         fmt.Fprintln(stderr, "...done")
 367
 368         fmt.Fprintln(stderr, "initializing database...")
 369         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")
 370         cmd.Dir = "/var/lib/arvados/railsapi"
 371         cmd.Stdout = stderr
 372         cmd.Stderr = stderr
 373         err = cmd.Run()
 374         if err != nil {
 375                 err = fmt.Errorf("rake db:setup failed: %w", err)
 376                 return 1
 377         }
 378         fmt.Fprintln(stderr, "...done")
 379
 380         if initcmd.Start {
 381                 fmt.Fprintln(stderr, "starting systemd service...")
 382                 cmd := exec.CommandContext(ctx, "systemctl", "start", "arvados")
 383                 cmd.Dir = "/"
 384                 cmd.Stdout = stderr
 385                 cmd.Stderr = stderr
 386                 err = cmd.Run()
 387                 if err != nil {
 388                         err = fmt.Errorf("%v: %w", cmd.Args, err)
 389                         return 1
 390                 }
 391                 fmt.Fprintln(stderr, "...done")
 392
 393                 fmt.Fprintln(stderr, "checking controller API endpoint...")
 394                 u := url.URL(cluster.Services.Controller.ExternalURL)
 395                 conn := rpc.NewConn(cluster.ClusterID, &u, cluster.TLS.Insecure, rpc.PassthroughTokenProvider)
 396                 ctx := auth.NewContext(context.Background(), auth.NewCredentials(cluster.SystemRootToken))
 397                 _, err = conn.UserGetCurrent(ctx, arvados.GetOptions{})
 398                 if err != nil {
 399                         err = fmt.Errorf("API request failed: %w", err)
 400                         return 1
 401                 }
 402                 fmt.Fprintln(stderr, "...looks good")
 403         }
 404
 405         if out, err := exec.CommandContext(ctx, "docker", "version").CombinedOutput(); err == nil && strings.Contains(string(out), "\nServer:\n") {
 406                 fmt.Fprintln(stderr, "loading alpine docker image for diagnostics...")
 407                 cmd := exec.CommandContext(ctx, "docker", "pull", "alpine")
 408                 cmd.Stdout = stderr
 409                 cmd.Stderr = stderr
 410                 err = cmd.Run()
 411                 if err != nil {
 412                         err = fmt.Errorf("%v: %w", cmd.Args, err)
 413                         return 1
 414                 }
 415                 cmd = exec.CommandContext(ctx, "arv", "sudo", "keep", "docker", "alpine")
 416                 cmd.Stdout = stderr
 417                 cmd.Stderr = stderr
 418                 err = cmd.Run()
 419                 if err != nil {
 420                         err = fmt.Errorf("%v: %w", cmd.Args, err)
 421                         return 1
 422                 }
 423                 fmt.Fprintln(stderr, "...done")
 424         } else {
 425                 fmt.Fprintln(stderr, "docker is not installed -- skipping step of downloading 'alpine' image")
 426         }
 427
 428         fmt.Fprintf(stderr, `
 429 Setup complete. Next steps:
 430 * run 'arv sudo diagnostics'
 431 * log in to workbench2 at %s
 432 * see documentation at https://doc.arvados.org/install/automatic.html
 433 `, cluster.Services.Workbench2.ExternalURL.String())
 434
 435         return 0
 436 }
 437
 438 func (initcmd *initCommand) GenerateSSHPrivateKey() (string, error) {
 439         privkey, err := rsa.GenerateKey(rand.Reader, 4096)
 440         if err != nil {
 441                 return "", err
 442         }
 443         err = privkey.Validate()
 444         if err != nil {
 445                 return "", err
 446         }
 447         return string(pem.EncodeToMemory(&pem.Block{
 448                 Type:  "RSA PRIVATE KEY",
 449                 Bytes: x509.MarshalPKCS1PrivateKey(privkey),
 450         })), nil
 451 }
 452
 453 func (initcmd *initCommand) RandomHex(chars int) string {
 454         b := make([]byte, chars/2)
 455         _, err := rand.Read(b)
 456         if err != nil {
 457                 panic(err)
 458         }
 459         return fmt.Sprintf("%x", b)
 460 }
 461
 462 func (initcmd *initCommand) createDB(ctx context.Context, dbconn arvados.PostgreSQLConnection, stderr io.Writer) error {
 463         cmd := exec.CommandContext(ctx, "sudo", "-u", "postgres", "psql", "--quiet",
 464                 "-c", `CREATE USER `+pq.QuoteIdentifier(dbconn["user"])+` WITH SUPERUSER ENCRYPTED PASSWORD `+pq.QuoteLiteral(dbconn["password"]),
 465                 "-c", `CREATE DATABASE `+pq.QuoteIdentifier(dbconn["dbname"])+` WITH TEMPLATE template0 ENCODING 'utf8'`,
 466         )
 467         cmd.Dir = "/"
 468         cmd.Stdout = stderr
 469         cmd.Stderr = stderr
 470         err := cmd.Run()
 471         if err != nil {
 472                 return fmt.Errorf("error setting up arvados user/database: %w", err)
 473         }
 474         return nil
 475 }
 476
 477 // Confirm that http://{initcmd.Domain}:{port} reaches a server that
 478 // we run on {port}.
 479 //
 480 // If port is "80", listening fails, and Nginx appears to be using the
 481 // debian-packaged default configuration that listens on port 80,
 482 // disable that Nginx config and try again.
 483 //
 484 // (Typically, the reason Nginx is installed is so that Arvados can
 485 // run an Nginx child process; the default Nginx service using config
 486 // from /etc/nginx is just an unfortunate side effect of installing
 487 // Nginx by way of the Debian package.)
 488 func (initcmd *initCommand) checkPort(ctx context.Context, port string) error {
 489         err := initcmd.checkPortOnce(ctx, port)
 490         if err == nil || port != "80" {
 491                 // success, or poking Nginx in the eye won't help
 492                 return err
 493         }
 494         d, err2 := os.Open("/etc/nginx/sites-enabled/.")
 495         if err2 != nil {
 496                 return err
 497         }
 498         fis, err2 := d.Readdir(-1)
 499         if err2 != nil || len(fis) != 1 {
 500                 return err
 501         }
 502         if target, err2 := os.Readlink("/etc/nginx/sites-enabled/default"); err2 != nil || target != "/etc/nginx/sites-available/default" {
 503                 return err
 504         }
 505         err2 = os.Remove("/etc/nginx/sites-enabled/default")
 506         if err2 != nil {
 507                 return err
 508         }
 509         exec.CommandContext(ctx, "nginx", "-s", "reload").Run()
 510         time.Sleep(time.Second)
 511         return initcmd.checkPortOnce(ctx, port)
 512 }
 513
 514 // Start an http server on 0.0.0.0:{port} and confirm that
 515 // http://{initcmd.Domain}:{port} reaches that server.
 516 func (initcmd *initCommand) checkPortOnce(ctx context.Context, port string) error {
 517         b := make([]byte, 128)
 518         _, err := rand.Read(b)
 519         if err != nil {
 520                 return err
 521         }
 522         token := fmt.Sprintf("%x", b)
 523
 524         srv := http.Server{
 525                 Addr: net.JoinHostPort("", port),
 526                 Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 527                         fmt.Fprint(w, token)
 528                 })}
 529         var errServe atomic.Value
 530         go func() {
 531                 errServe.Store(srv.ListenAndServe())
 532         }()
 533         defer srv.Close()
 534         url := "http://" + net.JoinHostPort(initcmd.Domain, port) + "/probe"
 535         req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
 536         if err != nil {
 537                 return err
 538         }
 539         resp, err := http.DefaultClient.Do(req)
 540         if err == nil {
 541                 defer resp.Body.Close()
 542         }
 543         if errServe, _ := errServe.Load().(error); errServe != nil {
 544                 // If server already exited, return that error
 545                 // (probably "can't listen"), not the request error.
 546                 return errServe
 547         }
 548         if err != nil {
 549                 return err
 550         }
 551         buf := make([]byte, len(token))
 552         n, err := io.ReadFull(resp.Body, buf)
 553         if string(buf[:n]) != token {
 554                 return fmt.Errorf("listened on port %s but %s connected to something else, returned %q, err %v", port, url, buf[:n], err)
 555         }
 556         return nil
 557 }