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: {}
 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`, &logbuf).Load()
 315         c.Assert(err, check.IsNil)
 316         yaml, err := yaml.Marshal(cfg)
 317         c.Assert(err, check.IsNil)
 318         cfgDumped, err := testLoader(c, string(yaml), &logbuf).Load()
 319         c.Assert(err, check.IsNil)
 320         c.Check(cfg, check.DeepEquals, cfgDumped)
 321         c.Check(logbuf.String(), check.Equals, "")
 322 }
 323
 324 func (s *LoadSuite) TestUnacceptableTokens(c *check.C) {
 325         for _, trial := range []struct {
 326                 short      bool
 327                 configPath string
 328                 example    string
 329         }{
 330                 {false, "SystemRootToken", "SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa_b_c"},
 331                 {false, "ManagementToken", "ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa b c"},
 332                 {false, "ManagementToken", "ManagementToken: \"$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabc\""},
 333                 {false, "Collections.BlobSigningKey", "Collections: {BlobSigningKey: \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa⛵\"}"},
 334                 {true, "SystemRootToken", "SystemRootToken: a_b_c"},
 335                 {true, "ManagementToken", "ManagementToken: a b c"},
 336                 {true, "ManagementToken", "ManagementToken: \"$abc\""},
 337                 {true, "Collections.BlobSigningKey", "Collections: {BlobSigningKey: \"⛵\"}"},
 338         } {
 339                 c.Logf("trying bogus config: %s", trial.example)
 340                 _, err := testLoader(c, "Clusters:\n zzzzz:\n  "+trial.example, nil).Load()
 341                 c.Check(err, check.ErrorMatches, `Clusters.zzzzz.`+trial.configPath+`: unacceptable characters in token.*`)
 342         }
 343 }
 344
 345 func (s *LoadSuite) TestPostgreSQLKeyConflict(c *check.C) {
 346         _, err := testLoader(c, `
 347 Clusters:
 348  zzzzz:
 349   PostgreSQL:
 350    Connection:
 351      DBName: dbname
 352      Host: host
 353 `, nil).Load()
 354         c.Check(err, check.ErrorMatches, `Clusters.zzzzz.PostgreSQL.Connection: multiple entries for "(dbname|host)".*`)
 355 }
 356
 357 func (s *LoadSuite) TestBadClusterIDs(c *check.C) {
 358         for _, data := range []string{`
 359 Clusters:
 360  123456:
 361   ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 362   SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 363   Collections:
 364    BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 365 `, `
 366 Clusters:
 367  12345:
 368   ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 369   SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 370   Collections:
 371    BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 372   RemoteClusters:
 373    Zzzzz:
 374     Host: Zzzzz.arvadosapi.com
 375     Proxy: true
 376 `, `
 377 Clusters:
 378  abcde:
 379   ManagementToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 380   SystemRootToken: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 381   Collections:
 382    BlobSigningKey: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 383   Login:
 384    LoginCluster: zz-zz
 385 `,
 386         } {
 387                 c.Log(data)
 388                 v, err := testLoader(c, data, nil).Load()
 389                 if v != nil {
 390                         c.Logf("%#v", v.Clusters)
 391                 }
 392                 c.Check(err, check.ErrorMatches, `.*cluster ID should be 5 alphanumeric characters.*`)
 393         }
 394 }
 395
 396 func (s *LoadSuite) TestBadType(c *check.C) {
 397         for _, data := range []string{`
 398 Clusters:
 399  zzzzz:
 400   PostgreSQL: true
 401 `, `
 402 Clusters:
 403  zzzzz:
 404   PostgreSQL:
 405    ConnectionPool: true
 406 `, `
 407 Clusters:
 408  zzzzz:
 409   PostgreSQL:
 410    ConnectionPool: "foo"
 411 `, `
 412 Clusters:
 413  zzzzz:
 414   PostgreSQL:
 415    ConnectionPool: []
 416 `, `
 417 Clusters:
 418  zzzzz:
 419   PostgreSQL:
 420    ConnectionPool: [] # {foo: bar} isn't caught here; we rely on config-check
 421 `,
 422         } {
 423                 c.Log(data)
 424                 v, err := testLoader(c, data, nil).Load()
 425                 if v != nil {
 426                         c.Logf("%#v", v.Clusters["zzzzz"].PostgreSQL.ConnectionPool)
 427                 }
 428                 c.Check(err, check.ErrorMatches, `.*cannot unmarshal .*PostgreSQL.*`)
 429         }
 430 }
 431
 432 func (s *LoadSuite) TestMovedKeys(c *check.C) {
 433         checkEquivalent(c, `# config has old keys only
 434 Clusters:
 435  zzzzz:
 436   RequestLimits:
 437    MultiClusterRequestConcurrency: 3
 438    MaxItemsPerResponse: 999
 439 `, `
 440 Clusters:
 441  zzzzz:
 442   API:
 443    MaxRequestAmplification: 3
 444    MaxItemsPerResponse: 999
 445 `)
 446         checkEquivalent(c, `# config has both old and new keys; old values win
 447 Clusters:
 448  zzzzz:
 449   RequestLimits:
 450    MultiClusterRequestConcurrency: 0
 451    MaxItemsPerResponse: 555
 452   API:
 453    MaxRequestAmplification: 3
 454    MaxItemsPerResponse: 999
 455 `, `
 456 Clusters:
 457  zzzzz:
 458   API:
 459    MaxRequestAmplification: 0
 460    MaxItemsPerResponse: 555
 461 `)
 462 }
 463
 464 func checkEquivalent(c *check.C, goty, expectedy string) string {
 465         var logbuf bytes.Buffer
 466         gotldr := testLoader(c, goty, &logbuf)
 467         expectedldr := testLoader(c, expectedy, nil)
 468         checkEquivalentLoaders(c, gotldr, expectedldr)
 469         return logbuf.String()
 470 }
 471
 472 func checkEqualYAML(c *check.C, got, expected interface{}) {
 473         expectedyaml, err := yaml.Marshal(expected)
 474         c.Assert(err, check.IsNil)
 475         gotyaml, err := yaml.Marshal(got)
 476         c.Assert(err, check.IsNil)
 477         if !bytes.Equal(gotyaml, expectedyaml) {
 478                 cmd := exec.Command("diff", "-u", "--label", "expected", "--label", "got", "/dev/fd/3", "/dev/fd/4")
 479                 for _, y := range [][]byte{expectedyaml, gotyaml} {
 480                         pr, pw, err := os.Pipe()
 481                         c.Assert(err, check.IsNil)
 482                         defer pr.Close()
 483                         go func(data []byte) {
 484                                 pw.Write(data)
 485                                 pw.Close()
 486                         }(y)
 487                         cmd.ExtraFiles = append(cmd.ExtraFiles, pr)
 488                 }
 489                 diff, err := cmd.CombinedOutput()
 490                 // diff should report differences and exit non-zero.
 491                 c.Check(err, check.NotNil)
 492                 c.Log(string(diff))
 493                 c.Error("got != expected; see diff (-expected +got) above")
 494         }
 495 }
 496
 497 func checkEquivalentLoaders(c *check.C, gotldr, expectedldr *Loader) {
 498         got, err := gotldr.Load()
 499         c.Assert(err, check.IsNil)
 500         expected, err := expectedldr.Load()
 501         c.Assert(err, check.IsNil)
 502         checkEqualYAML(c, got, expected)
 503 }
 504
 505 func checkListKeys(path string, x interface{}) (err error) {
 506         v := reflect.Indirect(reflect.ValueOf(x))
 507         switch v.Kind() {
 508         case reflect.Map:
 509                 iter := v.MapRange()
 510                 for iter.Next() {
 511                         k := iter.Key()
 512                         if k.Kind() == reflect.String {
 513                                 if err = checkListKeys(path+"."+k.String(), iter.Value().Interface()); err != nil {
 514                                         return
 515                                 }
 516                         }
 517                 }
 518                 return
 519
 520         case reflect.Struct:
 521                 for i := 0; i < v.NumField(); i++ {
 522                         val := v.Field(i)
 523                         structField := v.Type().Field(i)
 524                         fieldname := structField.Name
 525                         endsWithList := strings.HasSuffix(fieldname, "List")
 526                         isAnArray := structField.Type.Kind() == reflect.Slice
 527                         if endsWithList != isAnArray {
 528                                 if endsWithList {
 529                                         err = fmt.Errorf("%s.%s ends with 'List' but field is not an array (type %v)", path, fieldname, val.Kind())
 530                                         return
 531                                 }
 532                                 if isAnArray && structField.Type.Elem().Kind() != reflect.Uint8 {
 533                                         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())
 534                                         return
 535                                 }
 536                         }
 537                         if val.CanInterface() {
 538                                 checkListKeys(path+"."+fieldname, val.Interface())
 539                         }
 540                 }
 541         }
 542         return
 543 }
 544
 545 func (s *LoadSuite) TestListKeys(c *check.C) {
 546         v1 := struct {
 547                 EndInList []string
 548         }{[]string{"a", "b"}}
 549         var m1 = make(map[string]interface{})
 550         m1["c"] = &v1
 551         if err := checkListKeys("", m1); err != nil {
 552                 c.Error(err)
 553         }
 554
 555         v2 := struct {
 556                 DoesNot []string
 557         }{[]string{"a", "b"}}
 558         var m2 = make(map[string]interface{})
 559         m2["c"] = &v2
 560         if err := checkListKeys("", m2); err == nil {
 561                 c.Errorf("Should have produced an error")
 562         }
 563
 564         v3 := struct {
 565                 EndInList string
 566         }{"a"}
 567         var m3 = make(map[string]interface{})
 568         m3["c"] = &v3
 569         if err := checkListKeys("", m3); err == nil {
 570                 c.Errorf("Should have produced an error")
 571         }
 572
 573         loader := testLoader(c, string(DefaultYAML), nil)
 574         cfg, err := loader.Load()
 575         c.Assert(err, check.IsNil)
 576         if err := checkListKeys("", cfg); err != nil {
 577                 c.Error(err)
 578         }
 579 }
 580
 581 func (s *LoadSuite) TestImplicitStorageClasses(c *check.C) {
 582         // If StorageClasses and Volumes.*.StorageClasses are all
 583         // empty, there is a default storage class named "default".
 584         ldr := testLoader(c, `{"Clusters":{"z1111":{}}}`, nil)
 585         cfg, err := ldr.Load()
 586         c.Assert(err, check.IsNil)
 587         cc, err := cfg.GetCluster("z1111")
 588         c.Assert(err, check.IsNil)
 589         c.Check(cc.StorageClasses, check.HasLen, 1)
 590         c.Check(cc.StorageClasses["default"].Default, check.Equals, true)
 591         c.Check(cc.StorageClasses["default"].Priority, check.Equals, 0)
 592
 593         // The implicit "default" storage class is used by all
 594         // volumes.
 595         ldr = testLoader(c, `
 596 Clusters:
 597  z1111:
 598   Volumes:
 599    z: {}`, nil)
 600         cfg, err = ldr.Load()
 601         c.Assert(err, check.IsNil)
 602         cc, err = cfg.GetCluster("z1111")
 603         c.Assert(err, check.IsNil)
 604         c.Check(cc.StorageClasses, check.HasLen, 1)
 605         c.Check(cc.StorageClasses["default"].Default, check.Equals, true)
 606         c.Check(cc.StorageClasses["default"].Priority, check.Equals, 0)
 607         c.Check(cc.Volumes["z"].StorageClasses["default"], check.Equals, true)
 608
 609         // The "default" storage class isn't implicit if any classes
 610         // are configured explicitly.
 611         ldr = testLoader(c, `
 612 Clusters:
 613  z1111:
 614   StorageClasses:
 615    local:
 616     Default: true
 617     Priority: 111
 618   Volumes:
 619    z:
 620     StorageClasses:
 621      local: true`, nil)
 622         cfg, err = ldr.Load()
 623         c.Assert(err, check.IsNil)
 624         cc, err = cfg.GetCluster("z1111")
 625         c.Assert(err, check.IsNil)
 626         c.Check(cc.StorageClasses, check.HasLen, 1)
 627         c.Check(cc.StorageClasses["local"].Default, check.Equals, true)
 628         c.Check(cc.StorageClasses["local"].Priority, check.Equals, 111)
 629
 630         // It is an error for a volume to refer to a storage class
 631         // that isn't listed in StorageClasses.
 632         ldr = testLoader(c, `
 633 Clusters:
 634  z1111:
 635   StorageClasses:
 636    local:
 637     Default: true
 638     Priority: 111
 639   Volumes:
 640    z:
 641     StorageClasses:
 642      nx: true`, nil)
 643         _, err = ldr.Load()
 644         c.Assert(err, check.ErrorMatches, `z: volume refers to storage class "nx" that is not defined.*`)
 645
 646         // It is an error for a volume to refer to a storage class
 647         // that isn't listed in StorageClasses ... even if it's
 648         // "default", which would exist implicitly if it weren't
 649         // referenced explicitly by a volume.
 650         ldr = testLoader(c, `
 651 Clusters:
 652  z1111:
 653   Volumes:
 654    z:
 655     StorageClasses:
 656      default: true`, nil)
 657         _, err = ldr.Load()
 658         c.Assert(err, check.ErrorMatches, `z: volume refers to storage class "default" that is not defined.*`)
 659
 660         // If the "default" storage class is configured explicitly, it
 661         // is not used implicitly by any volumes, even if it's the
 662         // only storage class.
 663         var logbuf bytes.Buffer
 664         ldr = testLoader(c, `
 665 Clusters:
 666  z1111:
 667   StorageClasses:
 668    default:
 669     Default: true
 670     Priority: 111
 671   Volumes:
 672    z: {}`, &logbuf)
 673         _, err = ldr.Load()
 674         c.Assert(err, check.ErrorMatches, `z: volume has no StorageClasses listed`)
 675
 676         // If StorageClasses are configured explicitly, there must be
 677         // at least one with Default: true. (Calling one "default" is
 678         // not sufficient.)
 679         ldr = testLoader(c, `
 680 Clusters:
 681  z1111:
 682   StorageClasses:
 683    default:
 684     Priority: 111
 685   Volumes:
 686    z:
 687     StorageClasses:
 688      default: true`, nil)
 689         _, err = ldr.Load()
 690         c.Assert(err, check.ErrorMatches, `there is no default storage class.*`)
 691 }
 692
 693 func (s *LoadSuite) TestPreemptiblePriceFactor(c *check.C) {
 694         yaml := `
 695 Clusters:
 696  z1111:
 697   InstanceTypes:
 698    Type1:
 699     RAM: 12345M
 700     VCPUs: 8
 701     Price: 1.23
 702  z2222:
 703   Containers:
 704    PreemptiblePriceFactor: 0.5
 705   InstanceTypes:
 706    Type1:
 707     RAM: 12345M
 708     VCPUs: 8
 709     Price: 1.23
 710  z3333:
 711   Containers:
 712    PreemptiblePriceFactor: 0.5
 713   InstanceTypes:
 714    Type1:
 715     RAM: 12345M
 716     VCPUs: 8
 717     Price: 1.23
 718    Type1.preemptible: # higher price than the auto-added variant would use -- should generate warning
 719     ProviderType: Type1
 720     RAM: 12345M
 721     VCPUs: 8
 722     Price: 1.23
 723     Preemptible: true
 724    Type2:
 725     RAM: 23456M
 726     VCPUs: 16
 727     Price: 2.46
 728    Type2.preemptible: # identical to the auto-added variant -- so no warning
 729     ProviderType: Type2
 730     RAM: 23456M
 731     VCPUs: 16
 732     Price: 1.23
 733     Preemptible: true
 734 `
 735         var logbuf bytes.Buffer
 736         cfg, err := testLoader(c, yaml, &logbuf).Load()
 737         c.Assert(err, check.IsNil)
 738         cc, err := cfg.GetCluster("z1111")
 739         c.Assert(err, check.IsNil)
 740         c.Check(cc.InstanceTypes["Type1"].Price, check.Equals, 1.23)
 741         c.Check(cc.InstanceTypes, check.HasLen, 1)
 742
 743         cc, err = cfg.GetCluster("z2222")
 744         c.Assert(err, check.IsNil)
 745         c.Check(cc.InstanceTypes["Type1"].Preemptible, check.Equals, false)
 746         c.Check(cc.InstanceTypes["Type1"].Price, check.Equals, 1.23)
 747         c.Check(cc.InstanceTypes["Type1.preemptible"].Preemptible, check.Equals, true)
 748         c.Check(cc.InstanceTypes["Type1.preemptible"].Price, check.Equals, 1.23/2)
 749         c.Check(cc.InstanceTypes["Type1.preemptible"].ProviderType, check.Equals, "Type1")
 750         c.Check(cc.InstanceTypes, check.HasLen, 2)
 751
 752         cc, err = cfg.GetCluster("z3333")
 753         c.Assert(err, check.IsNil)
 754         // Don't overwrite the explicitly configured preemptible variant
 755         c.Check(cc.InstanceTypes["Type1.preemptible"].Price, check.Equals, 1.23)
 756         c.Check(cc.InstanceTypes, check.HasLen, 4)
 757         c.Check(logbuf.String(), check.Matches, `(?ms).*Clusters\.z3333\.InstanceTypes\[Type1\.preemptible\]: already exists, so not automatically adding a preemptible variant of Type1.*`)
 758         c.Check(logbuf.String(), check.Not(check.Matches), `(?ms).*Type2\.preemptible.*`)
 759         c.Check(logbuf.String(), check.Not(check.Matches), `(?ms).*(z1111|z2222)[^\n]*InstanceTypes.*`)
 760 }