// Copyright (C) The Arvados Authors. All rights reserved. // // SPDX-License-Identifier: AGPL-3.0 package boot import ( "context" "errors" "flag" "fmt" "io" "sort" "time" "git.arvados.org/arvados.git/lib/cmd" "git.arvados.org/arvados.git/sdk/go/ctxlog" "github.com/coreos/go-systemd/daemon" ) var Command cmd.Handler = bootCommand{} type supervisedTask interface { // Execute the task. Run should return nil when the task is // done enough to satisfy a dependency relationship (e.g., the // service is running and ready). If the task starts a // goroutine that fails after Run returns (e.g., the service // shuts down), it should call fail(). Run(ctx context.Context, fail func(error), super *Supervisor) error String() string } var errNeedConfigReload = errors.New("config changed, restart needed") var errParseFlags = errors.New("error parsing command line arguments") type bootCommand struct{} func (bcmd bootCommand) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int { logger := ctxlog.New(stderr, "json", "info") ctx := ctxlog.Context(context.Background(), logger) for { err := bcmd.run(ctx, prog, args, stdin, stdout, stderr) if err == errNeedConfigReload { continue } else if err == errParseFlags { return 2 } else if err != nil { logger.WithError(err).Info("exiting") return 1 } else { return 0 } } } func (bcmd bootCommand) run(ctx context.Context, prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) error { ctx, cancel := context.WithCancel(ctx) defer cancel() super := &Supervisor{ Stdin: stdin, Stderr: stderr, logger: ctxlog.FromContext(ctx), } flags := flag.NewFlagSet(prog, flag.ContinueOnError) versionFlag := flags.Bool("version", false, "Write version information to stdout and exit 0") flags.StringVar(&super.ConfigPath, "config", "/etc/arvados/config.yml", "arvados config file `path`") flags.StringVar(&super.SourcePath, "source", ".", "arvados source tree `directory`") flags.StringVar(&super.ClusterType, "type", "production", "cluster `type`: development, test, or production") flags.StringVar(&super.ListenHost, "listen-host", "127.0.0.1", "host name or interface address for internal services whose InternalURLs are not configured") flags.StringVar(&super.ControllerAddr, "controller-address", ":0", "desired controller address, `host:port` or `:port`") flags.BoolVar(&super.NoWorkbench1, "no-workbench1", true, "do not run workbench1") flags.BoolVar(&super.NoWorkbench2, "no-workbench2", false, "do not run workbench2") flags.BoolVar(&super.OwnTemporaryDatabase, "own-temporary-database", false, "bring up a postgres server and create a temporary database") timeout := flags.Duration("timeout", 0, "maximum time to wait for cluster to be ready") shutdown := flags.Bool("shutdown", false, "shut down when the cluster becomes ready") if ok, code := cmd.ParseFlags(flags, prog, args, "", stderr); !ok { if code == 0 { return nil } else { return errParseFlags } } else if *versionFlag { cmd.Version.RunCommand(prog, args, stdin, stdout, stderr) return nil } else if super.ClusterType != "development" && super.ClusterType != "test" && super.ClusterType != "production" { return fmt.Errorf("cluster type must be 'development', 'test', or 'production'") } super.Start(ctx) defer super.Stop() var timer *time.Timer if *timeout > 0 { timer = time.AfterFunc(*timeout, super.Stop) } ok := super.WaitReady() if timer != nil && !timer.Stop() { return errors.New("boot timed out") } else if !ok { super.logger.Error("boot failed") } else { // Write each cluster's controller URL, id, and URL // host:port to stdout. Nothing else goes to stdout, // so this allows a calling script to determine when // the cluster is ready to use, and the controller's // host:port (which may have been dynamically assigned // depending on config/options). // // Sort output by cluster ID for convenience. var ids []string for id := range super.Clusters() { ids = append(ids, id) } sort.Strings(ids) for _, id := range ids { cc := super.Cluster(id) // Providing both scheme://host:port and // host:port is redundant, but convenient. fmt.Fprintln(stdout, cc.Services.Controller.ExternalURL, id, cc.Services.Controller.ExternalURL.Host) } // Write ".\n" to mark the end of the list of // controllers, in case the caller doesn't already // know how many clusters are coming up. fmt.Fprintln(stdout, ".") if *shutdown { super.Stop() // Wait for children to exit. Don't report the // ensuing "context cancelled" error, though: // return nil to indicate successful startup. _ = super.Wait() fmt.Fprintln(stderr, "PASS - all services booted successfully") return nil } } if _, err := daemon.SdNotify(false, "READY=1"); err != nil { super.logger.WithError(err).Errorf("error notifying init daemon") } // Wait for signal/crash + orderly shutdown return super.Wait() }