func (t *LiveTests) TestBootstrapWithDefaultSeries(c *C) {
if !t.HasProvisioner {
c.Skip("HasProvisioner is false; cannot test deployment")
}
current := version.Current
other := current
other.Series = "precise"
if current == other {
other.Series = "quantal"
}
cfg := t.Env.Config()
cfg, err := cfg.Apply(map[string]interface{}{"default-series": other.Series})
c.Assert(err, IsNil)
env, err := environs.New(cfg)
c.Assert(err, IsNil)
dummyenv, err := environs.NewFromAttrs(map[string]interface{}{
"type": "dummy",
"name": "dummy storage",
"secret": "pizza",
"state-server": false,
})
c.Assert(err, IsNil)
defer dummyenv.Destroy(nil)
currentPath := environs.ToolsStoragePath(current)
otherPath := environs.ToolsStoragePath(other)
envStorage := env.Storage()
dummyStorage := dummyenv.Storage()
defer envStorage.Remove(otherPath)
_, err = environs.PutTools(dummyStorage, ¤t.Number)
c.Assert(err, 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, currentPath, envStorage, otherPath)
c.Assert(err, IsNil)
err = environs.Bootstrap(env, false, panicWrite)
c.Assert(err, IsNil)
defer env.Destroy(nil)
conn, err := juju.NewConn(env)
c.Assert(err, 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, IsNil)
mw0 := newMachineToolWaiter(m0)
defer mw0.Stop()
waitAgentTools(c, mw0, other)
}
func (t *LiveTests) SetUpSuite(c *C) {
t.LoggingSuite.SetUpSuite(c)
// Get an authenticated Goose client to extract some configuration parameters for the test environment.
cred, err := identity.CompleteCredentialsFromEnv()
c.Assert(err, IsNil)
client := client.NewClient(cred, identity.AuthUserPass, nil)
err = client.Authenticate()
c.Assert(err, IsNil)
publicBucketURL, err := client.MakeServiceURL("object-store", nil)
c.Assert(err, IsNil)
attrs := makeTestConfig()
attrs["public-bucket-url"] = publicBucketURL
t.Config = attrs
e, err := environs.NewFromAttrs(t.Config)
c.Assert(err, IsNil)
// Environ.PublicStorage() is read only.
// For testing, we create a specific storage instance which is authorised to write to
// the public storage bucket so that we can upload files for testing.
t.writeablePublicStorage = openstack.WritablePublicStorage(e)
// Put some fake tools in place so that tests that are simply
// starting instances without any need to check if those instances
// are running will find them in the public bucket.
putFakeTools(c, t.writeablePublicStorage)
t.LiveTests.SetUpSuite(c)
}
func (t *LiveTests) SetUpSuite(c *C) {
t.LoggingSuite.SetUpSuite(c)
e, err := environs.NewFromAttrs(t.TestConfig.Config)
c.Assert(err, IsNil, Commentf("opening environ %#v", t.TestConfig.Config))
c.Assert(e, NotNil)
t.Env = e
c.Logf("environment configuration: %#v", publicAttrs(e))
}
func (t *Tests) TestBootstrapWithoutAdminSecret(c *C) {
m := t.Env.Config().AllAttrs()
delete(m, "admin-secret")
env, err := environs.NewFromAttrs(m)
c.Assert(err, IsNil)
err = environs.Bootstrap(env, false, panicWrite)
c.Assert(err, ErrorMatches, ".*admin-secret is required for bootstrap")
}
func (s *publicBucketSuite) TestPublicBucketFromEnv(c *C) {
config := makeTestConfig(s.cred)
config["public-bucket-url"] = "http://127.0.0.1/public-bucket"
var err error
s.env, err = environs.NewFromAttrs(config)
c.Assert(err, IsNil)
url, err := s.env.PublicStorage().URL("")
c.Assert(err, IsNil)
c.Assert(url, Equals, "http://127.0.0.1/public-bucket/juju-dist/")
}
func (OpenSuite) TestNewUnknownEnviron(c *C) {
env, err := environs.NewFromAttrs(map[string]interface{}{
"name": "foo",
"type": "wondercloud",
"authorized-keys": "i-am-a-key",
"ca-cert": testing.CACert,
"ca-private-key": "",
})
c.Assert(err, ErrorMatches, "no registered provider for.*")
c.Assert(env, IsNil)
}
func (s *publicBucketSuite) TestPublicBucketFromKeystone(c *C) {
config := makeTestConfig(s.cred)
config["public-bucket-url"] = ""
var err error
s.env, err = environs.NewFromAttrs(config)
c.Assert(err, IsNil)
url, err := s.env.PublicStorage().URL("")
c.Assert(err, IsNil)
swiftURL, err := openstack.GetSwiftURL(s.env)
c.Assert(err, IsNil)
c.Assert(url, Equals, fmt.Sprintf("%s/juju-dist/", swiftURL))
}
func (s *ConfigDeprecationSuite) setupEnv(c *gc.C, deprecatedKey, value string) {
s.setupEnvCredentials()
attrs := map[string]interface{}{
"name": "testenv",
"type": "openstack",
"control-bucket": "x",
"authorized-keys": "fakekey",
deprecatedKey: value,
}
_, err := environs.NewFromAttrs(attrs)
c.Assert(err, gc.IsNil)
}
func (cs *NewConnSuite) TestConnStateDoesNotUpdateExistingSecrets(c *C) {
attrs := map[string]interface{}{
"name": "erewhemos",
"type": "dummy",
"state-server": true,
"authorized-keys": "i-am-a-key",
"secret": "pork",
"admin-secret": "some secret",
"ca-cert": coretesting.CACert,
"ca-private-key": coretesting.CAKey,
}
env, err := environs.NewFromAttrs(attrs)
c.Assert(err, IsNil)
err = environs.Bootstrap(env, constraints.Value{})
c.Assert(err, IsNil)
// Make a new Conn, which will push the secrets.
conn, err := juju.NewConn(env)
c.Assert(err, IsNil)
defer conn.Close()
// Make another env with a different secret.
attrs["secret"] = "squirrel"
env1, err := environs.NewFromAttrs(attrs)
c.Assert(err, IsNil)
// Connect with the new env and check that the secret has not changed
conn, err = juju.NewConn(env1)
c.Assert(err, IsNil)
defer conn.Close()
cfg, err := conn.State.EnvironConfig()
c.Assert(err, IsNil)
c.Assert(cfg.UnknownAttrs()["secret"], Equals, "pork")
// Reset the admin password so the state db can be reused.
err = conn.State.SetAdminMongoPassword("")
c.Assert(err, IsNil)
}
func (t *MongoToolsSuite) SetUpTest(c *C) {
t.LoggingSuite.SetUpTest(c)
env, err := environs.NewFromAttrs(map[string]interface{}{
"name": "test",
"type": "dummy",
"state-server": false,
"authorized-keys": "i-am-a-key",
"ca-cert": testing.CACert,
"ca-private-key": "",
})
c.Assert(err, IsNil)
t.env = env
t.dataDir = c.MkDir()
}
func (*NewConnSuite) TestNewConnWithoutAdminSecret(c *C) {
attrs := map[string]interface{}{
"name": "erewhemos",
"type": "dummy",
"state-server": true,
"authorized-keys": "i-am-a-key",
"secret": "pork",
"admin-secret": "really",
"ca-cert": coretesting.CACert,
"ca-private-key": coretesting.CAKey,
}
env, err := environs.NewFromAttrs(attrs)
c.Assert(err, IsNil)
err = environs.Bootstrap(env, constraints.Value{})
c.Assert(err, IsNil)
delete(attrs, "admin-secret")
env1, err := environs.NewFromAttrs(attrs)
c.Assert(err, IsNil)
conn, err := juju.NewConn(env1)
c.Check(conn, IsNil)
c.Assert(err, ErrorMatches, "cannot connect without admin-secret")
}
func (s *StorageSuite) SetUpTest(c *gc.C) {
s.LoggingSuite.SetUpTest(c)
env, err := environs.NewFromAttrs(map[string]interface{}{
"name": "test",
"type": "dummy",
"state-server": false,
"authorized-keys": "i-am-a-key",
"ca-cert": testing.CACert,
"ca-private-key": "",
})
c.Assert(err, gc.IsNil)
s.env = env
s.dataDir = c.MkDir()
}
func (OpenSuite) TestNewDummyEnviron(c *C) {
// matches *Settings.Map()
config := map[string]interface{}{
"name": "foo",
"type": "dummy",
"state-server": false,
"authorized-keys": "i-am-a-key",
"admin-secret": "foo",
"ca-cert": testing.CACert,
"ca-private-key": "",
}
env, err := environs.NewFromAttrs(config)
c.Assert(err, IsNil)
c.Assert(env.Bootstrap(constraints.Value{}), IsNil)
}
func (t *LiveTests) SetUpSuite(c *C) {
t.LoggingSuite.SetUpSuite(c)
e, err := environs.NewFromAttrs(t.Config)
c.Assert(err, IsNil)
// Environ.PublicStorage() is read only.
// For testing, we create a specific storage instance which is authorised to write to
// the public storage bucket so that we can upload files for testing.
t.writablePublicStorage = ec2.WritablePublicStorage(e)
// Put some fake tools in place so that tests that are simply
// starting instances without any need to check if those instances
// are running will find them in the public bucket.
putFakeTools(c, t.writablePublicStorage)
t.LiveTests.SetUpSuite(c)
}
func (cs *NewConnSuite) TestConnWithPassword(c *C) {
env, err := environs.NewFromAttrs(map[string]interface{}{
"name": "erewhemos",
"type": "dummy",
"state-server": true,
"authorized-keys": "i-am-a-key",
"secret": "squirrel",
"admin-secret": "nutkin",
"ca-cert": coretesting.CACert,
"ca-private-key": coretesting.CAKey,
})
c.Assert(err, IsNil)
err = environs.Bootstrap(env, constraints.Value{})
c.Assert(err, IsNil)
// Check that Bootstrap has correctly used a hash
// of the admin password.
info, _, err := env.StateInfo()
c.Assert(err, IsNil)
info.Password = utils.PasswordHash("nutkin")
st, err := state.Open(info, state.DefaultDialOpts())
c.Assert(err, IsNil)
st.Close()
// Check that we can connect with the original environment.
conn, err := juju.NewConn(env)
c.Assert(err, IsNil)
conn.Close()
// Check that the password has now been changed to the original
// admin password.
info.Password = "******"
st1, err := state.Open(info, state.DefaultDialOpts())
c.Assert(err, IsNil)
st1.Close()
// Check that we can still connect with the original
// environment.
conn, err = juju.NewConn(env)
c.Assert(err, IsNil)
defer conn.Close()
// Reset the admin password so the state db can be reused.
err = conn.State.SetAdminMongoPassword("")
c.Assert(err, IsNil)
}
func (s *ToolsSuite) Reset(c *C, attrs map[string]interface{}) {
version.Current = s.origCurrentVersion
dummy.Reset()
final := map[string]interface{}{
"name": "test",
"type": "dummy",
"state-server": false,
"authorized-keys": "i-am-a-key",
"ca-cert": testing.CACert,
"ca-private-key": "",
}
for k, v := range attrs {
final[k] = v
}
env, err := environs.NewFromAttrs(final)
c.Assert(err, IsNil)
s.env = env
envtesting.RemoveAllTools(c, s.env)
}
func (s *ConnSuite) SetUpTest(c *C) {
s.LoggingSuite.SetUpTest(c)
s.MgoSuite.SetUpTest(c)
attrs := map[string]interface{}{
"name": "erewhemos",
"type": "dummy",
"state-server": true,
"authorized-keys": "i-am-a-key",
"admin-secret": "deploy-test-secret",
"ca-cert": coretesting.CACert,
"ca-private-key": coretesting.CAKey,
}
environ, err := environs.NewFromAttrs(attrs)
c.Assert(err, IsNil)
err = environs.Bootstrap(environ, constraints.Value{})
c.Assert(err, IsNil)
s.conn, err = juju.NewConn(environ)
c.Assert(err, IsNil)
s.repo = &charm.LocalRepository{Path: c.MkDir()}
}
// newConfig creates a MAAS environment config from attributes.
func newConfig(values map[string]interface{}) (*maasEnvironConfig, error) {
defaults := map[string]interface{}{
"name": "testenv",
"type": "maas",
"admin-secret": "ssshhhhhh",
"authorized-keys": "I-am-not-a-real-key",
"agent-version": version.CurrentNumber().String(),
// These are not needed by MAAS, but juju-core breaks without them. Needs
// fixing there.
"ca-cert": testing.CACert,
"ca-private-key": testing.CAKey,
}
cfg := make(map[string]interface{})
copyAttrs(defaults, cfg)
copyAttrs(values, cfg)
env, err := environs.NewFromAttrs(cfg)
if err != nil {
return nil, err
}
return env.(*maasEnviron).ecfg(), nil
}
func (cs *NewConnSuite) TestConnStateSecretsSideEffect(c *C) {
attrs := map[string]interface{}{
"name": "erewhemos",
"type": "dummy",
"state-server": true,
"authorized-keys": "i-am-a-key",
"secret": "pork",
"admin-secret": "side-effect secret",
"ca-cert": coretesting.CACert,
"ca-private-key": coretesting.CAKey,
}
env, err := environs.NewFromAttrs(attrs)
c.Assert(err, IsNil)
err = environs.Bootstrap(env, constraints.Value{})
c.Assert(err, IsNil)
info, _, err := env.StateInfo()
c.Assert(err, IsNil)
info.Password = utils.PasswordHash("side-effect secret")
st, err := state.Open(info, state.DefaultDialOpts())
c.Assert(err, IsNil)
// Verify we have no secret in the environ config
cfg, err := st.EnvironConfig()
c.Assert(err, IsNil)
c.Assert(cfg.UnknownAttrs()["secret"], IsNil)
// Make a new Conn, which will push the secrets.
conn, err := juju.NewConn(env)
c.Assert(err, IsNil)
defer conn.Close()
cfg, err = conn.State.EnvironConfig()
c.Assert(err, IsNil)
c.Assert(cfg.UnknownAttrs()["secret"], Equals, "pork")
// Reset the admin password so the state db can be reused.
err = conn.State.SetAdminMongoPassword("")
c.Assert(err, IsNil)
}
func (*NewAPIConnSuite) TestNewConn(c *C) {
attrs := map[string]interface{}{
"name": "erewhemos",
"type": "dummy",
"state-server": true,
"authorized-keys": "i-am-a-key",
"secret": "pork",
"admin-secret": "really",
"ca-cert": coretesting.CACert,
"ca-private-key": coretesting.CAKey,
}
env, err := environs.NewFromAttrs(attrs)
c.Assert(err, IsNil)
err = environs.Bootstrap(env, constraints.Value{})
c.Assert(err, IsNil)
conn, err := juju.NewConn(env)
c.Assert(err, IsNil)
c.Assert(conn.Environ, Equals, env)
c.Assert(conn.State, NotNil)
c.Assert(conn.Close(), IsNil)
}
// Open opens an instance of the testing environment.
func (t *Tests) Open(c *C) environs.Environ {
e, err := environs.NewFromAttrs(t.Config)
c.Assert(err, IsNil, Commentf("opening environ %#v", t.Config))
c.Assert(e, NotNil)
return e
}
func (t *LiveTests) TestBootstrapWithDefaultSeries(c *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"
}
cfg := t.Env.Config()
cfg, err := cfg.Apply(map[string]interface{}{"default-series": other.Series})
c.Assert(err, IsNil)
env, err := environs.New(cfg)
c.Assert(err, IsNil)
dummyenv, err := environs.NewFromAttrs(map[string]interface{}{
"type": "dummy",
"name": "dummy storage",
"secret": "pizza",
"state-server": false,
"ca-cert": coretesting.CACert,
"ca-private-key": coretesting.CAKey,
})
c.Assert(err, IsNil)
defer dummyenv.Destroy(nil)
// BUG: We destroy the environment, then write to its storage.
// This is bogus, strictly speaking, but it works on
// existing providers for the time being and means
// this test does not fail when the environment is
// already bootstrapped.
t.Destroy(c)
currentName := tools.StorageName(current)
otherName := tools.StorageName(other)
envStorage := env.Storage()
dummyStorage := dummyenv.Storage()
defer envStorage.Remove(otherName)
_, err = tools.Upload(dummyStorage, ¤t.Number)
c.Assert(err, 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, IsNil)
err = environs.Bootstrap(env, constraints.Value{})
c.Assert(err, IsNil)
defer env.Destroy(nil)
conn, err := juju.NewConn(env)
c.Assert(err, 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, IsNil)
mw0 := newMachineToolWaiter(m0)
defer mw0.Stop()
waitAgentTools(c, mw0, other)
}