func (*OpenSuite) TestPrepareGeneratesDifferentAdminSecrets(c *gc.C) {
baselineAttrs := dummy.SampleConfig().Merge(testing.Attrs{
"state-server": false,
"name": "erewhemos",
}).Delete(
"admin-secret",
)
cfg, err := config.New(config.NoDefaults, baselineAttrs)
c.Assert(err, gc.IsNil)
ctx := testing.Context(c)
env0, err := environs.Prepare(cfg, ctx, configstore.NewMem())
c.Assert(err, gc.IsNil)
adminSecret0 := env0.Config().AdminSecret()
c.Assert(adminSecret0, gc.HasLen, 32)
c.Assert(adminSecret0, gc.Matches, "^[0-9a-f]*$")
env1, err := environs.Prepare(cfg, ctx, configstore.NewMem())
c.Assert(err, gc.IsNil)
adminSecret1 := env1.Config().AdminSecret()
c.Assert(adminSecret1, gc.HasLen, 32)
c.Assert(adminSecret1, gc.Matches, "^[0-9a-f]*$")
c.Assert(adminSecret1, gc.Not(gc.Equals), adminSecret0)
}
func (*OpenSuite) TestPrepare(c *gc.C) {
baselineAttrs := dummy.SampleConfig().Merge(testing.Attrs{
"state-server": false,
"name": "erewhemos",
}).Delete(
"ca-cert",
"ca-private-key",
"admin-secret",
)
cfg, err := config.New(config.NoDefaults, baselineAttrs)
c.Assert(err, gc.IsNil)
store := configstore.NewMem()
ctx := testing.Context(c)
env, err := environs.Prepare(cfg, ctx, store)
c.Assert(err, gc.IsNil)
// Check we can access storage ok, which implies the environment has been prepared.
c.Assert(env.Storage(), gc.NotNil)
// Check that the environment info file was correctly created.
info, err := store.ReadInfo("erewhemos")
c.Assert(err, gc.IsNil)
c.Assert(info.Initialized(), jc.IsTrue)
c.Assert(info.BootstrapConfig(), gc.DeepEquals, env.Config().AllAttrs())
c.Logf("bootstrap config: %#v", info.BootstrapConfig())
// Check that an admin-secret was chosen.
adminSecret := env.Config().AdminSecret()
c.Assert(adminSecret, gc.HasLen, 32)
c.Assert(adminSecret, gc.Matches, "^[0-9a-f]*$")
// Check that the CA cert was generated.
cfgCertPEM, cfgCertOK := env.Config().CACert()
cfgKeyPEM, cfgKeyOK := env.Config().CAPrivateKey()
c.Assert(cfgCertOK, gc.Equals, true)
c.Assert(cfgKeyOK, gc.Equals, true)
// Check the common name of the generated cert
caCert, _, err := cert.ParseCertAndKey(cfgCertPEM, cfgKeyPEM)
c.Assert(err, gc.IsNil)
c.Assert(caCert.Subject.CommonName, gc.Equals, `juju-generated CA for environment "`+testing.SampleEnvName+`"`)
// Check we can call Prepare again.
env, err = environs.Prepare(cfg, ctx, store)
c.Assert(err, gc.IsNil)
c.Assert(env.Name(), gc.Equals, "erewhemos")
c.Assert(env.Storage(), gc.NotNil)
c.Assert(env.Config().AllAttrs(), gc.DeepEquals, info.BootstrapConfig())
}
func (*OpenSuite) TestDestroy(c *gc.C) {
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Merge(
testing.Attrs{
"state-server": false,
"name": "erewhemos",
},
))
c.Assert(err, gc.IsNil)
store := configstore.NewMem()
// Prepare the environment and sanity-check that
// the config storage info has been made.
ctx := testing.Context(c)
e, err := environs.Prepare(cfg, ctx, store)
c.Assert(err, gc.IsNil)
_, err = store.ReadInfo(e.Name())
c.Assert(err, gc.IsNil)
err = environs.Destroy(e, store)
c.Assert(err, gc.IsNil)
// Check that the environment has actually been destroyed
// and that the config info has been destroyed too.
_, _, err = e.StateInfo()
c.Assert(err, gc.ErrorMatches, "environment has been destroyed")
_, err = store.ReadInfo(e.Name())
c.Assert(err, jc.Satisfies, errors.IsNotFound)
}
func testingEnvConfig(c *gc.C) *config.Config {
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig())
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, testing.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
return env.Config()
}
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 (s *suite) TestAllocateAddress(c *gc.C) {
cfg, err := config.New(config.NoDefaults, s.TestConfig)
c.Assert(err, gc.IsNil)
e, err := environs.Prepare(cfg, testing.Context(c), s.ConfigStore)
c.Assert(err, gc.IsNil, gc.Commentf("preparing environ %#v", s.TestConfig))
c.Assert(e, gc.NotNil)
envtesting.UploadFakeTools(c, e.Storage())
err = bootstrap.EnsureNotBootstrapped(e)
c.Assert(err, gc.IsNil)
err = bootstrap.Bootstrap(testing.Context(c), e, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
inst, _ := jujutesting.AssertStartInstance(c, e, "0")
c.Assert(inst, gc.NotNil)
netId := network.Id("net1")
opc := make(chan dummy.Operation, 200)
dummy.Listen(opc)
expectAddress := instance.NewAddress("0.1.2.1", instance.NetworkCloudLocal)
address, err := e.AllocateAddress(inst.Id(), netId)
c.Assert(err, gc.IsNil)
c.Assert(address, gc.DeepEquals, expectAddress)
assertAllocateAddress(c, e, opc, inst.Id(), netId, expectAddress)
expectAddress = instance.NewAddress("0.1.2.2", instance.NetworkCloudLocal)
address, err = e.AllocateAddress(inst.Id(), netId)
c.Assert(err, gc.IsNil)
c.Assert(address, gc.DeepEquals, expectAddress)
assertAllocateAddress(c, e, opc, inst.Id(), netId, expectAddress)
}
// MakeConfig creates a functional environConfig for a test.
func MakeConfig(c *gc.C, attrs testing.Attrs) *environConfig {
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, testing.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
return env.(*joyentEnviron).Ecfg()
}
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 (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))
}
// If the environment is configured not to require a public IP address for nodes,
// bootstrapping and starting an instance should occur without any attempt to
// allocate a public address.
func (s *localServerSuite) TestStartInstanceWithoutPublicIP(c *gc.C) {
cleanup := s.srv.Service.Nova.RegisterControlPoint(
"addFloatingIP",
func(sc hook.ServiceControl, args ...interface{}) error {
return fmt.Errorf("add floating IP should not have been called")
},
)
defer cleanup()
cleanup = s.srv.Service.Nova.RegisterControlPoint(
"addServerFloatingIP",
func(sc hook.ServiceControl, args ...interface{}) error {
return fmt.Errorf("add server floating IP should not have been called")
},
)
defer cleanup()
cfg, err := config.New(config.NoDefaults, s.TestConfig.Merge(coretesting.Attrs{
"use-floating-ip": false,
}))
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, coretesting.Context(c), s.ConfigStore)
c.Assert(err, gc.IsNil)
err = bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
inst, _ := testing.AssertStartInstance(c, env, "100")
err = env.StopInstances([]instance.Instance{inst})
c.Assert(err, gc.IsNil)
}
// 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 (s *StorageSuite) SetUpTest(c *gc.C) {
s.LoggingSuite.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()
}
func (s *uploadSuite) SetUpTest(c *gc.C) {
s.LoggingSuite.SetUpTest(c)
s.ToolsFixture.SetUpTest(c)
// We only want to use simplestreams to find any synced tools.
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig())
c.Assert(err, gc.IsNil)
s.env, err = environs.Prepare(cfg, coretesting.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
}
func (s *SimpleStreamsToolsSuite) resetEnv(c *gc.C, attrs map[string]interface{}) {
version.Current = s.origCurrentVersion
dummy.Reset()
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Merge(attrs))
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, testing.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
s.env = env
s.removeTools(c)
}
func (*OpenSuite) TestNewDummyEnviron(c *gc.C) {
// matches *Settings.Map()
cfg, err := config.New(config.NoDefaults, dummySampleConfig())
c.Assert(err, gc.IsNil)
ctx := testing.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)
}
// 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 (s *bootstrapSuite) TestBootstrapTools(c *gc.C) {
allTests := append(envtesting.BootstrapToolsTests, bootstrapSetAgentVersionTests...)
// version.Current is set in the loop so ensure it is restored later.
s.PatchValue(&version.Current, version.Current)
for i, test := range allTests {
c.Logf("\ntest %d: %s", i, test.Info)
dummy.Reset()
attrs := dummy.SampleConfig().Merge(coretesting.Attrs{
"state-server": false,
"development": test.Development,
"default-series": test.DefaultSeries,
})
if test.AgentVersion != version.Zero {
attrs["agent-version"] = test.AgentVersion.String()
}
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, coretesting.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
envtesting.RemoveAllTools(c, env)
version.Current = test.CliVersion
envtesting.AssertUploadFakeToolsVersions(c, env.Storage(), test.Available...)
// Remove the default tools URL from the search path, just look in cloud storage.
s.PatchValue(&envtools.DefaultBaseURL, "")
cons := constraints.Value{}
if test.Arch != "" {
cons = constraints.MustParse("arch=" + test.Arch)
}
err = bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{Constraints: cons})
if test.Err != "" {
c.Check(err, gc.NotNil)
if err != nil {
stripped := strings.Replace(err.Error(), "\n", "", -1)
c.Check(stripped, gc.Matches, ".*"+stripped)
}
continue
} else {
c.Check(err, gc.IsNil)
}
unique := map[version.Number]bool{}
for _, expected := range test.Expect {
unique[expected.Number] = true
}
for expectAgentVersion := range unique {
agentVersion, ok := env.Config().AgentVersion()
c.Check(ok, gc.Equals, true)
c.Check(agentVersion, gc.Equals, expectAgentVersion)
}
}
}
func (s *URLsSuite) env(c *gc.C, toolsMetadataURL string) environs.Environ {
attrs := dummy.SampleConfig()
if toolsMetadataURL != "" {
attrs = attrs.Merge(testing.Attrs{
"tools-metadata-url": toolsMetadataURL,
})
}
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, testing.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
return env
}
func (t *localNonUSEastSuite) SetUpTest(c *gc.C) {
t.LoggingSuite.SetUpTest(c)
t.srv.config = &s3test.Config{
Send409Conflict: true,
}
t.srv.startServer(c)
cfg, err := config.New(config.NoDefaults, localConfigAttrs)
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, coretesting.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
t.env = env
}
func (*ConfigSuite) TestSecretAttrs(c *gc.C) {
attrs := dummy.SampleConfig().Delete("secret")
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
ctx := testing.Context(c)
env, err := environs.Prepare(cfg, ctx, configstore.NewMem())
c.Assert(err, gc.IsNil)
defer env.Destroy()
expected := map[string]string{
"secret": "pork",
}
actual, err := env.Provider().SecretAttrs(cfg)
c.Assert(err, gc.IsNil)
c.Assert(actual, gc.DeepEquals, expected)
}
func (s *ConnSuite) SetUpTest(c *gc.C) {
s.LoggingSuite.SetUpTest(c)
s.MgoSuite.SetUpTest(c)
s.ToolsFixture.SetUpTest(c)
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig())
c.Assert(err, gc.IsNil)
ctx := coretesting.Context(c)
environ, err := environs.Prepare(cfg, ctx, configstore.NewMem())
c.Assert(err, gc.IsNil)
envtesting.UploadFakeTools(c, environ.Storage())
err = bootstrap.Bootstrap(ctx, environ, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
s.conn, err = juju.NewConn(environ)
c.Assert(err, gc.IsNil)
s.repo = &charm.LocalRepository{Path: c.MkDir()}
}
func (*OpenSuite) TestPrepareWithMissingKey(c *gc.C) {
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Delete("ca-cert", "ca-private-key").Merge(
testing.Attrs{
"state-server": false,
"name": "erewhemos",
"ca-cert": string(testing.CACert),
},
))
c.Assert(err, gc.IsNil)
store := configstore.NewMem()
env, err := environs.Prepare(cfg, testing.Context(c), store)
c.Assert(err, gc.ErrorMatches, "cannot ensure CA certificate: environment configuration with a certificate but no CA private key")
c.Assert(env, gc.IsNil)
// Ensure that the config storage info is cleaned up.
_, err = store.ReadInfo(cfg.Name())
c.Assert(err, jc.Satisfies, errors.IsNotFound)
}
func (*NewConnSuite) TestNewConnWithoutAdminSecret(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)
attrs := env.Config().AllAttrs()
delete(attrs, "admin-secret")
env1, err := environs.NewFromAttrs(attrs)
c.Assert(err, gc.IsNil)
conn, err := juju.NewConn(env1)
c.Check(conn, gc.IsNil)
c.Assert(err, gc.ErrorMatches, "cannot connect without admin-secret")
}
func (*NewConnSuite) TestConnStateSecretsSideEffect(c *gc.C) {
attrs := dummy.SampleConfig().Merge(coretesting.Attrs{
"admin-secret": "side-effect secret",
"secret": "pork",
})
cfg, err := config.New(config.NoDefaults, attrs)
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)
info, _, err := env.StateInfo()
c.Assert(err, gc.IsNil)
info.Password = utils.UserPasswordHash("side-effect secret", utils.CompatSalt)
// Use a state without a nil policy, which will allow us to set an invalid config.
st, err := state.Open(info, state.DefaultDialOpts(), state.Policy(nil))
c.Assert(err, gc.IsNil)
defer assertClose(c, st)
// Verify we have secrets in the environ config already.
statecfg, err := st.EnvironConfig()
c.Assert(err, gc.IsNil)
c.Assert(statecfg.UnknownAttrs()["secret"], gc.Equals, "pork")
// Remove the secret from state, and then make sure it gets
// pushed back again.
err = st.UpdateEnvironConfig(map[string]interface{}{}, []string{"secret"}, nil)
c.Assert(err, gc.IsNil)
// Make a new Conn, which will push the secrets.
conn, err := juju.NewConn(env)
c.Assert(err, gc.IsNil)
defer assertClose(c, conn)
statecfg, err = conn.State.EnvironConfig()
c.Assert(err, gc.IsNil)
c.Assert(statecfg.UnknownAttrs()["secret"], gc.Equals, "pork")
// Reset the admin password so the state db can be reused.
err = conn.State.SetAdminMongoPassword("")
c.Assert(err, gc.IsNil)
}
func (*NewConnSuite) TestConnWithPassword(c *gc.C) {
attrs := dummy.SampleConfig().Merge(coretesting.Attrs{
"admin-secret": "nutkin",
})
cfg, err := config.New(config.NoDefaults, attrs)
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)
// Check that Bootstrap has correctly used a hash
// of the admin password.
info, _, err := env.StateInfo()
c.Assert(err, gc.IsNil)
info.Password = utils.UserPasswordHash("nutkin", utils.CompatSalt)
st, err := state.Open(info, state.DefaultDialOpts(), environs.NewStatePolicy())
c.Assert(err, gc.IsNil)
assertClose(c, st)
// Check that we can connect with the original environment.
conn, err := juju.NewConn(env)
c.Assert(err, gc.IsNil)
assertClose(c, conn)
// Check that the password has now been changed to the original
// admin password.
info.Password = "******"
st1, err := state.Open(info, state.DefaultDialOpts(), environs.NewStatePolicy())
c.Assert(err, gc.IsNil)
assertClose(c, st1)
// Check that we can still connect with the original
// environment.
conn, err = juju.NewConn(env)
c.Assert(err, gc.IsNil)
defer assertClose(c, conn)
// Reset the admin password so the state db can be reused.
err = conn.State.SetAdminMongoPassword("")
c.Assert(err, gc.IsNil)
}
func (*OpenSuite) TestPrepareWithExistingKeyPair(c *gc.C) {
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Merge(
testing.Attrs{
"state-server": false,
"name": "erewhemos",
"ca-cert": string(testing.CACert),
"ca-private-key": string(testing.CAKey),
},
))
c.Assert(err, gc.IsNil)
ctx := testing.Context(c)
env, err := environs.Prepare(cfg, ctx, configstore.NewMem())
c.Assert(err, gc.IsNil)
cfgCertPEM, cfgCertOK := env.Config().CACert()
cfgKeyPEM, cfgKeyOK := env.Config().CAPrivateKey()
c.Assert(cfgCertOK, gc.Equals, true)
c.Assert(cfgKeyOK, gc.Equals, true)
c.Assert(string(cfgCertPEM), gc.DeepEquals, testing.CACert)
c.Assert(string(cfgKeyPEM), gc.DeepEquals, testing.CAKey)
}
func (s *localHTTPSServerSuite) SetUpTest(c *gc.C) {
s.LoggingSuite.SetUpTest(c)
s.srv.UseTLS = true
cred := &identity.Credentials{
User: "******",
Secrets: "secret",
Region: "some-region",
TenantName: "some tenant",
}
// Note: start() will change cred.URL to point to s.srv.Server.URL
s.srv.start(c, cred)
s.cred = cred
attrs := s.createConfigAttrs(c)
c.Assert(attrs["auth-url"].(string)[:8], gc.Equals, "https://")
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
s.env, err = environs.Prepare(cfg, coretesting.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
s.attrs = s.env.Config().AllAttrs()
}
func (s *URLsSuite) env(c *gc.C, imageMetadataURL, stream string) environs.Environ {
attrs := dummy.SampleConfig()
if stream != "" {
attrs = attrs.Merge(testing.Attrs{
"image-stream": stream,
})
}
if imageMetadataURL != "" {
attrs = attrs.Merge(testing.Attrs{
"image-metadata-url": imageMetadataURL,
})
}
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, testing.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
// Put a file in images since the dummy storage provider requires a
// file to exist before the URL can be found. This is to ensure it behaves
// the same way as MAAS.
err = env.Storage().Put("images/dummy", strings.NewReader("dummy"), 5)
c.Assert(err, gc.IsNil)
return env
}
func (*NewConnSuite) TestConnStateDoesNotUpdateExistingSecrets(c *gc.C) {
attrs := dummy.SampleConfig().Merge(coretesting.Attrs{
"secret": "pork",
})
cfg, err := config.New(config.NoDefaults, attrs)
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)
// Make a new Conn, which will push the secrets.
conn, err := juju.NewConn(env)
c.Assert(err, gc.IsNil)
defer assertClose(c, conn)
// Make another env with a different secret.
attrs = env.Config().AllAttrs()
attrs["secret"] = "squirrel"
env1, err := environs.NewFromAttrs(attrs)
c.Assert(err, gc.IsNil)
// Connect with the new env and check that the secret has not changed
conn, err = juju.NewConn(env1)
c.Assert(err, gc.IsNil)
defer assertClose(c, conn)
cfg, err = conn.State.EnvironConfig()
c.Assert(err, gc.IsNil)
c.Assert(cfg.UnknownAttrs()["secret"], gc.Equals, "pork")
// Reset the admin password so the state db can be reused.
err = conn.State.SetAdminMongoPassword("")
c.Assert(err, gc.IsNil)
}
func (t *LiveTests) TestBootstrapWithDefaultSeries(c *gc.C) {
if !t.HasProvisioner {
c.Skip("HasProvisioner is false; cannot test deployment")
}
current := version.Current
other := current
other.Series = "quantal"
if current == other {
other.Series = "precise"
}
dummyCfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Merge(coretesting.Attrs{
"state-server": false,
"name": "dummy storage",
}))
dummyenv, err := environs.Prepare(dummyCfg, coretesting.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
defer dummyenv.Destroy()
t.Destroy(c)
attrs := t.TestConfig.Merge(coretesting.Attrs{"default-series": other.Series})
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, coretesting.Context(c), t.ConfigStore)
c.Assert(err, gc.IsNil)
defer environs.Destroy(env, t.ConfigStore)
currentName := envtools.StorageName(current)
otherName := envtools.StorageName(other)
envStorage := env.Storage()
dummyStorage := dummyenv.Storage()
defer envStorage.Remove(otherName)
_, err = sync.Upload(dummyStorage, ¤t.Number)
c.Assert(err, gc.IsNil)
// This will only work while cross-compiling across releases is safe,
// which depends on external elements. Tends to be safe for the last
// few releases, but we may have to refactor some day.
err = storageCopy(dummyStorage, currentName, envStorage, otherName)
c.Assert(err, gc.IsNil)
err = bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
conn, err := juju.NewConn(env)
c.Assert(err, gc.IsNil)
defer conn.Close()
// Wait for machine agent to come up on the bootstrap
// machine and ensure it deployed the proper series.
m0, err := conn.State.Machine("0")
c.Assert(err, gc.IsNil)
mw0 := newMachineToolWaiter(m0)
defer mw0.Stop()
waitAgentTools(c, mw0, other)
}