environs/ec2: authorize internal traffic

environs/jujutest/livetests.go

 package jujutest
 
 import (
         "fmt"
         . "launchpad.net/gocheck"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/juju"
         "launchpad.net/juju-core/state"
+        "launchpad.net/juju-core/testing"
         "launchpad.net/juju-core/version"
         "time"
 )
 
 // TestStartStop is similar to Tests.TestStartStop except
 // that it does not assume a pristine environment.
 func (t *LiveTests) TestStartStop(c *C) {
         insts, err := t.Env.Instances(nil)
         c.Assert(err, IsNil)
         c.Check(insts, HasLen, 0)
@@ skipping 125 matching lines @@
         err := t.Env.Bootstrap(false)
         c.Assert(err, ErrorMatches, "environment is already bootstrapped")
 
         c.Logf("destroy env")
         t.Destroy(c)
 
         // check that we can bootstrap after destroy
         t.BootstrapOnce(c)
 }
 
-func (t *LiveTests) TestBootstrapProvisioner(c *C) {
+func (t *LiveTests) TestBootstrapAndDeploy(c *C) {
         if !t.CanOpenState || !t.HasProvisioner {
                 c.Skip(fmt.Sprintf("skipping provisioner test, CanOpenState: %v, HasProvisioner: %v", t.CanOpenState, t.HasProvisioner))
         }
         t.BootstrapOnce(c)
 
+        c.Logf("opening connection")
         conn, err := juju.NewConn(t.Env)
         c.Assert(err, IsNil)
         defer conn.Close()
 
-        // Check that we can upgrade the machine agent on the bootstrap machine.
-        m, err := conn.State.Machine(0)
-        c.Assert(err, IsNil)
-
         // Check that the agent version has made it through the
         // bootstrap process (it's optional in the config.Config)
         cfg, err := conn.State.EnvironConfig()
         c.Assert(err, IsNil)
         c.Check(cfg.AgentVersion(), Equals, version.Current.Number)
 
-        t.checkUpgradeMachineAgent(c, conn.State, m)
+        // Wait for machine agent to come up on the bootstrap
+        // machine and find the deployed series from that.
+        m0, err := conn.State.Machine(0)
+        c.Assert(err, IsNil)
+        w0, tools0 := t.machineAgentTools(c, m0)
+        defer w0.Stop()
 
-        // place a new machine into the state
-        m, err = conn.State.AddMachine()
+        // Create a new service and deploy a unit of it.
+        c.Logf("deploying service")
+        repo := &testing.Repo{c.MkDir()}
+        repo.DirWithSeries(tools0.Series, "dummy")
+        sch, err := conn.PutCharm(repo.URL(tools0.Series, "dummy"), repo.Path, false)
         c.Assert(err, IsNil)
+        svc, err := conn.AddService("", sch)
+        c.Assert(err, IsNil)
+        units, err := conn.AddUnits(svc, 1)
+        c.Assert(err, IsNil)
+        unit := units[0]
 
-        t.assertStartInstance(c, m)
+        // Wait for the unit's machine and associated agent to come up
+        // and announce itself.
+        mid, err := unit.AssignedMachineId()
+        c.Assert(err, IsNil)
+        m1, err := conn.State.Machine(mid)
+        c.Assert(err, IsNil)
+        w1, tools1 := t.machineAgentTools(c, m1)
+        defer w1.Stop()
+        c.Assert(tools1.Binary, Equals, tools0.Binary)
 
-        // now remove it
-        c.Assert(conn.State.RemoveMachine(m.Id()), IsNil)
+        // Check that we can upgrade the environment.
+        newVersion := tools1.Binary
+        newVersion.Patch++
+        t.checkUpgrade(c, conn, newVersion, w0, w1)
 
-        // watch the PA remove it
-        t.assertStopInstance(c, m)
-        assertInstanceId(c, m, nil)
+        c.Logf("removing unit")
+        // Now remove the unit and its assigned machine and
+        // check that the PA removes it.
+        err = svc.RemoveUnit(unit)
+        c.Assert(err, IsNil)
+        err = conn.State.RemoveMachine(m1.Id())
+        c.Assert(err, IsNil)
+        c.Logf("waiting for instance to be removed")
+        t.assertStopInstance(c, m1)
+        assertInstanceId(c, m1, nil)
 }
 
-func (t *LiveTests) checkUpgradeMachineAgent(c *C, st *state.State, m *state.Machine) {
-        // First watch the machine agent's to make sure that the its
-        // current tools are set appropriately.
-        w := m.Watch()
+// machineAgentTools waits for the given machine agent
+// to start and returns the machine watcher and the tools that it's running.
+func (t *LiveTests) machineAgentTools(c *C, m *state.Machine) (w *state.MachineWatcher, tools *state.Tools) {
+        c.Logf("waiting for machine %d to signal agent version", m.Id())
+        w = m.Watch()
 
         var gotTools *state.Tools
         for _ = range w.Changes() {
                 tools, err := m.AgentTools()
                 c.Assert(err, IsNil)
                 if tools.URL == "" {
                         // Machine agent hasn't started yet.
                         continue
                 }
                 gotTools = tools
                 break
         }
         c.Assert(gotTools, NotNil, Commentf("tools watcher died: %v", w.Err()))
         c.Assert(gotTools.Binary, Equals, version.Current)
+        return w, gotTools
+}
 
+// checkUpgrade sets the environment agent version and checks that
+// all the provided watchers upgrade to the requested version.
+func (t *LiveTests) checkUpgrade(c *C, conn *juju.Conn, newVersion version.Binary, watchers ...*state.MachineWatcher) {
         c.Logf("putting testing version of juju tools")
-
-        newVersion := version.Current
-        newVersion.Patch++
         upgradeTools, err := environs.PutTools(t.Env.Storage(), &newVersion)
         c.Assert(err, IsNil)
 
         // Check that the put version really is the version we expect.
         c.Assert(upgradeTools.Binary, Equals, newVersion)
-        err = setStateAgentVersion(st, newVersion.Number)
+        err = setStateAgentVersion(conn.State, newVersion.Number)
         c.Assert(err, IsNil)
 
-        c.Logf("waiting for upgrade")
-        _, ok := <-w.Changes()
-        if !ok {
-                c.Fatalf("watcher died: %v", w.Err())
+        for i, w := range watchers {
+                c.Logf("waiting for upgrade %d", i)
+                m, ok := <-w.Changes()
+                if !c.Check(ok, Equals, true, Commentf("watcher %d died: %v", i, w.Err())) {
+                        continue
+                }
+                tools, err := m.AgentTools()
+                if !c.Check(err, IsNil) {
+                        continue
+                }
+                // N.B. We can't test that the URL is the same because there's
+                // no guarantee that it is, even though it might be referring to
+                // the same thing.
+                if c.Check(tools.Binary, DeepEquals, newVersion) {
+                        c.Logf("upgrade %d successful", i)
+                }
         }
-        tools, err := m.AgentTools()
-        c.Assert(err, IsNil)
-        // N.B. We can't test that the URL is the same because there's
-        // no guarantee that it is, even though it might be referring to
-        // the same thing.
-        c.Assert(tools.Binary, DeepEquals, upgradeTools.Binary)
-        c.Logf("upgrade successful!")
 }
 
 // setStateAgentVersion sets the current agent version in the state's
 // environment configuration.
 func setStateAgentVersion(st *state.State, vers version.Number) error {
         cfg, err := st.EnvironConfig()
         if err != nil {
                 return err
         }
         attrs := cfg.AllAttrs()
@@ skipping 122 matching lines @@
         }
 
         inst, err := t.Env.StartInstance(4, InvalidStateInfo, tools)
         if inst != nil {
                 err := t.Env.StopInstances([]environs.Instance{inst})
                 c.Check(err, IsNil)
         }
         c.Assert(inst, IsNil)
         c.Assert(err, ErrorMatches, "cannot find image.*")
 }