lib/config/cmd.go

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 package config
   6
   7 import (
   8         "bytes"
   9         "flag"
  10         "fmt"
  11         "io"
  12         "os"
  13         "os/exec"
  14
  15         "git.arvados.org/arvados.git/sdk/go/arvados"
  16         "git.arvados.org/arvados.git/sdk/go/ctxlog"
  17         "github.com/ghodss/yaml"
  18         "github.com/sirupsen/logrus"
  19 )
  20
  21 var DumpCommand dumpCommand
  22
  23 type dumpCommand struct{}
  24
  25 func (dumpCommand) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
  26         var err error
  27         defer func() {
  28                 if err != nil {
  29                         fmt.Fprintf(stderr, "%s\n", err)
  30                 }
  31         }()
  32
  33         loader := &Loader{
  34                 Stdin:  stdin,
  35                 Logger: ctxlog.New(stderr, "text", "info"),
  36         }
  37
  38         flags := flag.NewFlagSet("", flag.ContinueOnError)
  39         flags.SetOutput(stderr)
  40         loader.SetupFlags(flags)
  41
  42         err = flags.Parse(args)
  43         if err == flag.ErrHelp {
  44                 err = nil
  45                 return 0
  46         } else if err != nil {
  47                 return 2
  48         }
  49
  50         if len(flags.Args()) != 0 {
  51                 flags.Usage()
  52                 return 2
  53         }
  54
  55         cfg, err := loader.Load()
  56         if err != nil {
  57                 return 1
  58         }
  59         out, err := yaml.Marshal(cfg)
  60         if err != nil {
  61                 return 1
  62         }
  63         _, err = stdout.Write(out)
  64         if err != nil {
  65                 return 1
  66         }
  67         return 0
  68 }
  69
  70 var CheckCommand checkCommand
  71
  72 type checkCommand struct{}
  73
  74 func (checkCommand) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
  75         var err error
  76         var logbuf = &bytes.Buffer{}
  77         defer func() {
  78                 io.Copy(stderr, logbuf)
  79                 if err != nil {
  80                         fmt.Fprintf(stderr, "%s\n", err)
  81                 }
  82         }()
  83
  84         logger := logrus.New()
  85         logger.Out = logbuf
  86         loader := &Loader{
  87                 Stdin:  stdin,
  88                 Logger: logger,
  89         }
  90
  91         flags := flag.NewFlagSet("", flag.ContinueOnError)
  92         flags.SetOutput(stderr)
  93         loader.SetupFlags(flags)
  94
  95         err = flags.Parse(args)
  96         if err == flag.ErrHelp {
  97                 err = nil
  98                 return 0
  99         } else if err != nil {
 100                 return 2
 101         }
 102
 103         if len(flags.Args()) != 0 {
 104                 flags.Usage()
 105                 return 2
 106         }
 107
 108         // Load the config twice -- once without loading deprecated
 109         // keys/files, once with -- and then compare the two resulting
 110         // configs. This reveals whether the deprecated keys/files
 111         // have any effect on the final configuration.
 112         //
 113         // If they do, show the operator how to update their config
 114         // such that the deprecated keys/files are superfluous and can
 115         // be deleted.
 116         loader.SkipDeprecated = true
 117         loader.SkipLegacy = true
 118         withoutDepr, err := loader.Load()
 119         if err != nil {
 120                 return 1
 121         }
 122         loader.SkipDeprecated = false
 123         loader.SkipLegacy = false
 124         withDepr, err := loader.Load()
 125         if err != nil {
 126                 return 1
 127         }
 128         problems := false
 129         if warnAboutProblems(logger, withDepr) {
 130                 problems = true
 131         }
 132         cmd := exec.Command("diff", "-u", "--label", "without-deprecated-configs", "--label", "relying-on-deprecated-configs", "/dev/fd/3", "/dev/fd/4")
 133         for _, obj := range []interface{}{withoutDepr, withDepr} {
 134                 y, _ := yaml.Marshal(obj)
 135                 pr, pw, err := os.Pipe()
 136                 if err != nil {
 137                         return 1
 138                 }
 139                 defer pr.Close()
 140                 go func() {
 141                         io.Copy(pw, bytes.NewBuffer(y))
 142                         pw.Close()
 143                 }()
 144                 cmd.ExtraFiles = append(cmd.ExtraFiles, pr)
 145         }
 146         diff, err := cmd.CombinedOutput()
 147         if bytes.HasPrefix(diff, []byte("--- ")) {
 148                 fmt.Fprintln(stdout, "Your configuration is relying on deprecated entries. Suggest making the following changes.")
 149                 stdout.Write(diff)
 150                 err = nil
 151                 return 1
 152         } else if len(diff) > 0 {
 153                 fmt.Fprintf(stderr, "Unexpected diff output:\n%s", diff)
 154                 return 1
 155         } else if err != nil {
 156                 return 1
 157         }
 158         if logbuf.Len() > 0 {
 159                 return 1
 160         }
 161
 162         if problems {
 163                 return 1
 164         }
 165         return 0
 166 }
 167
 168 func warnAboutProblems(logger logrus.FieldLogger, cfg *arvados.Config) bool {
 169         warned := false
 170         for id, cc := range cfg.Clusters {
 171                 if cc.SystemRootToken == "" {
 172                         logger.Warnf("Clusters.%s.SystemRootToken is empty; see https://doc.arvados.org/master/install/install-keepstore.html", id)
 173                         warned = true
 174                 }
 175                 if cc.ManagementToken == "" {
 176                         logger.Warnf("Clusters.%s.ManagementToken is empty; see https://doc.arvados.org/admin/management-token.html", id)
 177                         warned = true
 178                 }
 179         }
 180         return warned
 181 }
 182
 183 var DumpDefaultsCommand defaultsCommand
 184
 185 type defaultsCommand struct{}
 186
 187 func (defaultsCommand) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 188         _, err := stdout.Write(DefaultYAML)
 189         if err != nil {
 190                 fmt.Fprintln(stderr, err)
 191                 return 1
 192         }
 193         return 0
 194 }