1 // Copyright (C) The Arvados Authors. All rights reserved.
3 // SPDX-License-Identifier: AGPL-3.0
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"
25 // Gocheck boilerplate
26 func Test(t *testing.T) {
30 var _ = check.Suite(&LoadSuite{})
32 var emptyConfigYAML = `Clusters: {"z1111": {}}`
34 // Return a new Loader that reads cluster config from configdata
35 // (instead of the usual default /etc/arvados/config.yml), and logs to
36 // logdst or (if that's nil) c.Log.
37 func testLoader(c *check.C, configdata string, logdst io.Writer) *Loader {
38 logger := ctxlog.TestLogger(c)
44 ldr := NewLoader(bytes.NewBufferString(configdata), logger)
49 type LoadSuite struct{}
51 func (s *LoadSuite) SetUpSuite(c *check.C) {
52 os.Unsetenv("ARVADOS_API_HOST")
53 os.Unsetenv("ARVADOS_API_HOST_INSECURE")
54 os.Unsetenv("ARVADOS_API_TOKEN")
57 func (s *LoadSuite) TestEmpty(c *check.C) {
58 cfg, err := testLoader(c, "", nil).Load()
59 c.Check(cfg, check.IsNil)
60 c.Assert(err, check.ErrorMatches, `config does not define any clusters`)
63 func (s *LoadSuite) TestNoConfigs(c *check.C) {
64 cfg, err := testLoader(c, emptyConfigYAML, nil).Load()
65 c.Assert(err, check.IsNil)
66 c.Assert(cfg.Clusters, check.HasLen, 1)
67 cc, err := cfg.GetCluster("z1111")
68 c.Assert(err, check.IsNil)
69 c.Check(cc.ClusterID, check.Equals, "z1111")
70 c.Check(cc.API.MaxRequestAmplification, check.Equals, 4)
71 c.Check(cc.API.MaxItemsPerResponse, check.Equals, 1000)
74 func (s *LoadSuite) TestMungeLegacyConfigArgs(c *check.C) {
75 f, err := ioutil.TempFile("", "")
76 c.Check(err, check.IsNil)
77 defer os.Remove(f.Name())
78 io.WriteString(f, "Debug: true\n")
81 f, err = ioutil.TempFile("", "")
82 c.Check(err, check.IsNil)
83 defer os.Remove(f.Name())
84 io.WriteString(f, emptyConfigYAML)
87 for _, trial := range []struct {
92 []string{"-config", oldfile},
93 []string{"-old-config", oldfile},
96 []string{"-config=" + oldfile},
97 []string{"-old-config=" + oldfile},
100 []string{"-config", newfile},
101 []string{"-config", newfile},
104 []string{"-config=" + newfile},
105 []string{"-config=" + newfile},
108 []string{"-foo", oldfile},
109 []string{"-foo", oldfile},
112 []string{"-foo=" + oldfile},
113 []string{"-foo=" + oldfile},
116 []string{"-foo", "-config=" + oldfile},
117 []string{"-foo", "-old-config=" + oldfile},
120 []string{"-foo", "bar", "-config=" + oldfile},
121 []string{"-foo", "bar", "-old-config=" + oldfile},
124 []string{"-foo=bar", "baz", "-config=" + oldfile},
125 []string{"-foo=bar", "baz", "-old-config=" + oldfile},
128 []string{"-config=/dev/null"},
129 []string{"-config=/dev/null"},
132 []string{"-config=-"},
133 []string{"-config=-"},
136 []string{"-config="},
137 []string{"-config="},
140 []string{"-foo=bar", "baz", "-config"},
141 []string{"-foo=bar", "baz", "-config"},
148 var logbuf bytes.Buffer
149 logger := logrus.New()
153 args := ldr.MungeLegacyConfigArgs(logger, trial.argsIn, "-old-config")
154 c.Check(args, check.DeepEquals, trial.argsOut)
155 if fmt.Sprintf("%v", trial.argsIn) != fmt.Sprintf("%v", trial.argsOut) {
156 c.Check(logbuf.String(), check.Matches, `.*`+oldfile+` is not a cluster config file -- interpreting -config as -old-config.*\n`)
161 func (s *LoadSuite) TestSampleKeys(c *check.C) {
162 for _, yaml := range []string{
163 `{"Clusters":{"z1111":{}}}`,
164 `{"Clusters":{"z1111":{"InstanceTypes":{"Foo":{"RAM": "12345M"}}}}}`,
166 cfg, err := testLoader(c, yaml, nil).Load()
167 c.Assert(err, check.IsNil)
168 cc, err := cfg.GetCluster("z1111")
169 c.Assert(err, check.IsNil)
170 _, hasSample := cc.InstanceTypes["SAMPLE"]
171 c.Check(hasSample, check.Equals, false)
172 if strings.Contains(yaml, "Foo") {
173 c.Check(cc.InstanceTypes["Foo"].RAM, check.Equals, arvados.ByteSize(12345000000))
174 c.Check(cc.InstanceTypes["Foo"].Price, check.Equals, 0.0)
179 func (s *LoadSuite) TestMultipleClusters(c *check.C) {
180 ldr := testLoader(c, `{"Clusters":{"z1111":{},"z2222":{}}}`, nil)
181 ldr.SkipDeprecated = true
182 cfg, err := ldr.Load()
183 c.Assert(err, check.IsNil)
184 c1, err := cfg.GetCluster("z1111")
185 c.Assert(err, check.IsNil)
186 c.Check(c1.ClusterID, check.Equals, "z1111")
187 c2, err := cfg.GetCluster("z2222")
188 c.Assert(err, check.IsNil)
189 c.Check(c2.ClusterID, check.Equals, "z2222")
192 func (s *LoadSuite) TestDeprecatedOrUnknownWarning(c *check.C) {
193 var logbuf bytes.Buffer
194 _, err := testLoader(c, `
197 ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
198 SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
200 BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
207 Host: z2222.arvadosapi.com
213 "http://host.example:12345": {}
216 "http://host.example:12345":
221 "http://host.example:12345": {}
223 zzzzz-nyw5e-aaaaaaaaaaaaaaa: {}
225 c.Assert(err, check.IsNil)
226 c.Log(logbuf.String())
227 logs := strings.Split(strings.TrimSuffix(logbuf.String(), "\n"), "\n")
228 for _, log := range logs {
229 c.Check(log, check.Matches, `.*deprecated or unknown config entry:.*(RunTimeEngine.*RuntimeEngine|BadKey1|BadKey2|KeepStore|ServiceS|RendezVous).*`)
231 c.Check(logs, check.HasLen, 6)
234 func (s *LoadSuite) checkSAMPLEKeys(c *check.C, path string, x interface{}) {
235 v := reflect.Indirect(reflect.ValueOf(x))
238 var stringKeys, sampleKey bool
242 if k.Kind() == reflect.String {
244 if k.String() == "SAMPLE" || k.String() == "xxxxx" {
246 s.checkSAMPLEKeys(c, path+"."+k.String(), iter.Value().Interface())
250 if stringKeys && !sampleKey {
251 c.Errorf("%s is a map with string keys (type %T) but config.default.yml has no SAMPLE key", path, x)
255 for i := 0; i < v.NumField(); i++ {
257 if val.CanInterface() {
258 s.checkSAMPLEKeys(c, path+"."+v.Type().Field(i).Name, val.Interface())
264 func (s *LoadSuite) TestDefaultConfigHasAllSAMPLEKeys(c *check.C) {
265 var logbuf bytes.Buffer
266 loader := testLoader(c, string(DefaultYAML), &logbuf)
267 cfg, err := loader.Load()
268 c.Assert(err, check.IsNil)
269 s.checkSAMPLEKeys(c, "", cfg)
272 func (s *LoadSuite) TestNoUnrecognizedKeysInDefaultConfig(c *check.C) {
273 var logbuf bytes.Buffer
274 var supplied map[string]interface{}
275 yaml.Unmarshal(DefaultYAML, &supplied)
277 loader := testLoader(c, string(DefaultYAML), &logbuf)
278 cfg, err := loader.Load()
279 c.Assert(err, check.IsNil)
280 var loaded map[string]interface{}
281 buf, err := yaml.Marshal(cfg)
282 c.Assert(err, check.IsNil)
283 err = yaml.Unmarshal(buf, &loaded)
284 c.Assert(err, check.IsNil)
286 c.Check(logbuf.String(), check.Matches, `(?ms).*SystemRootToken: secret token is not set.*`)
287 c.Check(logbuf.String(), check.Matches, `(?ms).*ManagementToken: secret token is not set.*`)
288 c.Check(logbuf.String(), check.Matches, `(?ms).*Collections.BlobSigningKey: secret token is not set.*`)
290 loader.logExtraKeys(loaded, supplied, "")
291 c.Check(logbuf.String(), check.Equals, "")
294 func (s *LoadSuite) TestNoWarningsForDumpedConfig(c *check.C) {
295 var logbuf bytes.Buffer
296 logger := logrus.New()
298 cfg, err := testLoader(c, `
301 ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
302 SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
304 BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`, &logbuf).Load()
305 c.Assert(err, check.IsNil)
306 yaml, err := yaml.Marshal(cfg)
307 c.Assert(err, check.IsNil)
308 cfgDumped, err := testLoader(c, string(yaml), &logbuf).Load()
309 c.Assert(err, check.IsNil)
310 c.Check(cfg, check.DeepEquals, cfgDumped)
311 c.Check(logbuf.String(), check.Equals, "")
314 func (s *LoadSuite) TestUnacceptableTokens(c *check.C) {
315 for _, trial := range []struct {
320 {false, "SystemRootToken", "SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa_b_c"},
321 {false, "ManagementToken", "ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa b c"},
322 {false, "ManagementToken", "ManagementToken: \"$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabc\""},
323 {false, "Collections.BlobSigningKey", "Collections: {BlobSigningKey: \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa⛵\"}"},
324 {true, "SystemRootToken", "SystemRootToken: a_b_c"},
325 {true, "ManagementToken", "ManagementToken: a b c"},
326 {true, "ManagementToken", "ManagementToken: \"$abc\""},
327 {true, "Collections.BlobSigningKey", "Collections: {BlobSigningKey: \"⛵\"}"},
329 c.Logf("trying bogus config: %s", trial.example)
330 _, err := testLoader(c, "Clusters:\n zzzzz:\n "+trial.example, nil).Load()
332 c.Check(err, check.ErrorMatches, `Clusters.zzzzz.`+trial.configPath+`: unacceptable characters in token.*`)
334 c.Check(err, check.ErrorMatches, `Clusters.zzzzz.`+trial.configPath+`: unacceptable characters in token.*`)
339 func (s *LoadSuite) TestPostgreSQLKeyConflict(c *check.C) {
340 _, err := testLoader(c, `
348 c.Check(err, check.ErrorMatches, `Clusters.zzzzz.PostgreSQL.Connection: multiple entries for "(dbname|host)".*`)
351 func (s *LoadSuite) TestBadClusterIDs(c *check.C) {
352 for _, data := range []string{`
355 ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
356 SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
358 BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
362 ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
363 SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
365 BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
368 Host: Zzzzz.arvadosapi.com
373 ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
374 SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
376 BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
382 v, err := testLoader(c, data, nil).Load()
384 c.Logf("%#v", v.Clusters)
386 c.Check(err, check.ErrorMatches, `.*cluster ID should be 5 alphanumeric characters.*`)
390 func (s *LoadSuite) TestBadType(c *check.C) {
391 for _, data := range []string{`
404 ConnectionPool: "foo"
414 ConnectionPool: [] # {foo: bar} isn't caught here; we rely on config-check
418 v, err := testLoader(c, data, nil).Load()
420 c.Logf("%#v", v.Clusters["zzzzz"].PostgreSQL.ConnectionPool)
422 c.Check(err, check.ErrorMatches, `.*cannot unmarshal .*PostgreSQL.*`)
426 func (s *LoadSuite) TestMovedKeys(c *check.C) {
427 checkEquivalent(c, `# config has old keys only
431 MultiClusterRequestConcurrency: 3
432 MaxItemsPerResponse: 999
437 MaxRequestAmplification: 3
438 MaxItemsPerResponse: 999
440 checkEquivalent(c, `# config has both old and new keys; old values win
444 MultiClusterRequestConcurrency: 0
445 MaxItemsPerResponse: 555
447 MaxRequestAmplification: 3
448 MaxItemsPerResponse: 999
453 MaxRequestAmplification: 0
454 MaxItemsPerResponse: 555
458 func checkEquivalent(c *check.C, goty, expectedy string) string {
459 var logbuf bytes.Buffer
460 gotldr := testLoader(c, goty, &logbuf)
461 expectedldr := testLoader(c, expectedy, nil)
462 checkEquivalentLoaders(c, gotldr, expectedldr)
463 return logbuf.String()
466 func checkEqualYAML(c *check.C, got, expected interface{}) {
467 expectedyaml, err := yaml.Marshal(expected)
468 c.Assert(err, check.IsNil)
469 gotyaml, err := yaml.Marshal(got)
470 c.Assert(err, check.IsNil)
471 if !bytes.Equal(gotyaml, expectedyaml) {
472 cmd := exec.Command("diff", "-u", "--label", "expected", "--label", "got", "/dev/fd/3", "/dev/fd/4")
473 for _, y := range [][]byte{expectedyaml, gotyaml} {
474 pr, pw, err := os.Pipe()
475 c.Assert(err, check.IsNil)
477 go func(data []byte) {
481 cmd.ExtraFiles = append(cmd.ExtraFiles, pr)
483 diff, err := cmd.CombinedOutput()
484 // diff should report differences and exit non-zero.
485 c.Check(err, check.NotNil)
487 c.Error("got != expected; see diff (-expected +got) above")
491 func checkEquivalentLoaders(c *check.C, gotldr, expectedldr *Loader) {
492 got, err := gotldr.Load()
493 c.Assert(err, check.IsNil)
494 expected, err := expectedldr.Load()
495 c.Assert(err, check.IsNil)
496 checkEqualYAML(c, got, expected)
499 func checkListKeys(path string, x interface{}) (err error) {
500 v := reflect.Indirect(reflect.ValueOf(x))
506 if k.Kind() == reflect.String {
507 if err = checkListKeys(path+"."+k.String(), iter.Value().Interface()); err != nil {
515 for i := 0; i < v.NumField(); i++ {
517 structField := v.Type().Field(i)
518 fieldname := structField.Name
519 endsWithList := strings.HasSuffix(fieldname, "List")
520 isAnArray := structField.Type.Kind() == reflect.Slice
521 if endsWithList != isAnArray {
523 err = fmt.Errorf("%s.%s ends with 'List' but field is not an array (type %v)", path, fieldname, val.Kind())
526 if isAnArray && structField.Type.Elem().Kind() != reflect.Uint8 {
527 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())
531 if val.CanInterface() {
532 checkListKeys(path+"."+fieldname, val.Interface())
539 func (s *LoadSuite) TestListKeys(c *check.C) {
542 }{[]string{"a", "b"}}
543 var m1 = make(map[string]interface{})
545 if err := checkListKeys("", m1); err != nil {
551 }{[]string{"a", "b"}}
552 var m2 = make(map[string]interface{})
554 if err := checkListKeys("", m2); err == nil {
555 c.Errorf("Should have produced an error")
561 var m3 = make(map[string]interface{})
563 if err := checkListKeys("", m3); err == nil {
564 c.Errorf("Should have produced an error")
567 loader := testLoader(c, string(DefaultYAML), nil)
568 cfg, err := loader.Load()
569 c.Assert(err, check.IsNil)
570 if err := checkListKeys("", cfg); err != nil {
575 func (s *LoadSuite) TestImplicitStorageClasses(c *check.C) {
576 // If StorageClasses and Volumes.*.StorageClasses are all
577 // empty, there is a default storage class named "default".
578 ldr := testLoader(c, `{"Clusters":{"z1111":{}}}`, nil)
579 cfg, err := ldr.Load()
580 c.Assert(err, check.IsNil)
581 cc, err := cfg.GetCluster("z1111")
582 c.Assert(err, check.IsNil)
583 c.Check(cc.StorageClasses, check.HasLen, 1)
584 c.Check(cc.StorageClasses["default"].Default, check.Equals, true)
585 c.Check(cc.StorageClasses["default"].Priority, check.Equals, 0)
587 // The implicit "default" storage class is used by all
589 ldr = testLoader(c, `
594 cfg, err = ldr.Load()
595 c.Assert(err, check.IsNil)
596 cc, err = cfg.GetCluster("z1111")
597 c.Assert(err, check.IsNil)
598 c.Check(cc.StorageClasses, check.HasLen, 1)
599 c.Check(cc.StorageClasses["default"].Default, check.Equals, true)
600 c.Check(cc.StorageClasses["default"].Priority, check.Equals, 0)
601 c.Check(cc.Volumes["z"].StorageClasses["default"], check.Equals, true)
603 // The "default" storage class isn't implicit if any classes
604 // are configured explicitly.
605 ldr = testLoader(c, `
616 cfg, err = ldr.Load()
617 c.Assert(err, check.IsNil)
618 cc, err = cfg.GetCluster("z1111")
619 c.Assert(err, check.IsNil)
620 c.Check(cc.StorageClasses, check.HasLen, 1)
621 c.Check(cc.StorageClasses["local"].Default, check.Equals, true)
622 c.Check(cc.StorageClasses["local"].Priority, check.Equals, 111)
624 // It is an error for a volume to refer to a storage class
625 // that isn't listed in StorageClasses.
626 ldr = testLoader(c, `
638 c.Assert(err, check.ErrorMatches, `z: volume refers to storage class "nx" that is not defined.*`)
640 // It is an error for a volume to refer to a storage class
641 // that isn't listed in StorageClasses ... even if it's
642 // "default", which would exist implicitly if it weren't
643 // referenced explicitly by a volume.
644 ldr = testLoader(c, `
652 c.Assert(err, check.ErrorMatches, `z: volume refers to storage class "default" that is not defined.*`)
654 // If the "default" storage class is configured explicitly, it
655 // is not used implicitly by any volumes, even if it's the
656 // only storage class.
657 var logbuf bytes.Buffer
658 ldr = testLoader(c, `
668 c.Assert(err, check.ErrorMatches, `z: volume has no StorageClasses listed`)
670 // If StorageClasses are configured explicitly, there must be
671 // at least one with Default: true. (Calling one "default" is
673 ldr = testLoader(c, `
684 c.Assert(err, check.ErrorMatches, `there is no default storage class.*`)