func (*suite) TestSetAPIHostPorts(c *gc.C) {
conf, err := agent.NewAgentConfig(attributeParams)
c.Assert(err, gc.IsNil)
addrs, err := conf.APIAddresses()
c.Assert(err, gc.IsNil)
c.Assert(addrs, gc.DeepEquals, attributeParams.APIAddresses)
// The first cloud-local address for each server is used,
// else if there are none then the first public- or unknown-
// scope address.
//
// If a server has only machine-local addresses, or none
// at all, then it will be excluded.
server1 := instance.NewAddresses("0.1.2.3", "0.1.2.4", "zeroonetwothree")
server1[0].NetworkScope = instance.NetworkCloudLocal
server1[1].NetworkScope = instance.NetworkCloudLocal
server1[2].NetworkScope = instance.NetworkPublic
server2 := instance.NewAddresses("127.0.0.1")
server2[0].NetworkScope = instance.NetworkMachineLocal
server3 := instance.NewAddresses("0.1.2.5", "zeroonetwofive")
server3[0].NetworkScope = instance.NetworkUnknown
server3[1].NetworkScope = instance.NetworkUnknown
conf.SetAPIHostPorts([][]instance.HostPort{
instance.AddressesWithPort(server1, 123),
instance.AddressesWithPort(server2, 124),
instance.AddressesWithPort(server3, 125),
})
addrs, err = conf.APIAddresses()
c.Assert(err, gc.IsNil)
c.Assert(addrs, gc.DeepEquals, []string{"0.1.2.3:123", "0.1.2.5:125"})
}
func (s *APIEndpointForEnvSuite) TestAPIEndpointNotMachineLocal(c *gc.C) {
defer coretesting.MakeEmptyFakeHome(c).Restore()
store := newConfigStore("env-name", dummyStoreInfo)
called := 0
hostPorts := [][]instance.HostPort{
instance.AddressesWithPort([]instance.Address{
instance.NewAddress("1.0.0.1", instance.NetworkPublic),
instance.NewAddress("192.0.0.1", instance.NetworkCloudLocal),
instance.NewAddress("127.0.0.1", instance.NetworkMachineLocal),
instance.NewAddress("localhost", instance.NetworkMachineLocal),
}, 1234),
instance.AddressesWithPort([]instance.Address{
instance.NewAddress("1.0.0.2", instance.NetworkUnknown),
instance.NewAddress("2002:0:0:0:0:0:100:2", instance.NetworkUnknown),
instance.NewAddress("::1", instance.NetworkMachineLocal),
instance.NewAddress("127.0.0.1", instance.NetworkMachineLocal),
instance.NewAddress("localhost", instance.NetworkMachineLocal),
}, 1235),
}
expectState := &mockAPIState{apiHostPorts: hostPorts}
apiOpen := func(_ *api.Info, _ api.DialOpts) (juju.APIState, error) {
called++
return expectState, nil
}
endpoint, err := juju.APIEndpointInStore("env-name", true, store, apiOpen)
c.Assert(err, gc.IsNil)
c.Check(called, gc.Equals, 1)
c.Check(endpoint.Addresses, gc.DeepEquals, []string{
"1.0.0.1:1234",
"192.0.0.1:1234",
"1.0.0.2:1235",
})
}
func (s *loginSuite) TestLoginAddrs(c *gc.C) {
info, cleanup := s.setupMachineAndServer(c)
defer cleanup()
// Initially just the address we connect with is returned,
// despite there being no APIHostPorts in state.
connectedAddr, hostPorts := s.loginHostPorts(c, info)
connectedAddrHost, connectedAddrPortString, err := net.SplitHostPort(connectedAddr)
c.Assert(err, gc.IsNil)
connectedAddrPort, err := strconv.Atoi(connectedAddrPortString)
c.Assert(err, gc.IsNil)
connectedAddrHostPorts := [][]instance.HostPort{
[]instance.HostPort{{
instance.NewAddress(connectedAddrHost, instance.NetworkUnknown),
connectedAddrPort,
}},
}
c.Assert(hostPorts, gc.DeepEquals, connectedAddrHostPorts)
// After storing APIHostPorts in state, Login should store
// all of them and the address we connected with.
server1Addresses := []instance.Address{{
Value: "server-1",
Type: instance.HostName,
NetworkScope: instance.NetworkPublic,
}, {
Value: "10.0.0.1",
Type: instance.Ipv4Address,
NetworkName: "internal",
NetworkScope: instance.NetworkCloudLocal,
}}
server2Addresses := []instance.Address{{
Value: "::1",
Type: instance.Ipv6Address,
NetworkName: "loopback",
NetworkScope: instance.NetworkMachineLocal,
}}
stateAPIHostPorts := [][]instance.HostPort{
instance.AddressesWithPort(server1Addresses, 123),
instance.AddressesWithPort(server2Addresses, 456),
}
err = s.State.SetAPIHostPorts(stateAPIHostPorts)
c.Assert(err, gc.IsNil)
connectedAddr, hostPorts = s.loginHostPorts(c, info)
// Now that we connected, we add the other stateAPIHostPorts. However,
// the one we connected to comes first.
stateAPIHostPorts = append(connectedAddrHostPorts, stateAPIHostPorts...)
c.Assert(hostPorts, gc.DeepEquals, stateAPIHostPorts)
}
func (s *APIEndpointForEnvSuite) TestAPIEndpointRefresh(c *gc.C) {
defer coretesting.MakeEmptyFakeHome(c).Restore()
store := newConfigStore("env-name", dummyStoreInfo)
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-foo")
c.Check(string(apiInfo.CACert), gc.Equals, "certificated")
c.Check(apiInfo.Password, gc.Equals, "foopass")
c.Check(opts, gc.DeepEquals, api.DefaultDialOpts())
called++
return expectState, nil
}
endpoint, err := juju.APIEndpointInStore("env-name", false, store, apiOpen)
c.Assert(err, gc.IsNil)
c.Assert(called, gc.Equals, 0)
c.Check(endpoint.Addresses, gc.DeepEquals, []string{"foo.invalid"})
// However, if we ask to refresh them, we'll connect to the API and get
// the freshest set
endpoint, err = juju.APIEndpointInStore("env-name", true, store, apiOpen)
c.Assert(err, gc.IsNil)
c.Check(called, gc.Equals, 1)
// This refresh now gives us the values return by APIHostPorts
c.Check(endpoint.Addresses, gc.DeepEquals, []string{"0.1.2.3:1234"})
}
func (s *APIAddressUpdaterSuite) TestAddressChange(c *gc.C) {
setter := &apiAddressSetter{servers: make(chan [][]instance.HostPort, 1)}
st, _ := s.OpenAPIAsNewMachine(c, state.JobHostUnits)
worker := apiaddressupdater.NewAPIAddressUpdater(st.Machiner(), setter)
defer func() { c.Assert(worker.Wait(), gc.IsNil) }()
defer worker.Kill()
s.BackingState.StartSync()
updatedServers := [][]instance.HostPort{instance.AddressesWithPort(
instance.NewAddresses("localhost", "127.0.0.1"),
1234,
)}
// SetAPIHostPorts should be called with the initial value (empty),
// and then the updated value.
select {
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out waiting for SetAPIHostPorts to be called first")
case servers := <-setter.servers:
c.Assert(servers, gc.HasLen, 0)
}
err := s.State.SetAPIHostPorts(updatedServers)
c.Assert(err, gc.IsNil)
s.BackingState.StartSync()
select {
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out waiting for SetAPIHostPorts to be called second")
case servers := <-setter.servers:
c.Assert(servers, gc.DeepEquals, updatedServers)
}
}
func (s *MachineSuite) TestMachineAgentRunsAPIAddressUpdaterWorker(c *gc.C) {
// Start the machine agent.
m, _, _ := s.primeAgent(c, version.Current, state.JobHostUnits)
a := s.newAgent(c, m)
go func() { c.Check(a.Run(nil), gc.IsNil) }()
defer func() { c.Check(a.Stop(), gc.IsNil) }()
// Update the API addresses.
updatedServers := [][]instance.HostPort{instance.AddressesWithPort(
instance.NewAddresses("localhost"), 1234,
)}
err := s.BackingState.SetAPIHostPorts(updatedServers)
c.Assert(err, gc.IsNil)
// Wait for config to be updated.
s.BackingState.StartSync()
for attempt := coretesting.LongAttempt.Start(); attempt.Next(); {
addrs, err := a.CurrentConfig().APIAddresses()
c.Assert(err, gc.IsNil)
if reflect.DeepEqual(addrs, []string{"localhost:1234"}) {
return
}
}
c.Fatalf("timeout while waiting for agent config to change")
}
func parseHostPort(s string) (instance.HostPort, error) {
addr, port, err := net.SplitHostPort(s)
if err != nil {
return instance.HostPort{}, err
}
portNum, err := strconv.Atoi(port)
if err != nil {
return instance.HostPort{}, fmt.Errorf("bad port number %q", port)
}
addrs := instance.NewAddresses(addr)
hostPorts := instance.AddressesWithPort(addrs, portNum)
return hostPorts[0], nil
}
func (m *fakeMachine) setStateHostPort(hostPort string) {
var mongoHostPorts []instance.HostPort
if hostPort != "" {
host, portStr, err := net.SplitHostPort(hostPort)
if err != nil {
panic(err)
}
port, err := strconv.Atoi(portStr)
if err != nil {
panic(err)
}
mongoHostPorts = instance.AddressesWithPort(instance.NewAddresses(host), port)
mongoHostPorts[0].NetworkScope = instance.NetworkCloudLocal
}
m.mutate(func(doc *machineDoc) {
doc.mongoHostPorts = mongoHostPorts
})
}
func (s *APIEndpointForEnvSuite) TestAPIEndpointNotCached(c *gc.C) {
defer coretesting.MakeMultipleEnvHome(c).Restore()
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 (s *NewAPIClientSuite) TestWithInfoOnly(c *gc.C) {
defer coretesting.MakeEmptyFakeHome(c).Restore()
store := newConfigStore("noconfig", dummyStoreInfo)
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-foo")
c.Check(string(apiInfo.CACert), gc.Equals, "certificated")
c.Check(apiInfo.Password, gc.Equals, "foopass")
c.Check(opts, gc.DeepEquals, api.DefaultDialOpts())
called++
return expectState, nil
}
// Give NewAPIFromStore a store interface that can report when the
// config was written to, to check if the cache is updated.
mockStore := &storageWithWriteNotify{store: store}
st, err := juju.NewAPIFromStore("noconfig", mockStore, apiOpen)
c.Assert(err, gc.IsNil)
c.Assert(st, gc.Equals, expectState)
c.Assert(called, gc.Equals, 1)
c.Assert(mockStore.written, jc.IsTrue)
info, err := store.ReadInfo("noconfig")
c.Assert(err, gc.IsNil)
c.Assert(info.APIEndpoint().Addresses, gc.DeepEquals, []string{"0.1.2.3:1234"})
mockStore.written = false
// If APIHostPorts haven't changed, then the store won't be updated.
st, err = juju.NewAPIFromStore("noconfig", mockStore, apiOpen)
c.Assert(err, gc.IsNil)
c.Assert(st, gc.Equals, expectState)
c.Assert(called, gc.Equals, 2)
c.Assert(mockStore.written, jc.IsFalse)
}
func (s *bootstrapSuite) TestInitializeState(c *gc.C) {
dataDir := c.MkDir()
pwHash := utils.UserPasswordHash(testing.DefaultMongoPassword, utils.CompatSalt)
configParams := agent.AgentConfigParams{
DataDir: dataDir,
Tag: "machine-0",
UpgradedToVersion: version.Current.Number,
StateAddresses: []string{testing.MgoServer.Addr()},
CACert: testing.CACert,
Password: pwHash,
}
servingInfo := params.StateServingInfo{
Cert: testing.ServerCert,
PrivateKey: testing.ServerKey,
APIPort: 1234,
StatePort: testing.MgoServer.Port(),
SystemIdentity: "def456",
}
cfg, err := agent.NewStateMachineConfig(configParams, servingInfo)
c.Assert(err, gc.IsNil)
_, available := cfg.StateServingInfo()
c.Assert(available, gc.Equals, true)
expectConstraints := constraints.MustParse("mem=1024M")
expectHW := instance.MustParseHardware("mem=2048M")
mcfg := agent.BootstrapMachineConfig{
Addresses: instance.NewAddresses("0.1.2.3", "zeroonetwothree"),
Constraints: expectConstraints,
Jobs: []params.MachineJob{params.JobHostUnits},
InstanceId: "i-bootstrap",
Characteristics: expectHW,
SharedSecret: "abc123",
}
envAttrs := dummy.SampleConfig().Delete("admin-secret").Merge(testing.Attrs{
"agent-version": version.Current.Number.String(),
"state-id": "1", // needed so policy can Open config
})
envCfg, err := config.New(config.NoDefaults, envAttrs)
c.Assert(err, gc.IsNil)
st, m, err := agent.InitializeState(cfg, envCfg, mcfg, state.DialOpts{}, environs.NewStatePolicy())
c.Assert(err, gc.IsNil)
defer st.Close()
err = cfg.Write()
c.Assert(err, gc.IsNil)
// Check that initial admin user has been set up correctly.
s.assertCanLogInAsAdmin(c, pwHash)
user, err := st.User("admin")
c.Assert(err, gc.IsNil)
c.Assert(user.PasswordValid(testing.DefaultMongoPassword), jc.IsTrue)
// Check that environment configuration has been added.
newEnvCfg, err := st.EnvironConfig()
c.Assert(err, gc.IsNil)
c.Assert(newEnvCfg.AllAttrs(), gc.DeepEquals, envCfg.AllAttrs())
// Check that the bootstrap machine looks correct.
c.Assert(m.Id(), gc.Equals, "0")
c.Assert(m.Jobs(), gc.DeepEquals, []state.MachineJob{state.JobHostUnits})
c.Assert(m.Series(), gc.Equals, version.Current.Series)
c.Assert(m.CheckProvisioned(state.BootstrapNonce), jc.IsTrue)
c.Assert(m.Addresses(), gc.DeepEquals, mcfg.Addresses)
gotConstraints, err := m.Constraints()
c.Assert(err, gc.IsNil)
c.Assert(gotConstraints, gc.DeepEquals, expectConstraints)
c.Assert(err, gc.IsNil)
gotHW, err := m.HardwareCharacteristics()
c.Assert(err, gc.IsNil)
c.Assert(*gotHW, gc.DeepEquals, expectHW)
gotAddrs := m.Addresses()
c.Assert(gotAddrs, gc.DeepEquals, mcfg.Addresses)
// Check that the API host ports are initialised correctly.
apiHostPorts, err := st.APIHostPorts()
c.Assert(err, gc.IsNil)
c.Assert(apiHostPorts, gc.DeepEquals, [][]instance.HostPort{
instance.AddressesWithPort(mcfg.Addresses, 1234),
})
// Check that the state serving info is initialised correctly.
stateServingInfo, err := st.StateServingInfo()
c.Assert(err, gc.IsNil)
c.Assert(stateServingInfo, jc.DeepEquals, params.StateServingInfo{
APIPort: 1234,
StatePort: testing.MgoServer.Port(),
Cert: testing.ServerCert,
PrivateKey: testing.ServerKey,
SharedSecret: "abc123",
SystemIdentity: "def456",
})
// Check that the machine agent's config has been written
// and that we can use it to connect to the state.
newCfg, err := agent.ReadConfig(agent.ConfigPath(dataDir, "machine-0"))
c.Assert(err, gc.IsNil)
c.Assert(newCfg.Tag(), gc.Equals, "machine-0")
c.Assert(agent.Password(newCfg), gc.Not(gc.Equals), pwHash)
c.Assert(agent.Password(newCfg), gc.Not(gc.Equals), testing.DefaultMongoPassword)
info, ok := cfg.StateInfo()
c.Assert(ok, jc.IsTrue)
st1, err := state.Open(info, state.DialOpts{}, environs.NewStatePolicy())
c.Assert(err, gc.IsNil)
defer st1.Close()
}
func addressesWithPort(port int, addrs ...string) []instance.HostPort {
return instance.AddressesWithPort(instance.NewAddresses(addrs...), port)
}
// initAPIHostPorts sets the initial API host/port addresses in state.
func initAPIHostPorts(c ConfigSetter, st *state.State, addrs []instance.Address, apiPort int) error {
hostPorts := instance.AddressesWithPort(addrs, apiPort)
return st.SetAPIHostPorts([][]instance.HostPort{hostPorts})
}
func (m *machineShim) MongoHostPorts() []instance.HostPort {
return instance.AddressesWithPort(m.Addresses(), m.mongoPort)
}
func (m *machineShim) APIHostPorts() []instance.HostPort {
return instance.AddressesWithPort(m.Addresses(), m.apiPort)
}