Merge branch '16470-api-rails-52'
[arvados.git] / lib / config / load_test.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         "fmt"
10         "io"
11         "io/ioutil"
12         "os"
13         "os/exec"
14         "reflect"
15         "strings"
16         "testing"
17
18         "git.arvados.org/arvados.git/sdk/go/arvados"
19         "git.arvados.org/arvados.git/sdk/go/ctxlog"
20         "github.com/ghodss/yaml"
21         "github.com/sirupsen/logrus"
22         check "gopkg.in/check.v1"
23 )
24
25 // Gocheck boilerplate
26 func Test(t *testing.T) {
27         check.TestingT(t)
28 }
29
30 var _ = check.Suite(&LoadSuite{})
31
32 // Return a new Loader that reads cluster config from configdata
33 // (instead of the usual default /etc/arvados/config.yml), and logs to
34 // logdst or (if that's nil) c.Log.
35 func testLoader(c *check.C, configdata string, logdst io.Writer) *Loader {
36         logger := ctxlog.TestLogger(c)
37         if logdst != nil {
38                 lgr := logrus.New()
39                 lgr.Out = logdst
40                 logger = lgr
41         }
42         ldr := NewLoader(bytes.NewBufferString(configdata), logger)
43         ldr.Path = "-"
44         return ldr
45 }
46
47 type LoadSuite struct{}
48
49 func (s *LoadSuite) SetUpSuite(c *check.C) {
50         os.Unsetenv("ARVADOS_API_HOST")
51         os.Unsetenv("ARVADOS_API_HOST_INSECURE")
52         os.Unsetenv("ARVADOS_API_TOKEN")
53 }
54
55 func (s *LoadSuite) TestEmpty(c *check.C) {
56         cfg, err := testLoader(c, "", nil).Load()
57         c.Check(cfg, check.IsNil)
58         c.Assert(err, check.ErrorMatches, `config does not define any clusters`)
59 }
60
61 func (s *LoadSuite) TestNoConfigs(c *check.C) {
62         cfg, err := testLoader(c, `Clusters: {"z1111": {}}`, nil).Load()
63         c.Assert(err, check.IsNil)
64         c.Assert(cfg.Clusters, check.HasLen, 1)
65         cc, err := cfg.GetCluster("z1111")
66         c.Assert(err, check.IsNil)
67         c.Check(cc.ClusterID, check.Equals, "z1111")
68         c.Check(cc.API.MaxRequestAmplification, check.Equals, 4)
69         c.Check(cc.API.MaxItemsPerResponse, check.Equals, 1000)
70 }
71
72 func (s *LoadSuite) TestMungeLegacyConfigArgs(c *check.C) {
73         f, err := ioutil.TempFile("", "")
74         c.Check(err, check.IsNil)
75         defer os.Remove(f.Name())
76         io.WriteString(f, "Debug: true\n")
77         oldfile := f.Name()
78
79         f, err = ioutil.TempFile("", "")
80         c.Check(err, check.IsNil)
81         defer os.Remove(f.Name())
82         io.WriteString(f, "Clusters: {aaaaa: {}}\n")
83         newfile := f.Name()
84
85         for _, trial := range []struct {
86                 argsIn  []string
87                 argsOut []string
88         }{
89                 {
90                         []string{"-config", oldfile},
91                         []string{"-old-config", oldfile},
92                 },
93                 {
94                         []string{"-config=" + oldfile},
95                         []string{"-old-config=" + oldfile},
96                 },
97                 {
98                         []string{"-config", newfile},
99                         []string{"-config", newfile},
100                 },
101                 {
102                         []string{"-config=" + newfile},
103                         []string{"-config=" + newfile},
104                 },
105                 {
106                         []string{"-foo", oldfile},
107                         []string{"-foo", oldfile},
108                 },
109                 {
110                         []string{"-foo=" + oldfile},
111                         []string{"-foo=" + oldfile},
112                 },
113                 {
114                         []string{"-foo", "-config=" + oldfile},
115                         []string{"-foo", "-old-config=" + oldfile},
116                 },
117                 {
118                         []string{"-foo", "bar", "-config=" + oldfile},
119                         []string{"-foo", "bar", "-old-config=" + oldfile},
120                 },
121                 {
122                         []string{"-foo=bar", "baz", "-config=" + oldfile},
123                         []string{"-foo=bar", "baz", "-old-config=" + oldfile},
124                 },
125                 {
126                         []string{"-config=/dev/null"},
127                         []string{"-config=/dev/null"},
128                 },
129                 {
130                         []string{"-config=-"},
131                         []string{"-config=-"},
132                 },
133                 {
134                         []string{"-config="},
135                         []string{"-config="},
136                 },
137                 {
138                         []string{"-foo=bar", "baz", "-config"},
139                         []string{"-foo=bar", "baz", "-config"},
140                 },
141                 {
142                         []string{},
143                         nil,
144                 },
145         } {
146                 var logbuf bytes.Buffer
147                 logger := logrus.New()
148                 logger.Out = &logbuf
149
150                 var ldr Loader
151                 args := ldr.MungeLegacyConfigArgs(logger, trial.argsIn, "-old-config")
152                 c.Check(args, check.DeepEquals, trial.argsOut)
153                 if fmt.Sprintf("%v", trial.argsIn) != fmt.Sprintf("%v", trial.argsOut) {
154                         c.Check(logbuf.String(), check.Matches, `.*`+oldfile+` is not a cluster config file -- interpreting -config as -old-config.*\n`)
155                 }
156         }
157 }
158
159 func (s *LoadSuite) TestSampleKeys(c *check.C) {
160         for _, yaml := range []string{
161                 `{"Clusters":{"z1111":{}}}`,
162                 `{"Clusters":{"z1111":{"InstanceTypes":{"Foo":{"RAM": "12345M"}}}}}`,
163         } {
164                 cfg, err := testLoader(c, yaml, nil).Load()
165                 c.Assert(err, check.IsNil)
166                 cc, err := cfg.GetCluster("z1111")
167                 c.Assert(err, check.IsNil)
168                 _, hasSample := cc.InstanceTypes["SAMPLE"]
169                 c.Check(hasSample, check.Equals, false)
170                 if strings.Contains(yaml, "Foo") {
171                         c.Check(cc.InstanceTypes["Foo"].RAM, check.Equals, arvados.ByteSize(12345000000))
172                         c.Check(cc.InstanceTypes["Foo"].Price, check.Equals, 0.0)
173                 }
174         }
175 }
176
177 func (s *LoadSuite) TestMultipleClusters(c *check.C) {
178         ldr := testLoader(c, `{"Clusters":{"z1111":{},"z2222":{}}}`, nil)
179         ldr.SkipDeprecated = true
180         cfg, err := ldr.Load()
181         c.Assert(err, check.IsNil)
182         c1, err := cfg.GetCluster("z1111")
183         c.Assert(err, check.IsNil)
184         c.Check(c1.ClusterID, check.Equals, "z1111")
185         c2, err := cfg.GetCluster("z2222")
186         c.Assert(err, check.IsNil)
187         c.Check(c2.ClusterID, check.Equals, "z2222")
188 }
189
190 func (s *LoadSuite) TestDeprecatedOrUnknownWarning(c *check.C) {
191         var logbuf bytes.Buffer
192         _, err := testLoader(c, `
193 Clusters:
194   zzzzz:
195     postgresql: {}
196     BadKey: {}
197     Containers: {}
198     RemoteClusters:
199       z2222:
200         Host: z2222.arvadosapi.com
201         Proxy: true
202         BadKey: badValue
203 `, &logbuf).Load()
204         c.Assert(err, check.IsNil)
205         logs := strings.Split(strings.TrimSuffix(logbuf.String(), "\n"), "\n")
206         for _, log := range logs {
207                 c.Check(log, check.Matches, `.*deprecated or unknown config entry:.*BadKey.*`)
208         }
209         c.Check(logs, check.HasLen, 2)
210 }
211
212 func (s *LoadSuite) checkSAMPLEKeys(c *check.C, path string, x interface{}) {
213         v := reflect.Indirect(reflect.ValueOf(x))
214         switch v.Kind() {
215         case reflect.Map:
216                 var stringKeys, sampleKey bool
217                 iter := v.MapRange()
218                 for iter.Next() {
219                         k := iter.Key()
220                         if k.Kind() == reflect.String {
221                                 stringKeys = true
222                                 if k.String() == "SAMPLE" || k.String() == "xxxxx" {
223                                         sampleKey = true
224                                         s.checkSAMPLEKeys(c, path+"."+k.String(), iter.Value().Interface())
225                                 }
226                         }
227                 }
228                 if stringKeys && !sampleKey {
229                         c.Errorf("%s is a map with string keys (type %T) but config.default.yml has no SAMPLE key", path, x)
230                 }
231                 return
232         case reflect.Struct:
233                 for i := 0; i < v.NumField(); i++ {
234                         val := v.Field(i)
235                         if val.CanInterface() {
236                                 s.checkSAMPLEKeys(c, path+"."+v.Type().Field(i).Name, val.Interface())
237                         }
238                 }
239         }
240 }
241
242 func (s *LoadSuite) TestDefaultConfigHasAllSAMPLEKeys(c *check.C) {
243         var logbuf bytes.Buffer
244         loader := testLoader(c, string(DefaultYAML), &logbuf)
245         cfg, err := loader.Load()
246         c.Assert(err, check.IsNil)
247         s.checkSAMPLEKeys(c, "", cfg)
248 }
249
250 func (s *LoadSuite) TestNoUnrecognizedKeysInDefaultConfig(c *check.C) {
251         var logbuf bytes.Buffer
252         var supplied map[string]interface{}
253         yaml.Unmarshal(DefaultYAML, &supplied)
254
255         loader := testLoader(c, string(DefaultYAML), &logbuf)
256         cfg, err := loader.Load()
257         c.Assert(err, check.IsNil)
258         var loaded map[string]interface{}
259         buf, err := yaml.Marshal(cfg)
260         c.Assert(err, check.IsNil)
261         err = yaml.Unmarshal(buf, &loaded)
262         c.Assert(err, check.IsNil)
263
264         loader.logExtraKeys(loaded, supplied, "")
265         c.Check(logbuf.String(), check.Equals, "")
266 }
267
268 func (s *LoadSuite) TestNoWarningsForDumpedConfig(c *check.C) {
269         var logbuf bytes.Buffer
270         logger := logrus.New()
271         logger.Out = &logbuf
272         cfg, err := testLoader(c, `{"Clusters":{"zzzzz":{}}}`, &logbuf).Load()
273         c.Assert(err, check.IsNil)
274         yaml, err := yaml.Marshal(cfg)
275         c.Assert(err, check.IsNil)
276         cfgDumped, err := testLoader(c, string(yaml), &logbuf).Load()
277         c.Assert(err, check.IsNil)
278         c.Check(cfg, check.DeepEquals, cfgDumped)
279         c.Check(logbuf.String(), check.Equals, "")
280 }
281
282 func (s *LoadSuite) TestPostgreSQLKeyConflict(c *check.C) {
283         _, err := testLoader(c, `
284 Clusters:
285  zzzzz:
286   postgresql:
287    connection:
288      DBName: dbname
289      Host: host
290 `, nil).Load()
291         c.Check(err, check.ErrorMatches, `Clusters.zzzzz.PostgreSQL.Connection: multiple entries for "(dbname|host)".*`)
292 }
293
294 func (s *LoadSuite) TestBadType(c *check.C) {
295         for _, data := range []string{`
296 Clusters:
297  zzzzz:
298   PostgreSQL: true
299 `, `
300 Clusters:
301  zzzzz:
302   PostgreSQL:
303    ConnectionPool: true
304 `, `
305 Clusters:
306  zzzzz:
307   PostgreSQL:
308    ConnectionPool: "foo"
309 `, `
310 Clusters:
311  zzzzz:
312   PostgreSQL:
313    ConnectionPool: []
314 `, `
315 Clusters:
316  zzzzz:
317   PostgreSQL:
318    ConnectionPool: [] # {foo: bar} isn't caught here; we rely on config-check
319 `,
320         } {
321                 c.Log(data)
322                 v, err := testLoader(c, data, nil).Load()
323                 if v != nil {
324                         c.Logf("%#v", v.Clusters["zzzzz"].PostgreSQL.ConnectionPool)
325                 }
326                 c.Check(err, check.ErrorMatches, `.*cannot unmarshal .*PostgreSQL.*`)
327         }
328 }
329
330 func (s *LoadSuite) TestMovedKeys(c *check.C) {
331         checkEquivalent(c, `# config has old keys only
332 Clusters:
333  zzzzz:
334   RequestLimits:
335    MultiClusterRequestConcurrency: 3
336    MaxItemsPerResponse: 999
337 `, `
338 Clusters:
339  zzzzz:
340   API:
341    MaxRequestAmplification: 3
342    MaxItemsPerResponse: 999
343 `)
344         checkEquivalent(c, `# config has both old and new keys; old values win
345 Clusters:
346  zzzzz:
347   RequestLimits:
348    MultiClusterRequestConcurrency: 0
349    MaxItemsPerResponse: 555
350   API:
351    MaxRequestAmplification: 3
352    MaxItemsPerResponse: 999
353 `, `
354 Clusters:
355  zzzzz:
356   API:
357    MaxRequestAmplification: 0
358    MaxItemsPerResponse: 555
359 `)
360 }
361
362 func checkEquivalent(c *check.C, goty, expectedy string) {
363         gotldr := testLoader(c, goty, nil)
364         expectedldr := testLoader(c, expectedy, nil)
365         checkEquivalentLoaders(c, gotldr, expectedldr)
366 }
367
368 func checkEqualYAML(c *check.C, got, expected interface{}) {
369         expectedyaml, err := yaml.Marshal(expected)
370         c.Assert(err, check.IsNil)
371         gotyaml, err := yaml.Marshal(got)
372         c.Assert(err, check.IsNil)
373         if !bytes.Equal(gotyaml, expectedyaml) {
374                 cmd := exec.Command("diff", "-u", "--label", "expected", "--label", "got", "/dev/fd/3", "/dev/fd/4")
375                 for _, y := range [][]byte{expectedyaml, gotyaml} {
376                         pr, pw, err := os.Pipe()
377                         c.Assert(err, check.IsNil)
378                         defer pr.Close()
379                         go func(data []byte) {
380                                 pw.Write(data)
381                                 pw.Close()
382                         }(y)
383                         cmd.ExtraFiles = append(cmd.ExtraFiles, pr)
384                 }
385                 diff, err := cmd.CombinedOutput()
386                 // diff should report differences and exit non-zero.
387                 c.Check(err, check.NotNil)
388                 c.Log(string(diff))
389                 c.Error("got != expected; see diff (-expected +got) above")
390         }
391 }
392
393 func checkEquivalentLoaders(c *check.C, gotldr, expectedldr *Loader) {
394         got, err := gotldr.Load()
395         c.Assert(err, check.IsNil)
396         expected, err := expectedldr.Load()
397         c.Assert(err, check.IsNil)
398         checkEqualYAML(c, got, expected)
399 }
400
401 func checkListKeys(path string, x interface{}) (err error) {
402         v := reflect.Indirect(reflect.ValueOf(x))
403         switch v.Kind() {
404         case reflect.Map:
405                 iter := v.MapRange()
406                 for iter.Next() {
407                         k := iter.Key()
408                         if k.Kind() == reflect.String {
409                                 if err = checkListKeys(path+"."+k.String(), iter.Value().Interface()); err != nil {
410                                         return
411                                 }
412                         }
413                 }
414                 return
415
416         case reflect.Struct:
417                 for i := 0; i < v.NumField(); i++ {
418                         val := v.Field(i)
419                         structField := v.Type().Field(i)
420                         fieldname := structField.Name
421                         endsWithList := strings.HasSuffix(fieldname, "List")
422                         isAnArray := structField.Type.Kind() == reflect.Slice
423                         if endsWithList != isAnArray {
424                                 if endsWithList {
425                                         err = fmt.Errorf("%s.%s ends with 'List' but field is not an array (type %v)", path, fieldname, val.Kind())
426                                         return
427                                 }
428                                 if isAnArray && structField.Type.Elem().Kind() != reflect.Uint8 {
429                                         err = fmt.Errorf("%s.%s is an array but field name does not end in 'List' (slice of %v)", path, fieldname, structField.Type.Elem().Kind())
430                                         return
431                                 }
432                         }
433                         if val.CanInterface() {
434                                 checkListKeys(path+"."+fieldname, val.Interface())
435                         }
436                 }
437         }
438         return
439 }
440
441 func (s *LoadSuite) TestListKeys(c *check.C) {
442         v1 := struct {
443                 EndInList []string
444         }{[]string{"a", "b"}}
445         var m1 = make(map[string]interface{})
446         m1["c"] = &v1
447         if err := checkListKeys("", m1); err != nil {
448                 c.Error(err)
449         }
450
451         v2 := struct {
452                 DoesNot []string
453         }{[]string{"a", "b"}}
454         var m2 = make(map[string]interface{})
455         m2["c"] = &v2
456         if err := checkListKeys("", m2); err == nil {
457                 c.Errorf("Should have produced an error")
458         }
459
460         v3 := struct {
461                 EndInList string
462         }{"a"}
463         var m3 = make(map[string]interface{})
464         m3["c"] = &v3
465         if err := checkListKeys("", m3); err == nil {
466                 c.Errorf("Should have produced an error")
467         }
468
469         var logbuf bytes.Buffer
470         loader := testLoader(c, string(DefaultYAML), &logbuf)
471         cfg, err := loader.Load()
472         c.Assert(err, check.IsNil)
473         if err := checkListKeys("", cfg); err != nil {
474                 c.Error(err)
475         }
476 }