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 var emptyConfigYAML = `Clusters: {"z1111": {}}`
  33
  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)
  39         if logdst != nil {
  40                 lgr := logrus.New()
  41                 lgr.Out = logdst
  42                 logger = lgr
  43         }
  44         ldr := NewLoader(bytes.NewBufferString(configdata), logger)
  45         ldr.Path = "-"
  46         return ldr
  47 }
  48
  49 type LoadSuite struct{}
  50
  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")
  55 }
  56
  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`)
  61 }
  62
  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)
  72 }
  73
  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)
  84 }
  85
  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")
  91         oldfile := f.Name()
  92
  93         f, err = ioutil.TempFile("", "")
  94         c.Check(err, check.IsNil)
  95         defer os.Remove(f.Name())
  96         io.WriteString(f, emptyConfigYAML)
  97         newfile := f.Name()
  98
  99         for _, trial := range []struct {
 100                 argsIn  []string
 101                 argsOut []string
 102         }{
 103                 {
 104                         []string{"-config", oldfile},
 105                         []string{"-old-config", oldfile},
 106                 },
 107                 {
 108                         []string{"-config=" + oldfile},
 109                         []string{"-old-config=" + oldfile},
 110                 },
 111                 {
 112                         []string{"-config", newfile},
 113                         []string{"-config", newfile},
 114                 },
 115                 {
 116                         []string{"-config=" + newfile},
 117                         []string{"-config=" + newfile},
 118                 },
 119                 {
 120                         []string{"-foo", oldfile},
 121                         []string{"-foo", oldfile},
 122                 },
 123                 {
 124                         []string{"-foo=" + oldfile},
 125                         []string{"-foo=" + oldfile},
 126                 },
 127                 {
 128                         []string{"-foo", "-config=" + oldfile},
 129                         []string{"-foo", "-old-config=" + oldfile},
 130                 },
 131                 {
 132                         []string{"-foo", "bar", "-config=" + oldfile},
 133                         []string{"-foo", "bar", "-old-config=" + oldfile},
 134                 },
 135                 {
 136                         []string{"-foo=bar", "baz", "-config=" + oldfile},
 137                         []string{"-foo=bar", "baz", "-old-config=" + oldfile},
 138                 },
 139                 {
 140                         []string{"-config=/dev/null"},
 141                         []string{"-config=/dev/null"},
 142                 },
 143                 {
 144                         []string{"-config=-"},
 145                         []string{"-config=-"},
 146                 },
 147                 {
 148                         []string{"-config="},
 149                         []string{"-config="},
 150                 },
 151                 {
 152                         []string{"-foo=bar", "baz", "-config"},
 153                         []string{"-foo=bar", "baz", "-config"},
 154                 },
 155                 {
 156                         []string{},
 157                         nil,
 158                 },
 159         } {
 160                 var logbuf bytes.Buffer
 161                 logger := logrus.New()
 162                 logger.Out = &logbuf
 163
 164                 var ldr Loader
 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`)
 169                 }
 170         }
 171 }
 172
 173 func (s *LoadSuite) TestSampleKeys(c *check.C) {
 174         for _, yaml := range []string{
 175                 `{"Clusters":{"z1111":{}}}`,
 176                 `{"Clusters":{"z1111":{"InstanceTypes":{"Foo":{"RAM": "12345M"}}}}}`,
 177         } {
 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)
 187                 }
 188         }
 189 }
 190
 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")
 202 }
 203
 204 func (s *LoadSuite) TestDeprecatedOrUnknownWarning(c *check.C) {
 205         var logbuf bytes.Buffer
 206         _, err := testLoader(c, `
 207 Clusters:
 208   zzzzz:
 209     ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 210     SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 211     Collections:
 212      BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 213     PostgreSQL: {}
 214     BadKey1: {}
 215     Containers:
 216       RunTimeEngine: abc
 217     RemoteClusters:
 218       z2222:
 219         Host: z2222.arvadosapi.com
 220         Proxy: true
 221         BadKey2: badValue
 222     Services:
 223       KeepStore:
 224         InternalURLs:
 225           "http://host.example:12345": {}
 226       Keepstore:
 227         InternalURLs:
 228           "http://host.example:12345":
 229             RendezVous: x
 230     ServiceS:
 231       Keepstore:
 232         InternalURLs:
 233           "http://host.example:12345": {}
 234     Volumes:
 235       zzzzz-nyw5e-aaaaaaaaaaaaaaa: {Replication: 2}
 236 `, &logbuf).Load()
 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).*`)
 242         }
 243         c.Check(logs, check.HasLen, 6)
 244 }
 245
 246 func (s *LoadSuite) checkSAMPLEKeys(c *check.C, path string, x interface{}) {
 247         v := reflect.Indirect(reflect.ValueOf(x))
 248         switch v.Kind() {
 249         case reflect.Map:
 250                 var stringKeys, sampleKey bool
 251                 iter := v.MapRange()
 252                 for iter.Next() {
 253                         k := iter.Key()
 254                         if k.Kind() == reflect.String {
 255                                 stringKeys = true
 256                                 if k.String() == "SAMPLE" || k.String() == "xxxxx" {
 257                                         sampleKey = true
 258                                         s.checkSAMPLEKeys(c, path+"."+k.String(), iter.Value().Interface())
 259                                 }
 260                         }
 261                 }
 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)
 264                 }
 265                 return
 266         case reflect.Struct:
 267                 for i := 0; i < v.NumField(); i++ {
 268                         val := v.Field(i)
 269                         if val.CanInterface() {
 270                                 s.checkSAMPLEKeys(c, path+"."+v.Type().Field(i).Name, val.Interface())
 271                         }
 272                 }
 273         }
 274 }
 275
 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)
 282 }
 283
 284 func (s *LoadSuite) TestNoUnrecognizedKeysInDefaultConfig(c *check.C) {
 285         var logbuf bytes.Buffer
 286         var supplied map[string]interface{}
 287         yaml.Unmarshal(DefaultYAML, &supplied)
 288
 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)
 297
 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.*`)
 301         logbuf.Reset()
 302         loader.logExtraKeys(loaded, supplied, "")
 303         c.Check(logbuf.String(), check.Equals, "")
 304 }
 305
 306 func (s *LoadSuite) TestNoWarningsForDumpedConfig(c *check.C) {
 307         var logbuf bytes.Buffer
 308         cfg, err := testLoader(c, `
 309 Clusters:
 310  zzzzz:
 311   ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 312   SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 313   Collections:
 314    BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 315   InstanceTypes:
 316    abc:
 317     IncludedScratch: 123456
 318 `, &logbuf).Load()
 319         c.Assert(err, check.IsNil)
 320         yaml, err := yaml.Marshal(cfg)
 321         c.Assert(err, check.IsNil)
 322         cfgDumped, err := testLoader(c, string(yaml), &logbuf).Load()
 323         c.Assert(err, check.IsNil)
 324         c.Check(cfg, check.DeepEquals, cfgDumped)
 325         c.Check(logbuf.String(), check.Equals, "")
 326 }
 327
 328 func (s *LoadSuite) TestUnacceptableTokens(c *check.C) {
 329         for _, trial := range []struct {
 330                 short      bool
 331                 configPath string
 332                 example    string
 333         }{
 334                 {false, "SystemRootToken", "SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa_b_c"},
 335                 {false, "ManagementToken", "ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa b c"},
 336                 {false, "ManagementToken", "ManagementToken: \"$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabc\""},
 337                 {false, "Collections.BlobSigningKey", "Collections: {BlobSigningKey: \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa⛵\"}"},
 338                 {true, "SystemRootToken", "SystemRootToken: a_b_c"},
 339                 {true, "ManagementToken", "ManagementToken: a b c"},
 340                 {true, "ManagementToken", "ManagementToken: \"$abc\""},
 341                 {true, "Collections.BlobSigningKey", "Collections: {BlobSigningKey: \"⛵\"}"},
 342         } {
 343                 c.Logf("trying bogus config: %s", trial.example)
 344                 _, err := testLoader(c, "Clusters:\n zzzzz:\n  "+trial.example, nil).Load()
 345                 c.Check(err, check.ErrorMatches, `Clusters.zzzzz.`+trial.configPath+`: unacceptable characters in token.*`)
 346         }
 347 }
 348
 349 func (s *LoadSuite) TestPostgreSQLKeyConflict(c *check.C) {
 350         _, err := testLoader(c, `
 351 Clusters:
 352  zzzzz:
 353   PostgreSQL:
 354    Connection:
 355      DBName: dbname
 356      Host: host
 357 `, nil).Load()
 358         c.Check(err, check.ErrorMatches, `Clusters.zzzzz.PostgreSQL.Connection: multiple entries for "(dbname|host)".*`)
 359 }
 360
 361 func (s *LoadSuite) TestBadClusterIDs(c *check.C) {
 362         for _, data := range []string{`
 363 Clusters:
 364  123456:
 365   ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 366   SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 367   Collections:
 368    BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 369 `, `
 370 Clusters:
 371  12345:
 372   ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 373   SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 374   Collections:
 375    BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 376   RemoteClusters:
 377    Zzzzz:
 378     Host: Zzzzz.arvadosapi.com
 379     Proxy: true
 380 `, `
 381 Clusters:
 382  abcde:
 383   ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 384   SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 385   Collections:
 386    BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 387   Login:
 388    LoginCluster: zz-zz
 389 `,
 390         } {
 391                 c.Log(data)
 392                 v, err := testLoader(c, data, nil).Load()
 393                 if v != nil {
 394                         c.Logf("%#v", v.Clusters)
 395                 }
 396                 c.Check(err, check.ErrorMatches, `.*cluster ID should be 5 lowercase alphanumeric characters.*`)
 397         }
 398 }
 399
 400 func (s *LoadSuite) TestBadType(c *check.C) {
 401         for _, data := range []string{`
 402 Clusters:
 403  zzzzz:
 404   PostgreSQL: true
 405 `, `
 406 Clusters:
 407  zzzzz:
 408   PostgreSQL:
 409    ConnectionPool: true
 410 `, `
 411 Clusters:
 412  zzzzz:
 413   PostgreSQL:
 414    ConnectionPool: "foo"
 415 `, `
 416 Clusters:
 417  zzzzz:
 418   PostgreSQL:
 419    ConnectionPool: []
 420 `, `
 421 Clusters:
 422  zzzzz:
 423   PostgreSQL:
 424    ConnectionPool: [] # {foo: bar} isn't caught here; we rely on config-check
 425 `,
 426         } {
 427                 c.Log(data)
 428                 v, err := testLoader(c, data, nil).Load()
 429                 if v != nil {
 430                         c.Logf("%#v", v.Clusters["zzzzz"].PostgreSQL.ConnectionPool)
 431                 }
 432                 c.Check(err, check.ErrorMatches, `.*cannot unmarshal .*PostgreSQL.*`)
 433         }
 434 }
 435
 436 func (s *LoadSuite) TestMovedKeys(c *check.C) {
 437         checkEquivalent(c, `# config has old keys only
 438 Clusters:
 439  zzzzz:
 440   RequestLimits:
 441    MultiClusterRequestConcurrency: 3
 442    MaxItemsPerResponse: 999
 443 `, `
 444 Clusters:
 445  zzzzz:
 446   API:
 447    MaxRequestAmplification: 3
 448    MaxItemsPerResponse: 999
 449 `)
 450         checkEquivalent(c, `# config has both old and new keys; old values win
 451 Clusters:
 452  zzzzz:
 453   RequestLimits:
 454    MultiClusterRequestConcurrency: 0
 455    MaxItemsPerResponse: 555
 456   API:
 457    MaxRequestAmplification: 3
 458    MaxItemsPerResponse: 999
 459 `, `
 460 Clusters:
 461  zzzzz:
 462   API:
 463    MaxRequestAmplification: 0
 464    MaxItemsPerResponse: 555
 465 `)
 466 }
 467
 468 func checkEquivalent(c *check.C, goty, expectedy string) string {
 469         var logbuf bytes.Buffer
 470         gotldr := testLoader(c, goty, &logbuf)
 471         expectedldr := testLoader(c, expectedy, nil)
 472         checkEquivalentLoaders(c, gotldr, expectedldr)
 473         return logbuf.String()
 474 }
 475
 476 func checkEqualYAML(c *check.C, got, expected interface{}) {
 477         expectedyaml, err := yaml.Marshal(expected)
 478         c.Assert(err, check.IsNil)
 479         gotyaml, err := yaml.Marshal(got)
 480         c.Assert(err, check.IsNil)
 481         if !bytes.Equal(gotyaml, expectedyaml) {
 482                 cmd := exec.Command("diff", "-u", "--label", "expected", "--label", "got", "/dev/fd/3", "/dev/fd/4")
 483                 for _, y := range [][]byte{expectedyaml, gotyaml} {
 484                         pr, pw, err := os.Pipe()
 485                         c.Assert(err, check.IsNil)
 486                         defer pr.Close()
 487                         go func(data []byte) {
 488                                 pw.Write(data)
 489                                 pw.Close()
 490                         }(y)
 491                         cmd.ExtraFiles = append(cmd.ExtraFiles, pr)
 492                 }
 493                 diff, err := cmd.CombinedOutput()
 494                 // diff should report differences and exit non-zero.
 495                 c.Check(err, check.NotNil)
 496                 c.Log(string(diff))
 497                 c.Error("got != expected; see diff (-expected +got) above")
 498         }
 499 }
 500
 501 func checkEquivalentLoaders(c *check.C, gotldr, expectedldr *Loader) {
 502         got, err := gotldr.Load()
 503         c.Assert(err, check.IsNil)
 504         expected, err := expectedldr.Load()
 505         c.Assert(err, check.IsNil)
 506         checkEqualYAML(c, got, expected)
 507 }
 508
 509 func checkListKeys(path string, x interface{}) (err error) {
 510         v := reflect.Indirect(reflect.ValueOf(x))
 511         switch v.Kind() {
 512         case reflect.Map:
 513                 iter := v.MapRange()
 514                 for iter.Next() {
 515                         k := iter.Key()
 516                         if k.Kind() == reflect.String {
 517                                 if err = checkListKeys(path+"."+k.String(), iter.Value().Interface()); err != nil {
 518                                         return
 519                                 }
 520                         }
 521                 }
 522                 return
 523
 524         case reflect.Struct:
 525                 for i := 0; i < v.NumField(); i++ {
 526                         val := v.Field(i)
 527                         structField := v.Type().Field(i)
 528                         fieldname := structField.Name
 529                         endsWithList := strings.HasSuffix(fieldname, "List")
 530                         isAnArray := structField.Type.Kind() == reflect.Slice
 531                         if endsWithList != isAnArray {
 532                                 if endsWithList {
 533                                         err = fmt.Errorf("%s.%s ends with 'List' but field is not an array (type %v)", path, fieldname, val.Kind())
 534                                         return
 535                                 }
 536                                 if isAnArray && structField.Type.Elem().Kind() != reflect.Uint8 {
 537                                         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())
 538                                         return
 539                                 }
 540                         }
 541                         if val.CanInterface() {
 542                                 checkListKeys(path+"."+fieldname, val.Interface())
 543                         }
 544                 }
 545         }
 546         return
 547 }
 548
 549 func (s *LoadSuite) TestListKeys(c *check.C) {
 550         v1 := struct {
 551                 EndInList []string
 552         }{[]string{"a", "b"}}
 553         var m1 = make(map[string]interface{})
 554         m1["c"] = &v1
 555         if err := checkListKeys("", m1); err != nil {
 556                 c.Error(err)
 557         }
 558
 559         v2 := struct {
 560                 DoesNot []string
 561         }{[]string{"a", "b"}}
 562         var m2 = make(map[string]interface{})
 563         m2["c"] = &v2
 564         if err := checkListKeys("", m2); err == nil {
 565                 c.Errorf("Should have produced an error")
 566         }
 567
 568         v3 := struct {
 569                 EndInList string
 570         }{"a"}
 571         var m3 = make(map[string]interface{})
 572         m3["c"] = &v3
 573         if err := checkListKeys("", m3); err == nil {
 574                 c.Errorf("Should have produced an error")
 575         }
 576
 577         loader := testLoader(c, string(DefaultYAML), nil)
 578         cfg, err := loader.Load()
 579         c.Assert(err, check.IsNil)
 580         if err := checkListKeys("", cfg); err != nil {
 581                 c.Error(err)
 582         }
 583 }
 584
 585 func (s *LoadSuite) TestWarnUnusedLocalKeep(c *check.C) {
 586         var logbuf bytes.Buffer
 587         _, err := testLoader(c, `
 588 Clusters:
 589  z1111:
 590   Volumes:
 591    z:
 592     Replication: 1
 593 `, &logbuf).Load()
 594         c.Assert(err, check.IsNil)
 595         c.Check(logbuf.String(), check.Matches, `(?ms).*LocalKeepBlobBuffersPerVCPU is 1 but will not be used because at least one volume \(z\) has lower replication than DefaultReplication \(1 < 2\) -- suggest changing to 0.*`)
 596
 597         logbuf.Reset()
 598         _, err = testLoader(c, `
 599 Clusters:
 600  z1111:
 601   Volumes:
 602    z:
 603     AccessViaHosts:
 604      "http://0.0.0.0:12345": {}
 605 `, &logbuf).Load()
 606         c.Assert(err, check.IsNil)
 607         c.Check(logbuf.String(), check.Matches, `(?ms).*LocalKeepBlobBuffersPerVCPU is 1 but will not be used because at least one volume \(z\) uses AccessViaHosts -- suggest changing to 0.*`)
 608 }
 609
 610 func (s *LoadSuite) TestImplicitStorageClasses(c *check.C) {
 611         // If StorageClasses and Volumes.*.StorageClasses are all
 612         // empty, there is a default storage class named "default".
 613         ldr := testLoader(c, `{"Clusters":{"z1111":{}}}`, nil)
 614         cfg, err := ldr.Load()
 615         c.Assert(err, check.IsNil)
 616         cc, err := cfg.GetCluster("z1111")
 617         c.Assert(err, check.IsNil)
 618         c.Check(cc.StorageClasses, check.HasLen, 1)
 619         c.Check(cc.StorageClasses["default"].Default, check.Equals, true)
 620         c.Check(cc.StorageClasses["default"].Priority, check.Equals, 0)
 621
 622         // The implicit "default" storage class is used by all
 623         // volumes.
 624         ldr = testLoader(c, `
 625 Clusters:
 626  z1111:
 627   Volumes:
 628    z: {}`, nil)
 629         cfg, err = ldr.Load()
 630         c.Assert(err, check.IsNil)
 631         cc, err = cfg.GetCluster("z1111")
 632         c.Assert(err, check.IsNil)
 633         c.Check(cc.StorageClasses, check.HasLen, 1)
 634         c.Check(cc.StorageClasses["default"].Default, check.Equals, true)
 635         c.Check(cc.StorageClasses["default"].Priority, check.Equals, 0)
 636         c.Check(cc.Volumes["z"].StorageClasses["default"], check.Equals, true)
 637
 638         // The "default" storage class isn't implicit if any classes
 639         // are configured explicitly.
 640         ldr = testLoader(c, `
 641 Clusters:
 642  z1111:
 643   StorageClasses:
 644    local:
 645     Default: true
 646     Priority: 111
 647   Volumes:
 648    z:
 649     StorageClasses:
 650      local: true`, nil)
 651         cfg, err = ldr.Load()
 652         c.Assert(err, check.IsNil)
 653         cc, err = cfg.GetCluster("z1111")
 654         c.Assert(err, check.IsNil)
 655         c.Check(cc.StorageClasses, check.HasLen, 1)
 656         c.Check(cc.StorageClasses["local"].Default, check.Equals, true)
 657         c.Check(cc.StorageClasses["local"].Priority, check.Equals, 111)
 658
 659         // It is an error for a volume to refer to a storage class
 660         // that isn't listed in StorageClasses.
 661         ldr = testLoader(c, `
 662 Clusters:
 663  z1111:
 664   StorageClasses:
 665    local:
 666     Default: true
 667     Priority: 111
 668   Volumes:
 669    z:
 670     StorageClasses:
 671      nx: true`, nil)
 672         _, err = ldr.Load()
 673         c.Assert(err, check.ErrorMatches, `z: volume refers to storage class "nx" that is not defined.*`)
 674
 675         // It is an error for a volume to refer to a storage class
 676         // that isn't listed in StorageClasses ... even if it's
 677         // "default", which would exist implicitly if it weren't
 678         // referenced explicitly by a volume.
 679         ldr = testLoader(c, `
 680 Clusters:
 681  z1111:
 682   Volumes:
 683    z:
 684     StorageClasses:
 685      default: true`, nil)
 686         _, err = ldr.Load()
 687         c.Assert(err, check.ErrorMatches, `z: volume refers to storage class "default" that is not defined.*`)
 688
 689         // If the "default" storage class is configured explicitly, it
 690         // is not used implicitly by any volumes, even if it's the
 691         // only storage class.
 692         var logbuf bytes.Buffer
 693         ldr = testLoader(c, `
 694 Clusters:
 695  z1111:
 696   StorageClasses:
 697    default:
 698     Default: true
 699     Priority: 111
 700   Volumes:
 701    z: {}`, &logbuf)
 702         _, err = ldr.Load()
 703         c.Assert(err, check.ErrorMatches, `z: volume has no StorageClasses listed`)
 704
 705         // If StorageClasses are configured explicitly, there must be
 706         // at least one with Default: true. (Calling one "default" is
 707         // not sufficient.)
 708         ldr = testLoader(c, `
 709 Clusters:
 710  z1111:
 711   StorageClasses:
 712    default:
 713     Priority: 111
 714   Volumes:
 715    z:
 716     StorageClasses:
 717      default: true`, nil)
 718         _, err = ldr.Load()
 719         c.Assert(err, check.ErrorMatches, `there is no default storage class.*`)
 720 }
 721
 722 func (s *LoadSuite) TestPreemptiblePriceFactor(c *check.C) {
 723         yaml := `
 724 Clusters:
 725  z1111:
 726   InstanceTypes:
 727    Type1:
 728     RAM: 12345M
 729     VCPUs: 8
 730     Price: 1.23
 731  z2222:
 732   Containers:
 733    PreemptiblePriceFactor: 0.5
 734   InstanceTypes:
 735    Type1:
 736     RAM: 12345M
 737     VCPUs: 8
 738     Price: 1.23
 739  z3333:
 740   Containers:
 741    PreemptiblePriceFactor: 0.5
 742   InstanceTypes:
 743    Type1:
 744     RAM: 12345M
 745     VCPUs: 8
 746     Price: 1.23
 747    Type1.preemptible: # higher price than the auto-added variant would use -- should generate warning
 748     ProviderType: Type1
 749     RAM: 12345M
 750     VCPUs: 8
 751     Price: 1.23
 752     Preemptible: true
 753    Type2:
 754     RAM: 23456M
 755     VCPUs: 16
 756     Price: 2.46
 757    Type2.preemptible: # identical to the auto-added variant -- so no warning
 758     ProviderType: Type2
 759     RAM: 23456M
 760     VCPUs: 16
 761     Price: 1.23
 762     Preemptible: true
 763 `
 764         var logbuf bytes.Buffer
 765         cfg, err := testLoader(c, yaml, &logbuf).Load()
 766         c.Assert(err, check.IsNil)
 767         cc, err := cfg.GetCluster("z1111")
 768         c.Assert(err, check.IsNil)
 769         c.Check(cc.InstanceTypes["Type1"].Price, check.Equals, 1.23)
 770         c.Check(cc.InstanceTypes, check.HasLen, 1)
 771
 772         cc, err = cfg.GetCluster("z2222")
 773         c.Assert(err, check.IsNil)
 774         c.Check(cc.InstanceTypes["Type1"].Preemptible, check.Equals, false)
 775         c.Check(cc.InstanceTypes["Type1"].Price, check.Equals, 1.23)
 776         c.Check(cc.InstanceTypes["Type1.preemptible"].Preemptible, check.Equals, true)
 777         c.Check(cc.InstanceTypes["Type1.preemptible"].Price, check.Equals, 1.23/2)
 778         c.Check(cc.InstanceTypes["Type1.preemptible"].ProviderType, check.Equals, "Type1")
 779         c.Check(cc.InstanceTypes, check.HasLen, 2)
 780
 781         cc, err = cfg.GetCluster("z3333")
 782         c.Assert(err, check.IsNil)
 783         // Don't overwrite the explicitly configured preemptible variant
 784         c.Check(cc.InstanceTypes["Type1.preemptible"].Price, check.Equals, 1.23)
 785         c.Check(cc.InstanceTypes, check.HasLen, 4)
 786         c.Check(logbuf.String(), check.Matches, `(?ms).*Clusters\.z3333\.InstanceTypes\[Type1\.preemptible\]: already exists, so not automatically adding a preemptible variant of Type1.*`)
 787         c.Check(logbuf.String(), check.Not(check.Matches), `(?ms).*Type2\.preemptible.*`)
 788         c.Check(logbuf.String(), check.Not(check.Matches), `(?ms).*(z1111|z2222)[^\n]*InstanceTypes.*`)
 789 }