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 // 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)
42 ldr := NewLoader(bytes.NewBufferString(configdata), logger)
47 type LoadSuite struct{}
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")
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`)
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)
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")
79 f, err = ioutil.TempFile("", "")
80 c.Check(err, check.IsNil)
81 defer os.Remove(f.Name())
82 io.WriteString(f, "Clusters: {aaaaa: {}}\n")
85 for _, trial := range []struct {
90 []string{"-config", oldfile},
91 []string{"-old-config", oldfile},
94 []string{"-config=" + oldfile},
95 []string{"-old-config=" + oldfile},
98 []string{"-config", newfile},
99 []string{"-config", newfile},
102 []string{"-config=" + newfile},
103 []string{"-config=" + newfile},
106 []string{"-foo", oldfile},
107 []string{"-foo", oldfile},
110 []string{"-foo=" + oldfile},
111 []string{"-foo=" + oldfile},
114 []string{"-foo", "-config=" + oldfile},
115 []string{"-foo", "-old-config=" + oldfile},
118 []string{"-foo", "bar", "-config=" + oldfile},
119 []string{"-foo", "bar", "-old-config=" + oldfile},
122 []string{"-foo=bar", "baz", "-config=" + oldfile},
123 []string{"-foo=bar", "baz", "-old-config=" + oldfile},
126 []string{"-config=/dev/null"},
127 []string{"-config=/dev/null"},
130 []string{"-config=-"},
131 []string{"-config=-"},
134 []string{"-config="},
135 []string{"-config="},
138 []string{"-foo=bar", "baz", "-config"},
139 []string{"-foo=bar", "baz", "-config"},
146 var logbuf bytes.Buffer
147 logger := logrus.New()
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`)
159 func (s *LoadSuite) TestSampleKeys(c *check.C) {
160 for _, yaml := range []string{
161 `{"Clusters":{"z1111":{}}}`,
162 `{"Clusters":{"z1111":{"InstanceTypes":{"Foo":{"RAM": "12345M"}}}}}`,
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)
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")
190 func (s *LoadSuite) TestDeprecatedOrUnknownWarning(c *check.C) {
191 var logbuf bytes.Buffer
192 _, err := testLoader(c, `
195 ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
196 SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
198 BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
205 Host: z2222.arvadosapi.com
211 "http://host.example:12345": {}
212 # we use Keepproxy instead of Keepstore for the RendezVous test,
213 # to avoid the "keepstore has no volumes" warning
216 "http://host.example:12345":
217 # ideally we would reject Rendezvous here too, but
223 "http://host.example:12345": {}
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 var logbuf bytes.Buffer
568 loader := testLoader(c, string(DefaultYAML), &logbuf)
569 cfg, err := loader.Load()
570 c.Assert(err, check.IsNil)
571 if err := checkListKeys("", cfg); err != nil {