func (*configSuite) TestValidateAcceptsUnchangedConfig(c *gc.C) {
attrs := makeAzureConfigMap(c)
provider := azureEnvironProvider{}
oldConfig, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
newConfig, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
result, err := provider.Validate(newConfig, oldConfig)
c.Assert(err, gc.IsNil)
c.Check(result.Name(), gc.Equals, attrs["name"])
}
func (*configSuite) TestValidateChecksConfigChanges(c *gc.C) {
provider := azureEnvironProvider{}
oldConfig, err := config.New(config.NoDefaults, makeConfigMap(nil))
c.Assert(err, gc.IsNil)
newAttrs := makeConfigMap(map[string]interface{}{
"name": "different-name",
})
newConfig, err := config.New(config.NoDefaults, newAttrs)
c.Assert(err, gc.IsNil)
_, err = provider.Validate(newConfig, oldConfig)
c.Check(err, gc.NotNil)
}
// NewFromAttrs returns a new environment based on the provided configuration
// attributes.
// TODO(rog) remove this function - it's almost always wrong to use it.
func NewFromAttrs(attrs map[string]interface{}) (Environ, error) {
cfg, err := config.New(config.NoDefaults, attrs)
if err != nil {
return nil, err
}
return New(cfg)
}
// ConfigForName returns the configuration for the environment with
// the given name from the default environments file. If the name is
// blank, the default environment will be used. If the configuration
// is not found, an errors.NotFoundError is returned. If the given
// store contains an entry for the environment and it has associated
// bootstrap config, that configuration will be returned.
// ConfigForName also returns where the configuration was sourced from
// (this is also valid even when there is an error.
func ConfigForName(name string, store configstore.Storage) (*config.Config, ConfigSource, error) {
envs, err := ReadEnvirons("")
if err != nil {
return nil, ConfigFromNowhere, err
}
if name == "" {
name = envs.Default
}
// TODO(rog) 2013-10-04 https://bugs.github.com/juju/core/+bug/1235217
// Don't fall back to reading from environments.yaml
// when we can be sure that everyone has a
// .jenv file for their currently bootstrapped environments.
if name != "" {
info, err := store.ReadInfo(name)
if err == nil {
if len(info.BootstrapConfig()) == 0 {
return nil, ConfigFromNowhere, EmptyConfig{fmt.Errorf("environment has no bootstrap configuration data")}
}
logger.Debugf("ConfigForName found bootstrap config %#v", info.BootstrapConfig())
cfg, err := config.New(config.NoDefaults, info.BootstrapConfig())
return cfg, ConfigFromInfo, err
}
if err != nil && !errors.IsNotFound(err) {
return nil, ConfigFromInfo, fmt.Errorf("cannot read environment info for %q: %v", name, err)
}
}
cfg, err := envs.Config(name)
return cfg, ConfigFromEnvirons, err
}
func (*NewAPIConnSuite) TestNewConn(c *gc.C) {
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig())
c.Assert(err, gc.IsNil)
ctx := coretesting.Context(c)
env, err := environs.Prepare(cfg, ctx, configstore.NewMem())
c.Assert(err, gc.IsNil)
envtesting.UploadFakeTools(c, env.Storage())
err = bootstrap.Bootstrap(ctx, env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
cfg = env.Config()
cfg, err = cfg.Apply(map[string]interface{}{
"secret": "fnord",
})
c.Assert(err, gc.IsNil)
err = env.SetConfig(cfg)
c.Assert(err, gc.IsNil)
conn, err := juju.NewAPIConn(env, api.DefaultDialOpts())
c.Assert(err, gc.IsNil)
c.Assert(conn.Environ, gc.Equals, env)
c.Assert(conn.State, gc.NotNil)
// the secrets will not be updated, as they already exist
attrs, err := conn.State.Client().EnvironmentGet()
c.Assert(attrs["secret"], gc.Equals, "pork")
c.Assert(conn.Close(), gc.IsNil)
}
func (*configSuite) TestValidateParsesAzureConfig(c *gc.C) {
location := "location"
managementSubscriptionId := "subscription-id"
certificate := "certificate content"
storageAccountName := "account-name"
forceImageName := "force-image-name"
unknownFutureSetting := "preserved"
azureConfig := map[string]interface{}{
"location": location,
"management-subscription-id": managementSubscriptionId,
"management-certificate": certificate,
"storage-account-name": storageAccountName,
"force-image-name": forceImageName,
"unknown-future-setting": unknownFutureSetting,
}
attrs := makeConfigMap(azureConfig)
provider := azureEnvironProvider{}
config, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
azConfig, err := provider.newConfig(config)
c.Assert(err, gc.IsNil)
c.Check(azConfig.Name(), gc.Equals, attrs["name"])
c.Check(azConfig.location(), gc.Equals, location)
c.Check(azConfig.managementSubscriptionId(), gc.Equals, managementSubscriptionId)
c.Check(azConfig.managementCertificate(), gc.Equals, certificate)
c.Check(azConfig.storageAccountName(), gc.Equals, storageAccountName)
c.Check(azConfig.forceImageName(), gc.Equals, forceImageName)
c.Check(azConfig.UnknownAttrs()["unknown-future-setting"], gc.Equals, unknownFutureSetting)
}
func (suite *environSuite) assertGetImageMetadataSources(c *gc.C, stream, officialSourcePath string) {
// Make an env configured with the stream.
testAttrs := maasEnvAttrs
testAttrs = testAttrs.Merge(coretesting.Attrs{
"maas-server": suite.testMAASObject.TestServer.URL,
})
if stream != "" {
testAttrs = testAttrs.Merge(coretesting.Attrs{
"image-stream": stream,
})
}
attrs := coretesting.FakeConfig().Merge(testAttrs)
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
env, err := NewEnviron(cfg)
c.Assert(err, gc.IsNil)
// Add a dummy file to storage so we can use that to check the
// obtained source later.
data := makeRandomBytes(10)
stor := NewStorage(env)
err = stor.Put("images/filename", bytes.NewBuffer([]byte(data)), int64(len(data)))
c.Assert(err, gc.IsNil)
sources, err := imagemetadata.GetMetadataSources(env)
c.Assert(err, gc.IsNil)
c.Assert(len(sources), gc.Equals, 2)
assertSourceContents(c, sources[0], "filename", data)
url, err := sources[1].URL("")
c.Assert(err, gc.IsNil)
c.Assert(url, gc.Equals, fmt.Sprintf("http://cloud-images.ubuntu.com/%s/", officialSourcePath))
}
func getEnvironConfig(c *gc.C, attrs map[string]interface{}) *environConfig {
testConfig, err := config.New(config.UseDefaults, attrs)
c.Assert(err, gc.IsNil)
envConfig, err := manualProvider{}.validate(testConfig, nil)
c.Assert(err, gc.IsNil)
return envConfig
}
func (s *LiveTests) assertStartInstanceDefaultSecurityGroup(c *gc.C, useDefault bool) {
attrs := s.TestConfig.Merge(coretesting.Attrs{
"name": "sample-" + randomName(),
"control-bucket": "juju-test-" + randomName(),
"use-default-secgroup": useDefault,
})
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
// Set up a test environment.
env, err := environs.New(cfg)
c.Assert(err, gc.IsNil)
c.Assert(env, gc.NotNil)
defer env.Destroy()
// Bootstrap and start an instance.
err = bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
inst, _ := jujutesting.AssertStartInstance(c, env, "100")
// Check whether the instance has the default security group assigned.
novaClient := openstack.GetNovaClient(env)
groups, err := novaClient.GetServerSecurityGroups(string(inst.Id()))
c.Assert(err, gc.IsNil)
defaultGroupFound := false
for _, group := range groups {
if group.Name == "default" {
defaultGroupFound = true
break
}
}
c.Assert(defaultGroupFound, gc.Equals, useDefault)
}
func (t *ProviderSuite) assertGetImageMetadataSources(c *gc.C, stream, officialSourcePath string) {
// Make an env configured with the stream.
envAttrs := localConfigAttrs
if stream != "" {
envAttrs = envAttrs.Merge(coretesting.Attrs{
"image-stream": stream,
})
}
cfg, err := config.New(config.NoDefaults, envAttrs)
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, coretesting.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
c.Assert(env, gc.NotNil)
sources, err := imagemetadata.GetMetadataSources(env)
c.Assert(err, gc.IsNil)
c.Assert(len(sources), gc.Equals, 2)
var urls = make([]string, len(sources))
for i, source := range sources {
url, err := source.URL("")
c.Assert(err, gc.IsNil)
urls[i] = url
}
// The control bucket URL contains the bucket name.
c.Check(strings.Contains(urls[0], ec2.ControlBucketName(env)+"/images"), jc.IsTrue)
c.Assert(urls[1], gc.Equals, fmt.Sprintf("http://cloud-images.ubuntu.com/%s/", officialSourcePath))
}
func (s *ConfigSuite) TestFirewallMode(c *gc.C) {
for i, test := range firewallModeTests {
c.Logf("test %d: %s", i, test.configFirewallMode)
attrs := dummy.SampleConfig()
if test.configFirewallMode != "" {
attrs = attrs.Merge(testing.Attrs{
"firewall-mode": test.configFirewallMode,
})
}
cfg, err := config.New(config.NoDefaults, attrs)
if err != nil {
c.Assert(err, gc.ErrorMatches, test.errorMsg)
continue
}
ctx := testing.Context(c)
env, err := environs.Prepare(cfg, ctx, configstore.NewMem())
if test.errorMsg != "" {
c.Assert(err, gc.ErrorMatches, test.errorMsg)
continue
}
c.Assert(err, gc.IsNil)
defer env.Destroy()
firewallMode := env.Config().FirewallMode()
c.Assert(firewallMode, gc.Equals, test.firewallMode)
s.TearDownTest(c)
}
}
func (s *providerSuite) TestPrepareUseSSHStorage(c *gc.C) {
minimal := manual.MinimalConfigValues()
minimal["use-sshstorage"] = false
testConfig, err := config.New(config.UseDefaults, minimal)
c.Assert(err, gc.IsNil)
_, err = manual.ProviderInstance.Prepare(coretesting.Context(c), testConfig)
c.Assert(err, gc.ErrorMatches, "use-sshstorage must not be specified")
s.PatchValue(manual.NewSSHStorage, func(sshHost, storageDir, storageTmpdir string) (storage.Storage, error) {
return nil, fmt.Errorf("newSSHStorage failed")
})
minimal["use-sshstorage"] = true
testConfig, err = config.New(config.UseDefaults, minimal)
c.Assert(err, gc.IsNil)
_, err = manual.ProviderInstance.Prepare(coretesting.Context(c), testConfig)
c.Assert(err, gc.ErrorMatches, "initialising SSH storage failed: newSSHStorage failed")
}
func (s *StorageSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig())
c.Assert(err, gc.IsNil)
s.env, err = environs.Prepare(cfg, testing.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
s.dataDir = c.MkDir()
}
// CustomEnvironConfig returns an environment configuration with
// additional specified keys added.
func CustomEnvironConfig(c *gc.C, extra Attrs) *config.Config {
attrs := FakeConfig().Merge(Attrs{
"agent-version": "1.2.3",
}).Merge(extra).Delete("admin-secret", "ca-private-key")
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
return cfg
}
func (st *State) EnvironConfig() (*config.Config, error) {
settings, err := readSettings(st, environGlobalKey)
if err != nil {
return nil, err
}
attrs := settings.Map()
return config.New(config.NoDefaults, attrs)
}
// Prepare prepares an instance of the testing environment.
func (t *Tests) Prepare(c *gc.C) environs.Environ {
cfg, err := config.New(config.NoDefaults, t.TestConfig)
c.Assert(err, gc.IsNil)
e, err := environs.Prepare(cfg, coretesting.Context(c), t.ConfigStore)
c.Assert(err, gc.IsNil, gc.Commentf("preparing environ %#v", t.TestConfig))
c.Assert(e, gc.NotNil)
return e
}
func (*configSuite) TestChecksLocationIsRequired(c *gc.C) {
attrs := makeAzureConfigMap(c)
attrs["location"] = ""
provider := azureEnvironProvider{}
newConfig, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
_, err = provider.Validate(newConfig, nil)
c.Check(err, gc.ErrorMatches, ".*environment has no location.*")
}
func (*configSuite) TestEmptyImageStream1dot16Compat(c *gc.C) {
attrs := makeAzureConfigMap(c)
attrs["image-stream"] = ""
provider := azureEnvironProvider{}
cfg, err := config.New(config.UseDefaults, attrs)
c.Assert(err, gc.IsNil)
_, err = provider.Validate(cfg, nil)
c.Assert(err, gc.IsNil)
}
func newTestConfig(c *gc.C, explicit testing.Attrs) *config.Config {
final := testing.Attrs{"type": "my-type", "name": "my-name"}
for key, value := range explicit {
final[key] = value
}
result, err := config.New(config.UseDefaults, final)
c.Assert(err, gc.IsNil)
return result
}
// Open opens an instance of the testing environment.
func (t *Tests) Open(c *gc.C) environs.Environ {
info, err := t.ConfigStore.ReadInfo(t.TestConfig["name"].(string))
c.Assert(err, gc.IsNil)
cfg, err := config.New(config.NoDefaults, info.BootstrapConfig())
c.Assert(err, gc.IsNil)
e, err := environs.New(cfg)
c.Assert(err, gc.IsNil, gc.Commentf("opening environ %#v", cfg.AllAttrs()))
c.Assert(e, gc.NotNil)
return e
}
func (*configSuite) TestAvailabilitySetsEnabledImmutable(c *gc.C) {
cfg, err := config.New(config.UseDefaults, makeAzureConfigMap(c))
c.Assert(err, gc.IsNil)
env, err := azureEnvironProvider{}.Prepare(testing.Context(c), cfg)
c.Assert(err, gc.IsNil)
cfg, err = env.Config().Apply(map[string]interface{}{"availability-sets-enabled": false})
c.Assert(err, gc.IsNil)
err = env.SetConfig(cfg)
c.Assert(err, gc.ErrorMatches, "cannot change availability-sets-enabled")
}
func (*configSuite) TestChecksExistingCertFile(c *gc.C) {
nonExistingCertPath := "non-existing-cert-file"
attrs := makeAzureConfigMap(c)
delete(attrs, "management-certificate")
attrs["management-certificate-path"] = nonExistingCertPath
provider := azureEnvironProvider{}
newConfig, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
_, err = provider.Validate(newConfig, nil)
c.Check(err, gc.ErrorMatches, ".*"+nonExistingCertPath+": no such file or directory.*")
}
func dummyConfig(c *gc.C) *config.Config {
testConfig, err := config.New(config.UseDefaults, coretesting.FakeConfig())
c.Assert(err, gc.IsNil)
testConfig, err = testConfig.Apply(map[string]interface{}{
"type": "dummy",
"state-server": false,
"agent-version": version.Current.Number.String(),
})
c.Assert(err, gc.IsNil)
return testConfig
}
func (s *providerSuite) TestPrepare(c *gc.C) {
minimal := manual.MinimalConfigValues()
minimal["use-sshstorage"] = true
delete(minimal, "storage-auth-key")
testConfig, err := config.New(config.UseDefaults, minimal)
c.Assert(err, gc.IsNil)
env, err := manual.ProviderInstance.Prepare(coretesting.Context(c), testConfig)
c.Assert(err, gc.IsNil)
cfg := env.Config()
key, _ := cfg.UnknownAttrs()["storage-auth-key"].(string)
c.Assert(key, jc.Satisfies, utils.IsValidUUIDString)
}
func (s *ConfigSuite) TestConfigAttrs(c *gc.C) {
// Normally this is handled by testing.FakeHome
s.PatchEnvironment(osenv.JujuLoggingConfigEnvKey, "")
attrs := map[string]interface{}{
"type": "my-type",
"name": "my-name",
"authorized-keys": testing.FakeAuthKeys,
"firewall-mode": config.FwInstance,
"admin-secret": "foo",
"unknown": "my-unknown",
"ca-cert": caCert,
"ssl-hostname-verification": true,
"development": false,
"provisioner-safe-mode": false,
"state-port": 1234,
"api-port": 4321,
"syslog-port": 2345,
"bootstrap-timeout": 3600,
"bootstrap-retry-delay": 30,
"bootstrap-addresses-delay": 10,
"default-series": testing.FakeDefaultSeries,
"charm-store-auth": "token=auth",
"test-mode": false,
}
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
// These attributes are added if not set.
attrs["development"] = false
attrs["logging-config"] = "<root>=WARNING;unit=DEBUG"
attrs["ca-private-key"] = ""
attrs["image-metadata-url"] = ""
attrs["tools-metadata-url"] = ""
attrs["tools-url"] = ""
attrs["image-stream"] = ""
attrs["proxy-ssh"] = false
attrs["lxc-clone-aufs"] = false
// Default firewall mode is instance
attrs["firewall-mode"] = string(config.FwInstance)
c.Assert(cfg.AllAttrs(), jc.DeepEquals, attrs)
c.Assert(cfg.UnknownAttrs(), jc.DeepEquals, map[string]interface{}{"unknown": "my-unknown"})
newcfg, err := cfg.Apply(map[string]interface{}{
"name": "new-name",
"new-unknown": "my-new-unknown",
})
c.Assert(err, gc.IsNil)
attrs["name"] = "new-name"
attrs["new-unknown"] = "my-new-unknown"
c.Assert(newcfg.AllAttrs(), jc.DeepEquals, attrs)
}
func (s *configSuite) TestStorageCompat(c *gc.C) {
// Older environment configurations will not have the
// use-sshstorage attribute. We treat them as if they
// have use-sshstorage=false.
values := MinimalConfigValues()
delete(values, "use-sshstorage")
cfg, err := config.New(config.UseDefaults, values)
c.Assert(err, gc.IsNil)
envConfig := newEnvironConfig(cfg, values)
c.Assert(err, gc.IsNil)
c.Assert(envConfig.useSSHStorage(), jc.IsFalse)
}
func (s *configSuite) TestValidateConfigWithFloatPort(c *gc.C) {
// When the config values get serialized through JSON, the integers
// get coerced to float64 values. The parsing needs to handle this.
values := MinimalConfigValues()
values["storage-port"] = float64(8040)
cfg, err := config.New(config.UseDefaults, values)
c.Assert(err, gc.IsNil)
valid, err := ProviderInstance.Validate(cfg, nil)
c.Assert(err, gc.IsNil)
unknownAttrs := valid.UnknownAttrs()
c.Assert(unknownAttrs["storage-port"], gc.Equals, int(8040))
}
// PrepareOnce ensures that the environment is
// available and prepared. It sets t.Env appropriately.
func (t *LiveTests) PrepareOnce(c *gc.C) {
if t.prepared {
return
}
cfg, err := config.New(config.NoDefaults, t.TestConfig)
c.Assert(err, gc.IsNil)
e, err := environs.Prepare(cfg, coretesting.Context(c), t.ConfigStore)
c.Assert(err, gc.IsNil, gc.Commentf("preparing environ %#v", t.TestConfig))
c.Assert(e, gc.NotNil)
t.Env = e
t.prepared = true
}
func (*environProviderSuite) TestOpen(c *gc.C) {
prov := azureEnvironProvider{}
attrs := makeAzureConfigMap(c)
attrs["name"] = "my-shiny-new-env"
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
env, err := prov.Open(cfg)
c.Assert(err, gc.IsNil)
c.Check(env.Name(), gc.Equals, attrs["name"])
}
// To test UpdateEnvironConfig updates state, Validate returns a config
// different to both input configs
func mockValidCfg() (valid *config.Config, err error) {
cfg, err := config.New(config.UseDefaults, coretesting.FakeConfig())
if err != nil {
return nil, err
}
valid, err = cfg.Apply(map[string]interface{}{
"arbitrary-key": "cptn-marvel",
})
if err != nil {
return nil, err
}
return valid, nil
}