1 // Copyright (C) The Arvados Authors. All rights reserved.
3 // SPDX-License-Identifier: AGPL-3.0
25 "git.arvados.org/arvados.git/lib/cmd"
26 "git.arvados.org/arvados.git/lib/config"
27 "git.arvados.org/arvados.git/lib/controller/rpc"
28 "git.arvados.org/arvados.git/sdk/go/arvados"
29 "git.arvados.org/arvados.git/sdk/go/auth"
30 "git.arvados.org/arvados.git/sdk/go/ctxlog"
34 var InitCommand cmd.Handler = &initCommand{}
36 type initCommand struct {
39 PostgreSQLPassword string
48 LoginGoogleClientID string
49 LoginGoogleClientSecret string
52 func (initcmd *initCommand) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
53 logger := ctxlog.New(stderr, "text", "info")
54 ctx := ctxlog.Context(context.Background(), logger)
55 ctx, cancel := context.WithCancel(ctx)
61 logger.WithError(err).Info("exiting")
65 hostname, err := os.Hostname()
67 err = fmt.Errorf("Hostname(): %w", err)
71 flags := flag.NewFlagSet(prog, flag.ContinueOnError)
72 flags.SetOutput(stderr)
73 versionFlag := flags.Bool("version", false, "Write version information to stdout and exit 0")
74 flags.StringVar(&initcmd.ClusterID, "cluster-id", "", "cluster `id`, like x1234 for a dev cluster")
75 flags.StringVar(&initcmd.Domain, "domain", hostname, "cluster public DNS `name`, like x1234.arvadosapi.com")
76 flags.StringVar(&initcmd.Login, "login", "", "login `backend`: test, pam, 'google {client-id} {client-secret}', or ''")
77 flags.StringVar(&initcmd.AdminEmail, "admin-email", "", "give admin privileges to user with given `email`")
78 flags.StringVar(&initcmd.TLS, "tls", "none", "tls certificate `source`: acme, auto, insecure, or none")
79 flags.BoolVar(&initcmd.Start, "start", true, "start systemd service after creating config")
80 if ok, code := cmd.ParseFlags(flags, prog, args, "", stderr); !ok {
82 } else if *versionFlag {
83 return cmd.Version.RunCommand(prog, args, stdin, stdout, stderr)
84 } else if !regexp.MustCompile(`^[a-z][a-z0-9]{4}`).MatchString(initcmd.ClusterID) {
85 err = fmt.Errorf("cluster ID %q is invalid; must be an ASCII letter followed by 4 alphanumerics (try -help)", initcmd.ClusterID)
89 if fields := strings.Fields(initcmd.Login); len(fields) == 3 && fields[0] == "google" {
90 initcmd.LoginGoogle = true
91 initcmd.LoginGoogleClientID = fields[1]
92 initcmd.LoginGoogleClientSecret = fields[2]
93 } else if initcmd.Login == "test" {
94 initcmd.LoginTest = true
95 if initcmd.AdminEmail == "" {
96 initcmd.AdminEmail = "admin@example.com"
98 } else if initcmd.Login == "pam" {
99 initcmd.LoginPAM = true
100 } else if initcmd.Login == "" {
101 // none; login will show an error page
103 err = fmt.Errorf("invalid argument to -login: %q: should be 'test', 'pam', 'google {client-id} {client-secret}', or empty", initcmd.Login)
107 confdir := "/etc/arvados"
108 conffile := confdir + "/config.yml"
109 if _, err = os.Stat(conffile); err == nil {
110 err = fmt.Errorf("config file %s already exists; delete it first if you really want to start over", conffile)
114 // Do the "create extension" thing early. This way, if there's
115 // no local postgresql server (a likely failure mode), we can
116 // bail out without any side effects, and the user can start
118 fmt.Fprintln(stderr, "installing pg_trgm postgresql extension...")
119 cmd := exec.CommandContext(ctx, "sudo", "-u", "postgres", "psql", "--quiet",
120 "-c", `CREATE EXTENSION IF NOT EXISTS pg_trgm`)
126 err = fmt.Errorf("error preparing postgresql server: %w", err)
129 fmt.Fprintln(stderr, "...done")
131 wwwuser, err := user.Lookup("www-data")
133 err = fmt.Errorf("user.Lookup(%q): %w", "www-data", err)
136 wwwgid, err := strconv.Atoi(wwwuser.Gid)
140 initcmd.PostgreSQLPassword = initcmd.RandomHex(32)
142 fmt.Fprintln(stderr, "creating data storage directory /var/lib/arvados/keep ...")
143 err = os.Mkdir("/var/lib/arvados/keep", 0600)
144 if err != nil && !os.IsExist(err) {
145 err = fmt.Errorf("mkdir /var/lib/arvados/keep: %w", err)
148 fmt.Fprintln(stderr, "...done")
150 fmt.Fprintln(stderr, "creating config file", conffile, "...")
151 err = os.Mkdir(confdir, 0750)
152 if err != nil && !os.IsExist(err) {
153 err = fmt.Errorf("mkdir %s: %w", confdir, err)
156 err = os.Chown(confdir, 0, wwwgid)
158 err = fmt.Errorf("chown 0:%d %s: %w", wwwgid, confdir, err)
161 f, err := os.OpenFile(conffile+".tmp", os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0644)
163 err = fmt.Errorf("open %s: %w", conffile+".tmp", err)
166 tmpl, err := template.New("config").Parse(`Clusters:
171 "http://0.0.0.0:9000/": {}
172 ExternalURL: {{printf "%q" ( print "https://" .Domain ":4440/" ) }}
175 "http://0.0.0.0:9001/": {}
178 "http://0.0.0.0:8005/": {}
179 ExternalURL: {{printf "%q" ( print "wss://" .Domain ":4446/" ) }}
182 "http://0.0.0.0:9019/": {}
185 "http://0.0.0.0:9005/": {}
186 ExternalURL: {{printf "%q" ( print "https://" .Domain ":4445/" ) }}
189 "http://0.0.0.0:9006/": {}
192 "http://0.0.0.0:9007/": {}
193 ExternalURL: {{printf "%q" ( print "https://" .Domain ":4447/" ) }}
196 "http://0.0.0.0:9008/": {}
197 ExternalURL: {{printf "%q" ( print "https://" .Domain ":4448/" ) }}
200 "http://0.0.0.0:9009/": {}
201 ExternalURL: {{printf "%q" ( print "https://" .Domain ":4449/" ) }}
204 "http://0.0.0.0:9010/": {}
206 ExternalURL: {{printf "%q" ( print "https://" .Domain ":4459/composer" ) }}
209 "http://0.0.0.0:9002/": {}
210 ExternalURL: {{printf "%q" ( print "https://" .Domain ":4442/" ) }}
213 "http://0.0.0.0:9003/": {}
214 ExternalURL: {{printf "%q" ( print "https://" .Domain "/" ) }}
217 "http://0.0.0.0:9011/": {}
219 BlobSigningKey: {{printf "%q" ( .RandomHex 50 )}}
220 {{if eq .TLS "insecure"}}
221 TrustAllContent: true
224 DispatchPrivateKey: {{printf "%q" .GenerateSSHPrivateKey}}
228 ManagementToken: {{printf "%q" ( .RandomHex 50 )}}
234 password: {{printf "%q" .PostgreSQLPassword}}
235 SystemRootToken: {{printf "%q" ( .RandomHex 50 )}}
237 {{if eq .TLS "insecure"}}
239 {{else if eq .TLS "auto"}}
241 {{else if eq .TLS "acme"}}
242 Certificate: {{printf "%q" (print "/var/lib/acme/live/" .Domain "/cert")}}
243 Key: {{printf "%q" (print "/var/lib/acme/live/" .Domain "/privkey")}}
248 {{.ClusterID}}-nyw5e-000000000000000:
251 Root: /var/lib/arvados/keep
254 SecretKeyBase: {{printf "%q" ( .RandomHex 50 )}}
259 {{else if .LoginTest}}
265 Email: {{printf "%q" .AdminEmail}}
267 {{else if .LoginGoogle}}
271 ClientID: {{printf "%q" .LoginGoogleClientID}}
272 ClientSecret: {{printf "%q" .LoginGoogleClientSecret}}
275 AutoAdminUserWithEmail: {{printf "%q" .AdminEmail}}
280 err = tmpl.Execute(f, initcmd)
282 err = fmt.Errorf("%s: tmpl.Execute: %w", conffile+".tmp", err)
287 err = fmt.Errorf("%s: close: %w", conffile+".tmp", err)
290 err = os.Rename(conffile+".tmp", conffile)
292 err = fmt.Errorf("rename %s -> %s: %w", conffile+".tmp", conffile, err)
295 fmt.Fprintln(stderr, "...done")
297 ldr := config.NewLoader(nil, logger)
298 ldr.SkipLegacy = true
299 ldr.Path = conffile // load the file we just wrote, even if $ARVADOS_CONFIG is set
300 cfg, err := ldr.Load()
302 err = fmt.Errorf("%s: %w", conffile, err)
305 cluster, err := cfg.GetCluster("")
310 fmt.Fprintln(stderr, "creating postresql user and database...")
311 err = initcmd.createDB(ctx, cluster.PostgreSQL.Connection, stderr)
315 fmt.Fprintln(stderr, "...done")
317 fmt.Fprintln(stderr, "initializing database...")
318 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")
319 cmd.Dir = "/var/lib/arvados/railsapi"
324 err = fmt.Errorf("rake db:setup failed: %w", err)
327 fmt.Fprintln(stderr, "...done")
330 fmt.Fprintln(stderr, "starting systemd service...")
331 cmd := exec.CommandContext(ctx, "systemctl", "start", "arvados")
337 err = fmt.Errorf("%v: %w", cmd.Args, err)
340 fmt.Fprintln(stderr, "...done")
342 fmt.Fprintln(stderr, "checking controller API endpoint...")
343 u := url.URL(cluster.Services.Controller.ExternalURL)
344 conn := rpc.NewConn(cluster.ClusterID, &u, cluster.TLS.Insecure, rpc.PassthroughTokenProvider)
345 ctx := auth.NewContext(context.Background(), auth.NewCredentials(cluster.SystemRootToken))
346 _, err = conn.UserGetCurrent(ctx, arvados.GetOptions{})
348 err = fmt.Errorf("API request failed: %w", err)
351 fmt.Fprintln(stderr, "...looks good")
354 fmt.Fprintln(stderr, "Setup complete. You should now be able to log in to workbench2 at", cluster.Services.Workbench2.ExternalURL.String())
359 func (initcmd *initCommand) GenerateSSHPrivateKey() (string, error) {
360 privkey, err := rsa.GenerateKey(rand.Reader, 4096)
364 err = privkey.Validate()
368 return string(pem.EncodeToMemory(&pem.Block{
369 Type: "RSA PRIVATE KEY",
370 Bytes: x509.MarshalPKCS1PrivateKey(privkey),
374 func (initcmd *initCommand) RandomHex(chars int) string {
375 b := make([]byte, chars/2)
376 _, err := rand.Read(b)
380 return fmt.Sprintf("%x", b)
383 func (initcmd *initCommand) createDB(ctx context.Context, dbconn arvados.PostgreSQLConnection, stderr io.Writer) error {
384 cmd := exec.CommandContext(ctx, "sudo", "-u", "postgres", "psql", "--quiet",
385 "-c", `CREATE USER `+pq.QuoteIdentifier(dbconn["user"])+` WITH SUPERUSER ENCRYPTED PASSWORD `+pq.QuoteLiteral(dbconn["password"]),
386 "-c", `CREATE DATABASE `+pq.QuoteIdentifier(dbconn["dbname"])+` WITH TEMPLATE template0 ENCODING 'utf8'`,
393 return fmt.Errorf("error setting up arvados user/database: %w", err)