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.curoverse.com/arvados.git/sdk/go/ctxlog"
  16         "github.com/ghodss/yaml"
  17         "github.com/sirupsen/logrus"
  18 )
  19
  20 var DumpCommand dumpCommand
  21
  22 type dumpCommand struct{}
  23
  24 func (dumpCommand) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
  25         var err error
  26         defer func() {
  27                 if err != nil {
  28                         fmt.Fprintf(stderr, "%s\n", err)
  29                 }
  30         }()
  31
  32         loader := &Loader{
  33                 Stdin:  stdin,
  34                 Logger: ctxlog.New(stderr, "text", "info"),
  35         }
  36
  37         flags := flag.NewFlagSet("", flag.ContinueOnError)
  38         flags.SetOutput(stderr)
  39         loader.SetupFlags(flags)
  40
  41         err = flags.Parse(args)
  42         if err == flag.ErrHelp {
  43                 err = nil
  44                 return 0
  45         } else if err != nil {
  46                 return 2
  47         }
  48
  49         if len(flags.Args()) != 0 {
  50                 flags.Usage()
  51                 return 2
  52         }
  53
  54         cfg, err := loader.Load()
  55         if err != nil {
  56                 return 1
  57         }
  58         out, err := yaml.Marshal(cfg)
  59         if err != nil {
  60                 return 1
  61         }
  62         _, err = stdout.Write(out)
  63         if err != nil {
  64                 return 1
  65         }
  66         return 0
  67 }
  68
  69 var CheckCommand checkCommand
  70
  71 type checkCommand struct{}
  72
  73 func (checkCommand) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
  74         var err error
  75         var logbuf = &bytes.Buffer{}
  76         defer func() {
  77                 io.Copy(stderr, logbuf)
  78                 if err != nil {
  79                         fmt.Fprintf(stderr, "%s\n", err)
  80                 }
  81         }()
  82
  83         logger := logrus.New()
  84         logger.Out = logbuf
  85         loader := &Loader{
  86                 Stdin:  stdin,
  87                 Logger: logger,
  88         }
  89
  90         flags := flag.NewFlagSet("", flag.ContinueOnError)
  91         flags.SetOutput(stderr)
  92         loader.SetupFlags(flags)
  93
  94         err = flags.Parse(args)
  95         if err == flag.ErrHelp {
  96                 err = nil
  97                 return 0
  98         } else if err != nil {
  99                 return 2
 100         }
 101
 102         if len(flags.Args()) != 0 {
 103                 flags.Usage()
 104                 return 2
 105         }
 106
 107         // Load the config twice -- once without loading deprecated
 108         // keys/files, once with -- and then compare the two resulting
 109         // configs. This reveals whether the deprecated keys/files
 110         // have any effect on the final configuration.
 111         //
 112         // If they do, show the operator how to update their config
 113         // such that the deprecated keys/files are superfluous and can
 114         // be deleted.
 115         loader.SkipDeprecated = true
 116         withoutDepr, err := loader.Load()
 117         if err != nil {
 118                 return 1
 119         }
 120         loader.SkipDeprecated = false
 121         withDepr, err := loader.Load()
 122         if err != nil {
 123                 return 1
 124         }
 125         cmd := exec.Command("diff", "-u", "--label", "without-deprecated-configs", "--label", "relying-on-deprecated-configs", "/dev/fd/3", "/dev/fd/4")
 126         for _, obj := range []interface{}{withoutDepr, withDepr} {
 127                 y, _ := yaml.Marshal(obj)
 128                 pr, pw, err := os.Pipe()
 129                 if err != nil {
 130                         return 1
 131                 }
 132                 defer pr.Close()
 133                 go func() {
 134                         io.Copy(pw, bytes.NewBuffer(y))
 135                         pw.Close()
 136                 }()
 137                 cmd.ExtraFiles = append(cmd.ExtraFiles, pr)
 138         }
 139         diff, err := cmd.CombinedOutput()
 140         if bytes.HasPrefix(diff, []byte("--- ")) {
 141                 fmt.Fprintln(stdout, "Your configuration is relying on deprecated entries. Suggest making the following changes.")
 142                 stdout.Write(diff)
 143                 err = nil
 144                 return 1
 145         } else if len(diff) > 0 {
 146                 fmt.Fprintf(stderr, "Unexpected diff output:\n%s", diff)
 147                 return 1
 148         } else if err != nil {
 149                 return 1
 150         }
 151         if logbuf.Len() > 0 {
 152                 return 1
 153         }
 154         return 0
 155 }
 156
 157 var DumpDefaultsCommand defaultsCommand
 158
 159 type defaultsCommand struct{}
 160
 161 func (defaultsCommand) RunCommand(prog string, args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 162         _, err := stdout.Write(DefaultYAML)
 163         if err != nil {
 164                 fmt.Fprintln(stderr, err)
 165                 return 1
 166         }
 167         return 0
 168 }