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) TestNullKeyDoesNotOverrideDefault(c *check.C) {
75 ldr := testLoader(c, `{"Clusters":{"z1111":{"API":}}}`, nil)
76 ldr.SkipDeprecated = true
77 cfg, err := ldr.Load()
78 c.Assert(err, check.IsNil)
79 c1, err := cfg.GetCluster("z1111")
80 c.Assert(err, check.IsNil)
81 c.Check(c1.ClusterID, check.Equals, "z1111")
82 c.Check(c1.API.MaxRequestAmplification, check.Equals, 4)
83 c.Check(c1.API.MaxItemsPerResponse, check.Equals, 1000)
86 func (s *LoadSuite) TestMungeLegacyConfigArgs(c *check.C) {
87 f, err := ioutil.TempFile("", "")
88 c.Check(err, check.IsNil)
89 defer os.Remove(f.Name())
90 io.WriteString(f, "Debug: true\n")
93 f, err = ioutil.TempFile("", "")
94 c.Check(err, check.IsNil)
95 defer os.Remove(f.Name())
96 io.WriteString(f, emptyConfigYAML)
99 for _, trial := range []struct {
104 []string{"-config", oldfile},
105 []string{"-old-config", oldfile},
108 []string{"-config=" + oldfile},
109 []string{"-old-config=" + oldfile},
112 []string{"-config", newfile},
113 []string{"-config", newfile},
116 []string{"-config=" + newfile},
117 []string{"-config=" + newfile},
120 []string{"-foo", oldfile},
121 []string{"-foo", oldfile},
124 []string{"-foo=" + oldfile},
125 []string{"-foo=" + oldfile},
128 []string{"-foo", "-config=" + oldfile},
129 []string{"-foo", "-old-config=" + oldfile},
132 []string{"-foo", "bar", "-config=" + oldfile},
133 []string{"-foo", "bar", "-old-config=" + oldfile},
136 []string{"-foo=bar", "baz", "-config=" + oldfile},
137 []string{"-foo=bar", "baz", "-old-config=" + oldfile},
140 []string{"-config=/dev/null"},
141 []string{"-config=/dev/null"},
144 []string{"-config=-"},
145 []string{"-config=-"},
148 []string{"-config="},
149 []string{"-config="},
152 []string{"-foo=bar", "baz", "-config"},
153 []string{"-foo=bar", "baz", "-config"},
160 var logbuf bytes.Buffer
161 logger := logrus.New()
165 args := ldr.MungeLegacyConfigArgs(logger, trial.argsIn, "-old-config")
166 c.Check(args, check.DeepEquals, trial.argsOut)
167 if fmt.Sprintf("%v", trial.argsIn) != fmt.Sprintf("%v", trial.argsOut) {
168 c.Check(logbuf.String(), check.Matches, `.*`+oldfile+` is not a cluster config file -- interpreting -config as -old-config.*\n`)
173 func (s *LoadSuite) TestSampleKeys(c *check.C) {
174 for _, yaml := range []string{
175 `{"Clusters":{"z1111":{}}}`,
176 `{"Clusters":{"z1111":{"InstanceTypes":{"Foo":{"RAM": "12345M"}}}}}`,
178 cfg, err := testLoader(c, yaml, nil).Load()
179 c.Assert(err, check.IsNil)
180 cc, err := cfg.GetCluster("z1111")
181 c.Assert(err, check.IsNil)
182 _, hasSample := cc.InstanceTypes["SAMPLE"]
183 c.Check(hasSample, check.Equals, false)
184 if strings.Contains(yaml, "Foo") {
185 c.Check(cc.InstanceTypes["Foo"].RAM, check.Equals, arvados.ByteSize(12345000000))
186 c.Check(cc.InstanceTypes["Foo"].Price, check.Equals, 0.0)
191 func (s *LoadSuite) TestMultipleClusters(c *check.C) {
192 ldr := testLoader(c, `{"Clusters":{"z1111":{},"z2222":{}}}`, nil)
193 ldr.SkipDeprecated = true
194 cfg, err := ldr.Load()
195 c.Assert(err, check.IsNil)
196 c1, err := cfg.GetCluster("z1111")
197 c.Assert(err, check.IsNil)
198 c.Check(c1.ClusterID, check.Equals, "z1111")
199 c2, err := cfg.GetCluster("z2222")
200 c.Assert(err, check.IsNil)
201 c.Check(c2.ClusterID, check.Equals, "z2222")
204 func (s *LoadSuite) TestDeprecatedOrUnknownWarning(c *check.C) {
205 var logbuf bytes.Buffer
206 _, err := testLoader(c, `
209 ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
210 SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
212 BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
219 Host: z2222.arvadosapi.com
225 "http://host.example:12345": {}
228 "http://host.example:12345":
233 "http://host.example:12345": {}
235 zzzzz-nyw5e-aaaaaaaaaaaaaaa: {}
237 c.Assert(err, check.IsNil)
238 c.Log(logbuf.String())
239 logs := strings.Split(strings.TrimSuffix(logbuf.String(), "\n"), "\n")
240 for _, log := range logs {
241 c.Check(log, check.Matches, `.*deprecated or unknown config entry:.*(RunTimeEngine.*RuntimeEngine|BadKey1|BadKey2|KeepStore|ServiceS|RendezVous).*`)
243 c.Check(logs, check.HasLen, 6)
246 func (s *LoadSuite) checkSAMPLEKeys(c *check.C, path string, x interface{}) {
247 v := reflect.Indirect(reflect.ValueOf(x))
250 var stringKeys, sampleKey bool
254 if k.Kind() == reflect.String {
256 if k.String() == "SAMPLE" || k.String() == "xxxxx" {
258 s.checkSAMPLEKeys(c, path+"."+k.String(), iter.Value().Interface())
262 if stringKeys && !sampleKey {
263 c.Errorf("%s is a map with string keys (type %T) but config.default.yml has no SAMPLE key", path, x)
267 for i := 0; i < v.NumField(); i++ {
269 if val.CanInterface() {
270 s.checkSAMPLEKeys(c, path+"."+v.Type().Field(i).Name, val.Interface())
276 func (s *LoadSuite) TestDefaultConfigHasAllSAMPLEKeys(c *check.C) {
277 var logbuf bytes.Buffer
278 loader := testLoader(c, string(DefaultYAML), &logbuf)
279 cfg, err := loader.Load()
280 c.Assert(err, check.IsNil)
281 s.checkSAMPLEKeys(c, "", cfg)
284 func (s *LoadSuite) TestNoUnrecognizedKeysInDefaultConfig(c *check.C) {
285 var logbuf bytes.Buffer
286 var supplied map[string]interface{}
287 yaml.Unmarshal(DefaultYAML, &supplied)
289 loader := testLoader(c, string(DefaultYAML), &logbuf)
290 cfg, err := loader.Load()
291 c.Assert(err, check.IsNil)
292 var loaded map[string]interface{}
293 buf, err := yaml.Marshal(cfg)
294 c.Assert(err, check.IsNil)
295 err = yaml.Unmarshal(buf, &loaded)
296 c.Assert(err, check.IsNil)
298 c.Check(logbuf.String(), check.Matches, `(?ms).*SystemRootToken: secret token is not set.*`)
299 c.Check(logbuf.String(), check.Matches, `(?ms).*ManagementToken: secret token is not set.*`)
300 c.Check(logbuf.String(), check.Matches, `(?ms).*Collections.BlobSigningKey: secret token is not set.*`)
302 loader.logExtraKeys(loaded, supplied, "")
303 c.Check(logbuf.String(), check.Equals, "")
306 func (s *LoadSuite) TestNoWarningsForDumpedConfig(c *check.C) {
307 var logbuf bytes.Buffer
308 logger := logrus.New()
310 cfg, err := testLoader(c, `
313 ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
314 SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
316 BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`, &logbuf).Load()
317 c.Assert(err, check.IsNil)
318 yaml, err := yaml.Marshal(cfg)
319 c.Assert(err, check.IsNil)
320 cfgDumped, err := testLoader(c, string(yaml), &logbuf).Load()
321 c.Assert(err, check.IsNil)
322 c.Check(cfg, check.DeepEquals, cfgDumped)
323 c.Check(logbuf.String(), check.Equals, "")
326 func (s *LoadSuite) TestUnacceptableTokens(c *check.C) {
327 for _, trial := range []struct {
332 {false, "SystemRootToken", "SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa_b_c"},
333 {false, "ManagementToken", "ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa b c"},
334 {false, "ManagementToken", "ManagementToken: \"$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabc\""},
335 {false, "Collections.BlobSigningKey", "Collections: {BlobSigningKey: \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa⛵\"}"},
336 {true, "SystemRootToken", "SystemRootToken: a_b_c"},
337 {true, "ManagementToken", "ManagementToken: a b c"},
338 {true, "ManagementToken", "ManagementToken: \"$abc\""},
339 {true, "Collections.BlobSigningKey", "Collections: {BlobSigningKey: \"⛵\"}"},
341 c.Logf("trying bogus config: %s", trial.example)
342 _, err := testLoader(c, "Clusters:\n zzzzz:\n "+trial.example, nil).Load()
344 c.Check(err, check.ErrorMatches, `Clusters.zzzzz.`+trial.configPath+`: unacceptable characters in token.*`)
346 c.Check(err, check.ErrorMatches, `Clusters.zzzzz.`+trial.configPath+`: unacceptable characters in token.*`)
351 func (s *LoadSuite) TestPostgreSQLKeyConflict(c *check.C) {
352 _, err := testLoader(c, `
360 c.Check(err, check.ErrorMatches, `Clusters.zzzzz.PostgreSQL.Connection: multiple entries for "(dbname|host)".*`)
363 func (s *LoadSuite) TestBadClusterIDs(c *check.C) {
364 for _, data := range []string{`
367 ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
368 SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
370 BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
374 ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
375 SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
377 BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
380 Host: Zzzzz.arvadosapi.com
385 ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
386 SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
388 BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
394 v, err := testLoader(c, data, nil).Load()
396 c.Logf("%#v", v.Clusters)
398 c.Check(err, check.ErrorMatches, `.*cluster ID should be 5 alphanumeric characters.*`)
402 func (s *LoadSuite) TestBadType(c *check.C) {
403 for _, data := range []string{`
416 ConnectionPool: "foo"
426 ConnectionPool: [] # {foo: bar} isn't caught here; we rely on config-check
430 v, err := testLoader(c, data, nil).Load()
432 c.Logf("%#v", v.Clusters["zzzzz"].PostgreSQL.ConnectionPool)
434 c.Check(err, check.ErrorMatches, `.*cannot unmarshal .*PostgreSQL.*`)
438 func (s *LoadSuite) TestMovedKeys(c *check.C) {
439 checkEquivalent(c, `# config has old keys only
443 MultiClusterRequestConcurrency: 3
444 MaxItemsPerResponse: 999
449 MaxRequestAmplification: 3
450 MaxItemsPerResponse: 999
452 checkEquivalent(c, `# config has both old and new keys; old values win
456 MultiClusterRequestConcurrency: 0
457 MaxItemsPerResponse: 555
459 MaxRequestAmplification: 3
460 MaxItemsPerResponse: 999
465 MaxRequestAmplification: 0
466 MaxItemsPerResponse: 555
470 func checkEquivalent(c *check.C, goty, expectedy string) string {
471 var logbuf bytes.Buffer
472 gotldr := testLoader(c, goty, &logbuf)
473 expectedldr := testLoader(c, expectedy, nil)
474 checkEquivalentLoaders(c, gotldr, expectedldr)
475 return logbuf.String()
478 func checkEqualYAML(c *check.C, got, expected interface{}) {
479 expectedyaml, err := yaml.Marshal(expected)
480 c.Assert(err, check.IsNil)
481 gotyaml, err := yaml.Marshal(got)
482 c.Assert(err, check.IsNil)
483 if !bytes.Equal(gotyaml, expectedyaml) {
484 cmd := exec.Command("diff", "-u", "--label", "expected", "--label", "got", "/dev/fd/3", "/dev/fd/4")
485 for _, y := range [][]byte{expectedyaml, gotyaml} {
486 pr, pw, err := os.Pipe()
487 c.Assert(err, check.IsNil)
489 go func(data []byte) {
493 cmd.ExtraFiles = append(cmd.ExtraFiles, pr)
495 diff, err := cmd.CombinedOutput()
496 // diff should report differences and exit non-zero.
497 c.Check(err, check.NotNil)
499 c.Error("got != expected; see diff (-expected +got) above")
503 func checkEquivalentLoaders(c *check.C, gotldr, expectedldr *Loader) {
504 got, err := gotldr.Load()
505 c.Assert(err, check.IsNil)
506 expected, err := expectedldr.Load()
507 c.Assert(err, check.IsNil)
508 checkEqualYAML(c, got, expected)
511 func checkListKeys(path string, x interface{}) (err error) {
512 v := reflect.Indirect(reflect.ValueOf(x))
518 if k.Kind() == reflect.String {
519 if err = checkListKeys(path+"."+k.String(), iter.Value().Interface()); err != nil {
527 for i := 0; i < v.NumField(); i++ {
529 structField := v.Type().Field(i)
530 fieldname := structField.Name
531 endsWithList := strings.HasSuffix(fieldname, "List")
532 isAnArray := structField.Type.Kind() == reflect.Slice
533 if endsWithList != isAnArray {
535 err = fmt.Errorf("%s.%s ends with 'List' but field is not an array (type %v)", path, fieldname, val.Kind())
538 if isAnArray && structField.Type.Elem().Kind() != reflect.Uint8 {
539 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())
543 if val.CanInterface() {
544 checkListKeys(path+"."+fieldname, val.Interface())
551 func (s *LoadSuite) TestListKeys(c *check.C) {
554 }{[]string{"a", "b"}}
555 var m1 = make(map[string]interface{})
557 if err := checkListKeys("", m1); err != nil {
563 }{[]string{"a", "b"}}
564 var m2 = make(map[string]interface{})
566 if err := checkListKeys("", m2); err == nil {
567 c.Errorf("Should have produced an error")
573 var m3 = make(map[string]interface{})
575 if err := checkListKeys("", m3); err == nil {
576 c.Errorf("Should have produced an error")
579 loader := testLoader(c, string(DefaultYAML), nil)
580 cfg, err := loader.Load()
581 c.Assert(err, check.IsNil)
582 if err := checkListKeys("", cfg); err != nil {
587 func (s *LoadSuite) TestImplicitStorageClasses(c *check.C) {
588 // If StorageClasses and Volumes.*.StorageClasses are all
589 // empty, there is a default storage class named "default".
590 ldr := testLoader(c, `{"Clusters":{"z1111":{}}}`, nil)
591 cfg, err := ldr.Load()
592 c.Assert(err, check.IsNil)
593 cc, err := cfg.GetCluster("z1111")
594 c.Assert(err, check.IsNil)
595 c.Check(cc.StorageClasses, check.HasLen, 1)
596 c.Check(cc.StorageClasses["default"].Default, check.Equals, true)
597 c.Check(cc.StorageClasses["default"].Priority, check.Equals, 0)
599 // The implicit "default" storage class is used by all
601 ldr = testLoader(c, `
606 cfg, err = ldr.Load()
607 c.Assert(err, check.IsNil)
608 cc, err = cfg.GetCluster("z1111")
609 c.Assert(err, check.IsNil)
610 c.Check(cc.StorageClasses, check.HasLen, 1)
611 c.Check(cc.StorageClasses["default"].Default, check.Equals, true)
612 c.Check(cc.StorageClasses["default"].Priority, check.Equals, 0)
613 c.Check(cc.Volumes["z"].StorageClasses["default"], check.Equals, true)
615 // The "default" storage class isn't implicit if any classes
616 // are configured explicitly.
617 ldr = testLoader(c, `
628 cfg, err = ldr.Load()
629 c.Assert(err, check.IsNil)
630 cc, err = cfg.GetCluster("z1111")
631 c.Assert(err, check.IsNil)
632 c.Check(cc.StorageClasses, check.HasLen, 1)
633 c.Check(cc.StorageClasses["local"].Default, check.Equals, true)
634 c.Check(cc.StorageClasses["local"].Priority, check.Equals, 111)
636 // It is an error for a volume to refer to a storage class
637 // that isn't listed in StorageClasses.
638 ldr = testLoader(c, `
650 c.Assert(err, check.ErrorMatches, `z: volume refers to storage class "nx" that is not defined.*`)
652 // It is an error for a volume to refer to a storage class
653 // that isn't listed in StorageClasses ... even if it's
654 // "default", which would exist implicitly if it weren't
655 // referenced explicitly by a volume.
656 ldr = testLoader(c, `
664 c.Assert(err, check.ErrorMatches, `z: volume refers to storage class "default" that is not defined.*`)
666 // If the "default" storage class is configured explicitly, it
667 // is not used implicitly by any volumes, even if it's the
668 // only storage class.
669 var logbuf bytes.Buffer
670 ldr = testLoader(c, `
680 c.Assert(err, check.ErrorMatches, `z: volume has no StorageClasses listed`)
682 // If StorageClasses are configured explicitly, there must be
683 // at least one with Default: true. (Calling one "default" is
685 ldr = testLoader(c, `
696 c.Assert(err, check.ErrorMatches, `there is no default storage class.*`)