func (t *localServerSuite) TestAddresses(c *gc.C) {
env := t.Prepare(c)
envtesting.UploadFakeTools(c, env.Storage())
err := bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
inst, _ := testing.AssertStartInstance(c, env, "1")
c.Assert(err, gc.IsNil)
addrs, err := inst.Addresses()
c.Assert(err, gc.IsNil)
// Expected values use Address type but really contain a regexp for
// the value rather than a valid ip or hostname.
expected := []instance.Address{{
Value: "*.testing.invalid",
Type: instance.HostName,
NetworkScope: instance.NetworkPublic,
}, {
Value: "*.internal.invalid",
Type: instance.HostName,
NetworkScope: instance.NetworkCloudLocal,
}, {
Value: "8.0.0.*",
Type: instance.Ipv4Address,
NetworkScope: instance.NetworkPublic,
}, {
Value: "127.0.0.*",
Type: instance.Ipv4Address,
NetworkScope: instance.NetworkCloudLocal,
}}
c.Assert(addrs, gc.HasLen, len(expected))
for i, addr := range addrs {
c.Check(addr.Value, gc.Matches, expected[i].Value)
c.Check(addr.Type, gc.Equals, expected[i].Type)
c.Check(addr.NetworkScope, gc.Equals, expected[i].NetworkScope)
}
}
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 (t *localServerSuite) TestInstanceStatus(c *gc.C) {
env := t.Prepare(c)
envtesting.UploadFakeTools(c, env.Storage())
err := bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
t.srv.ec2srv.SetInitialInstanceState(ec2test.Terminated)
inst, _ := testing.AssertStartInstance(c, env, "1")
c.Assert(err, gc.IsNil)
c.Assert(inst.Status(), gc.Equals, "terminated")
}
func (t *localServerSuite) TestStartInstanceHardwareCharacteristics(c *gc.C) {
env := t.Prepare(c)
envtesting.UploadFakeTools(c, env.Storage())
err := bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
_, hc := testing.AssertStartInstance(c, env, "1")
c.Check(*hc.Arch, gc.Equals, "amd64")
c.Check(*hc.Mem, gc.Equals, uint64(1740))
c.Check(*hc.CpuCores, gc.Equals, uint64(1))
c.Assert(*hc.CpuPower, gc.Equals, uint64(100))
}
func (srv *localServer) startServer(c *gc.C) {
var err error
srv.ec2srv, err = ec2test.NewServer()
if err != nil {
c.Fatalf("cannot start ec2 test server: %v", err)
}
srv.s3srv, err = s3test.NewServer(srv.config)
if err != nil {
c.Fatalf("cannot start s3 test server: %v", err)
}
aws.Regions["test"] = aws.Region{
Name: "test",
EC2Endpoint: srv.ec2srv.URL(),
S3Endpoint: srv.s3srv.URL(),
S3LocationConstraint: true,
}
s3inst := s3.New(aws.Auth{}, aws.Regions["test"])
storage := ec2.BucketStorage(s3inst.Bucket("juju-dist"))
envtesting.UploadFakeTools(c, storage)
srv.addSpice(c)
}
func (s *APIEndpointForEnvSuite) TestAPIEndpointNotCached(c *gc.C) {
coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfig)
store, err := configstore.Default()
c.Assert(err, gc.IsNil)
ctx := coretesting.Context(c)
env, err := environs.PrepareFromName("erewhemos", ctx, store)
c.Assert(err, gc.IsNil)
defer dummy.Reset()
envtesting.UploadFakeTools(c, env.Storage())
err = bootstrap.Bootstrap(ctx, env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
// Note: if we get Bootstrap to start caching the API endpoint
// immediately, we'll still want to have this test for compatibility.
// We can just write blank info instead of reading and checking it is empty.
savedInfo, err := store.ReadInfo("erewhemos")
c.Assert(err, gc.IsNil)
// Ensure that the data isn't cached
c.Check(savedInfo.APIEndpoint().Addresses, gc.HasLen, 0)
called := 0
expectState := &mockAPIState{
apiHostPorts: [][]instance.HostPort{
instance.AddressesWithPort([]instance.Address{instance.NewAddress("0.1.2.3", instance.NetworkUnknown)}, 1234),
},
}
apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
c.Check(apiInfo.Tag, gc.Equals, "user-admin")
c.Check(string(apiInfo.CACert), gc.Equals, coretesting.CACert)
c.Check(apiInfo.Password, gc.Equals, coretesting.DefaultMongoPassword)
c.Check(opts, gc.DeepEquals, api.DefaultDialOpts())
called++
return expectState, nil
}
endpoint, err := juju.APIEndpointInStore("erewhemos", false, store, apiOpen)
c.Assert(err, gc.IsNil)
c.Assert(called, gc.Equals, 1)
c.Check(endpoint.Addresses, gc.DeepEquals, []string{"0.1.2.3:1234"})
}
func (t *LiveTests) SetUpSuite(c *gc.C) {
t.BaseSuite.SetUpSuite(c)
// Update some Config items now that we have services running.
// This is setting the simplestreams urls and auth-url because that
// information is set during startup of the localLiveSuite
cl := client.NewClient(t.cred, identity.AuthUserPass, nil)
err := cl.Authenticate()
c.Assert(err, gc.IsNil)
containerURL, err := cl.MakeServiceURL("object-store", nil)
c.Assert(err, gc.IsNil)
t.TestConfig = t.TestConfig.Merge(coretesting.Attrs{
"tools-metadata-url": containerURL + "/juju-dist-test/tools",
"image-metadata-url": containerURL + "/juju-dist-test",
"auth-url": t.cred.URL,
})
t.LiveTests.SetUpSuite(c)
// For testing, we create a storage instance to which is uploaded tools and image metadata.
t.PrepareOnce(c)
t.metadataStorage = openstack.MetadataStorage(t.Env)
// Put some fake tools metadata in place so that tests that are simply
// starting instances without any need to check if those instances
// are running can find the metadata.
envtesting.UploadFakeTools(c, t.metadataStorage)
}
func (t *localServerSuite) TestBootstrapInstanceUserDataAndState(c *gc.C) {
env := t.Prepare(c)
envtesting.UploadFakeTools(c, env.Storage())
err := bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
// check that the state holds the id of the bootstrap machine.
bootstrapState, err := bootstrap.LoadState(env.Storage())
c.Assert(err, gc.IsNil)
c.Assert(bootstrapState.StateInstances, gc.HasLen, 1)
insts, err := env.AllInstances()
c.Assert(err, gc.IsNil)
c.Assert(insts, gc.HasLen, 1)
c.Check(insts[0].Id(), gc.Equals, bootstrapState.StateInstances[0])
// check that the user data is configured to start zookeeper
// and the machine and provisioning agents.
// check that the user data is configured to only configure
// authorized SSH keys and set the log output; everything
// else happens after the machine is brought up.
inst := t.srv.ec2srv.Instance(string(insts[0].Id()))
c.Assert(inst, gc.NotNil)
bootstrapDNS, err := insts[0].DNSName()
c.Assert(err, gc.IsNil)
c.Assert(bootstrapDNS, gc.Not(gc.Equals), "")
userData, err := utils.Gunzip(inst.UserData)
c.Assert(err, gc.IsNil)
c.Logf("first instance: UserData: %q", userData)
var userDataMap map[interface{}]interface{}
err = goyaml.Unmarshal(userData, &userDataMap)
c.Assert(err, gc.IsNil)
c.Assert(userDataMap, jc.DeepEquals, map[interface{}]interface{}{
"output": map[interface{}]interface{}{
"all": "| tee -a /var/log/cloud-init-output.log",
},
"ssh_authorized_keys": splitAuthKeys(env.Config().AuthorizedKeys()),
"runcmd": []interface{}{
"set -xe",
"install -D -m 644 /dev/null '/var/lib/juju/nonce.txt'",
"printf '%s\\n' 'user-admin:bootstrap' > '/var/lib/juju/nonce.txt'",
},
})
// check that a new instance will be started with a machine agent
inst1, hc := testing.AssertStartInstance(c, env, "1")
c.Check(*hc.Arch, gc.Equals, "amd64")
c.Check(*hc.Mem, gc.Equals, uint64(1740))
c.Check(*hc.CpuCores, gc.Equals, uint64(1))
c.Assert(*hc.CpuPower, gc.Equals, uint64(100))
inst = t.srv.ec2srv.Instance(string(inst1.Id()))
c.Assert(inst, gc.NotNil)
userData, err = utils.Gunzip(inst.UserData)
c.Assert(err, gc.IsNil)
c.Logf("second instance: UserData: %q", userData)
userDataMap = nil
err = goyaml.Unmarshal(userData, &userDataMap)
c.Assert(err, gc.IsNil)
CheckPackage(c, userDataMap, "git", true)
CheckPackage(c, userDataMap, "mongodb-server", false)
CheckScripts(c, userDataMap, "jujud bootstrap-state", false)
CheckScripts(c, userDataMap, "/var/lib/juju/agents/machine-1/agent.conf", true)
// TODO check for provisioning agent
err = env.Destroy()
c.Assert(err, gc.IsNil)
_, err = bootstrap.LoadState(env.Storage())
c.Assert(err, gc.NotNil)
}
func (suite *StateSuite) newStorageWithDataDir(c *gc.C) (storage.Storage, string) {
closer, stor, dataDir := envtesting.CreateLocalTestStorage(c)
suite.AddCleanup(func(*gc.C) { closer.Close() })
envtesting.UploadFakeTools(c, stor)
return stor, dataDir
}
func (suite *environSuite) setupFakeTools(c *gc.C) {
stor := NewStorage(suite.makeEnviron())
envtesting.UploadFakeTools(c, stor)
}
