cmd/jujud: do not change password

environs/jujutest/livetests.go

 // Copyright 2011, 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package jujutest
 
 import (
         "bytes"
         "fmt"
         "io"
+        "io/ioutil"
         . "launchpad.net/gocheck"
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/constraints"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/environs/tools"
         "launchpad.net/juju-core/errors"
+        "launchpad.net/juju-core/instance"
         "launchpad.net/juju-core/juju"
         "launchpad.net/juju-core/juju/testing"
         "launchpad.net/juju-core/state"
-        "launchpad.net/juju-core/state/api/params"
+        "launchpad.net/juju-core/state/api"
         coretesting "launchpad.net/juju-core/testing"
         "launchpad.net/juju-core/utils"
         "launchpad.net/juju-core/version"
         "time"
 )
 
 // LiveTests contains tests that are designed to run against a live server
 // (e.g. Amazon EC2).  The Environ is opened once only for all the tests
 // in the suite, stored in Env, and Destroyed after the suite has completed.
 type LiveTests struct {
@@ skipping 73 matching lines @@
         t.bootstrapped = false
 }
 
 // TestStartStop is similar to Tests.TestStartStop except
 // that it does not assume a pristine environment.
 func (t *LiveTests) TestStartStop(c *C) {
         inst := testing.StartInstance(c, t.Env, "0")
         c.Assert(inst, NotNil)
         id0 := inst.Id()
 
-        insts, err := t.Env.Instances([]state.InstanceId{id0, id0})
+        insts, err := t.Env.Instances([]instance.Id{id0, id0})
         c.Assert(err, IsNil)
         c.Assert(insts, HasLen, 2)
         c.Assert(insts[0].Id(), Equals, id0)
         c.Assert(insts[1].Id(), Equals, id0)
 
         // Asserting on the return of AllInstances makes the test fragile,
         // as even comparing the before and after start values can be thrown
         // off if other instances have been created or destroyed in the same
         // time frame. Instead, just check the instance we created exists.
         insts, err = t.Env.AllInstances()
         c.Assert(err, IsNil)
         found := false
         for _, inst := range insts {
                 if inst.Id() == id0 {
                         c.Assert(found, Equals, false, Commentf("%v", insts))
                         found = true
                 }
         }
         c.Assert(found, Equals, true, Commentf("expected %v in %v", inst, insts))
 
         dns, err := inst.WaitDNSName()
         c.Assert(err, IsNil)
         c.Assert(dns, Not(Equals), "")
 
-        insts, err = t.Env.Instances([]state.InstanceId{id0, ""})
+        insts, err = t.Env.Instances([]instance.Id{id0, ""})
         c.Assert(err, Equals, environs.ErrPartialInstances)
         c.Assert(insts, HasLen, 2)
         c.Check(insts[0].Id(), Equals, id0)
         c.Check(insts[1], IsNil)
 
-        err = t.Env.StopInstances([]environs.Instance{inst})
+        err = t.Env.StopInstances([]instance.Instance{inst})
         c.Assert(err, IsNil)
 
         // The machine may not be marked as shutting down
         // immediately. Repeat a few times to ensure we get the error.
         for a := t.Attempt.Start(); a.Next(); {
-                insts, err = t.Env.Instances([]state.InstanceId{id0})
+                insts, err = t.Env.Instances([]instance.Id{id0})
                 if err != nil {
                         break
                 }
         }
         c.Assert(err, Equals, environs.ErrNoInstances)
         c.Assert(insts, HasLen, 0)
 }
 
 func (t *LiveTests) TestPorts(c *C) {
         inst1 := testing.StartInstance(c, t.Env, "1")
         c.Assert(inst1, NotNil)
-        defer t.Env.StopInstances([]environs.Instance{inst1})
+        defer t.Env.StopInstances([]instance.Instance{inst1})
         ports, err := inst1.Ports("1")
         c.Assert(err, IsNil)
         c.Assert(ports, HasLen, 0)
 
         inst2 := testing.StartInstance(c, t.Env, "2")
         c.Assert(inst2, NotNil)
         ports, err = inst2.Ports("2")
         c.Assert(err, IsNil)
         c.Assert(ports, HasLen, 0)
-        defer t.Env.StopInstances([]environs.Instance{inst2})
+        defer t.Env.StopInstances([]instance.Instance{inst2})
 
         // Open some ports and check they're there.
-        err = inst1.OpenPorts("1", []params.Port{{"udp", 67}, {"tcp", 45}})
+        err = inst1.OpenPorts("1", []instance.Port{{"udp", 67}, {"tcp", 45}})
         c.Assert(err, IsNil)
         ports, err = inst1.Ports("1")
         c.Assert(err, IsNil)
-        c.Assert(ports, DeepEquals, []params.Port{{"tcp", 45}, {"udp", 67}})
+        c.Assert(ports, DeepEquals, []instance.Port{{"tcp", 45}, {"udp", 67}})
         ports, err = inst2.Ports("2")
         c.Assert(err, IsNil)
         c.Assert(ports, HasLen, 0)
 
-        err = inst2.OpenPorts("2", []params.Port{{"tcp", 89}, {"tcp", 45}})
+        err = inst2.OpenPorts("2", []instance.Port{{"tcp", 89}, {"tcp", 45}})
         c.Assert(err, IsNil)
 
         // Check there's no crosstalk to another machine
         ports, err = inst2.Ports("2")
         c.Assert(err, IsNil)
-        c.Assert(ports, DeepEquals, []params.Port{{"tcp", 45}, {"tcp", 89}})
+        c.Assert(ports, DeepEquals, []instance.Port{{"tcp", 45}, {"tcp", 89}})
         ports, err = inst1.Ports("1")
         c.Assert(err, IsNil)
-        c.Assert(ports, DeepEquals, []params.Port{{"tcp", 45}, {"udp", 67}})
+        c.Assert(ports, DeepEquals, []instance.Port{{"tcp", 45}, {"udp", 67}})
 
         // Check that opening the same port again is ok.
         oldPorts, err := inst2.Ports("2")
         c.Assert(err, IsNil)
-        err = inst2.OpenPorts("2", []params.Port{{"tcp", 45}})
+        err = inst2.OpenPorts("2", []instance.Port{{"tcp", 45}})
         c.Assert(err, IsNil)
         ports, err = inst2.Ports("2")
         c.Assert(err, IsNil)
         c.Assert(ports, DeepEquals, oldPorts)
 
         // Check that opening the same port again and another port is ok.
-        err = inst2.OpenPorts("2", []params.Port{{"tcp", 45}, {"tcp", 99}})
+        err = inst2.OpenPorts("2", []instance.Port{{"tcp", 45}, {"tcp", 99}})
         c.Assert(err, IsNil)
         ports, err = inst2.Ports("2")
         c.Assert(err, IsNil)
-        c.Assert(ports, DeepEquals, []params.Port{{"tcp", 45}, {"tcp", 89}, {"tcp", 99}})
-
-        err = inst2.ClosePorts("2", []params.Port{{"tcp", 45}, {"tcp", 99}})
+        c.Assert(ports, DeepEquals, []instance.Port{{"tcp", 45}, {"tcp", 89}, {"tcp", 99}})
+
+        err = inst2.ClosePorts("2", []instance.Port{{"tcp", 45}, {"tcp", 99}})
         c.Assert(err, IsNil)
 
         // Check that we can close ports and that there's no crosstalk.
         ports, err = inst2.Ports("2")
         c.Assert(err, IsNil)
-        c.Assert(ports, DeepEquals, []params.Port{{"tcp", 89}})
+        c.Assert(ports, DeepEquals, []instance.Port{{"tcp", 89}})
         ports, err = inst1.Ports("1")
         c.Assert(err, IsNil)
-        c.Assert(ports, DeepEquals, []params.Port{{"tcp", 45}, {"udp", 67}})
+        c.Assert(ports, DeepEquals, []instance.Port{{"tcp", 45}, {"udp", 67}})
 
         // Check that we can close multiple ports.
-        err = inst1.ClosePorts("1", []params.Port{{"tcp", 45}, {"udp", 67}})
+        err = inst1.ClosePorts("1", []instance.Port{{"tcp", 45}, {"udp", 67}})
         c.Assert(err, IsNil)
         ports, err = inst1.Ports("1")
         c.Assert(ports, HasLen, 0)
 
         // Check that we can close ports that aren't there.
-        err = inst2.ClosePorts("2", []params.Port{{"tcp", 111}, {"udp", 222}})
+        err = inst2.ClosePorts("2", []instance.Port{{"tcp", 111}, {"udp", 222}})
         c.Assert(err, IsNil)
         ports, err = inst2.Ports("2")
-        c.Assert(ports, DeepEquals, []params.Port{{"tcp", 89}})
+        c.Assert(ports, DeepEquals, []instance.Port{{"tcp", 89}})
 
         // Check errors when acting on environment.
-        err = t.Env.OpenPorts([]params.Port{{"tcp", 80}})
+        err = t.Env.OpenPorts([]instance.Port{{"tcp", 80}})
         c.Assert(err, ErrorMatches, `invalid firewall mode for opening ports on environment: "instance"`)
 
-        err = t.Env.ClosePorts([]params.Port{{"tcp", 80}})
+        err = t.Env.ClosePorts([]instance.Port{{"tcp", 80}})
         c.Assert(err, ErrorMatches, `invalid firewall mode for closing ports on environment: "instance"`)
 
         _, err = t.Env.Ports()
         c.Assert(err, ErrorMatches, `invalid firewall mode for retrieving ports from environment: "instance"`)
 }
 
 func (t *LiveTests) TestGlobalPorts(c *C) {
         // Change configuration.
         oldConfig := t.Env.Config()
         defer func() {
                 err := t.Env.SetConfig(oldConfig)
                 c.Assert(err, IsNil)
         }()
 
         attrs := t.Env.Config().AllAttrs()
         attrs["firewall-mode"] = "global"
         newConfig, err := t.Env.Config().Apply(attrs)
         c.Assert(err, IsNil)
         err = t.Env.SetConfig(newConfig)
         c.Assert(err, IsNil)
 
         // Create instances and check open ports on both instances.
         inst1 := testing.StartInstance(c, t.Env, "1")
-        defer t.Env.StopInstances([]environs.Instance{inst1})
+        defer t.Env.StopInstances([]instance.Instance{inst1})
         ports, err := t.Env.Ports()
         c.Assert(err, IsNil)
         c.Assert(ports, HasLen, 0)
 
         inst2 := testing.StartInstance(c, t.Env, "2")
         ports, err = t.Env.Ports()
         c.Assert(err, IsNil)
         c.Assert(ports, HasLen, 0)
-        defer t.Env.StopInstances([]environs.Instance{inst2})
-
-        err = t.Env.OpenPorts([]params.Port{{"udp", 67}, {"tcp", 45}, {"tcp", 89}, {"tcp", 99}})
+        defer t.Env.StopInstances([]instance.Instance{inst2})
+
+        err = t.Env.OpenPorts([]instance.Port{{"udp", 67}, {"tcp", 45}, {"tcp", 89}, {"tcp", 99}})
         c.Assert(err, IsNil)
 
         ports, err = t.Env.Ports()
         c.Assert(err, IsNil)
-        c.Assert(ports, DeepEquals, []params.Port{{"tcp", 45}, {"tcp", 89}, {"tcp", 99}, {"udp", 67}})
+        c.Assert(ports, DeepEquals, []instance.Port{{"tcp", 45}, {"tcp", 89}, {"tcp", 99}, {"udp", 67}})
 
         // Check closing some ports.
-        err = t.Env.ClosePorts([]params.Port{{"tcp", 99}, {"udp", 67}})
+        err = t.Env.ClosePorts([]instance.Port{{"tcp", 99}, {"udp", 67}})
         c.Assert(err, IsNil)
 
         ports, err = t.Env.Ports()
         c.Assert(err, IsNil)
-        c.Assert(ports, DeepEquals, []params.Port{{"tcp", 45}, {"tcp", 89}})
+        c.Assert(ports, DeepEquals, []instance.Port{{"tcp", 45}, {"tcp", 89}})
 
         // Check that we can close ports that aren't there.
-        err = t.Env.ClosePorts([]params.Port{{"tcp", 111}, {"udp", 222}})
+        err = t.Env.ClosePorts([]instance.Port{{"tcp", 111}, {"udp", 222}})
         c.Assert(err, IsNil)
 
         ports, err = t.Env.Ports()
         c.Assert(err, IsNil)
-        c.Assert(ports, DeepEquals, []params.Port{{"tcp", 45}, {"tcp", 89}})
+        c.Assert(ports, DeepEquals, []instance.Port{{"tcp", 45}, {"tcp", 89}})
 
         // Check errors when acting on instances.
-        err = inst1.OpenPorts("1", []params.Port{{"tcp", 80}})
+        err = inst1.OpenPorts("1", []instance.Port{{"tcp", 80}})
         c.Assert(err, ErrorMatches, `invalid firewall mode for opening ports on instance: "global"`)
 
-        err = inst1.ClosePorts("1", []params.Port{{"tcp", 80}})
+        err = inst1.ClosePorts("1", []instance.Port{{"tcp", 80}})
         c.Assert(err, ErrorMatches, `invalid firewall mode for closing ports on instance: "global"`)
 
         _, err = inst1.Ports("1")
         c.Assert(err, ErrorMatches, `invalid firewall mode for retrieving ports from instance: "global"`)
 }
 
 func (t *LiveTests) TestBootstrapMultiple(c *C) {
         t.BootstrapOnce(c)
 
         err := environs.Bootstrap(t.Env, constraints.Value{})
@@ skipping 14 matching lines @@
         t.BootstrapOnce(c)
 
         // TODO(niemeyer): Stop growing this kitchen sink test and split it into proper parts.
 
         c.Logf("opening connection")
         conn, err := juju.NewConn(t.Env)
         c.Assert(err, IsNil)
         defer conn.Close()
 
         c.Logf("opening API connection")
-        apiConn, err := juju.NewAPIConn(t.Env)
+        apiConn, err := juju.NewAPIConn(t.Env, api.DefaultDialOpts())
         c.Assert(err, IsNil)
         defer conn.Close()
 
         // 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)
         agentVersion, ok := cfg.AgentVersion()
         c.Check(ok, Equals, true)
         c.Check(agentVersion, Equals, version.CurrentNumber())
@@ skipping 101 matching lines @@
                 err = m1.Refresh()
                 if errors.IsNotFoundError(err) {
                         break
                 }
                 c.Assert(err, IsNil)
         }
         c.Logf("waiting for instance to be removed")
         t.assertStopInstance(c, conn.Environ, instId1)
 }
 
+func (t *LiveTests) TestBootstrapVerifyStorage(c *C) {
+        // Bootstrap automatically verifies that storage is writable.
+        t.BootstrapOnce(c)
+        environ := t.Env
+        storage := environ.Storage()
+        reader, err := storage.Get("bootstrap-verify")
+        c.Assert(err, IsNil)
+        defer reader.Close()
+        contents, err := ioutil.ReadAll(reader)
+        c.Assert(err, IsNil)
+        c.Check(string(contents), Equals,
+                "juju-core storage writing verified: ok\n")
+}
+
 type tooler interface {
         Life() state.Life
         AgentTools() (*state.Tools, error)
         Refresh() error
         String() string
 }
 
 type watcher interface {
         Stop() error
         Err() error
@@ skipping 130 matching lines @@
 
 func (t *LiveTests) assertStartInstance(c *C, m *state.Machine) {
         // Wait for machine to get an instance id.
         for a := waitAgent.Start(); a.Next(); {
                 err := m.Refresh()
                 c.Assert(err, IsNil)
                 instId, ok := m.InstanceId()
                 if !ok {
                         continue
                 }
-                _, err = t.Env.Instances([]state.InstanceId{instId})
+                _, err = t.Env.Instances([]instance.Id{instId})
                 c.Assert(err, IsNil)
                 return
         }
         c.Fatalf("provisioner failed to start machine after %v", waitAgent.Total)
 }
 
-func (t *LiveTests) assertStopInstance(c *C, env environs.Environ, instId state.InstanceId) {
+func (t *LiveTests) assertStopInstance(c *C, env environs.Environ, instId instance.Id) {
         var err error
         for a := waitAgent.Start(); a.Next(); {
-                _, err = t.Env.Instances([]state.InstanceId{instId})
+                _, err = t.Env.Instances([]instance.Id{instId})
                 if err == nil {
                         continue
                 }
                 if err == environs.ErrNoInstances {
                         return
                 }
                 c.Logf("error from Instances: %v", err)
         }
         c.Fatalf("provisioner failed to stop machine after %v", waitAgent.Total)
 }
 
 // assertInstanceId asserts that the machine has an instance id
 // that matches that of the given instance. If the instance is nil,
 // It asserts that the instance id is unset.
-func assertInstanceId(c *C, m *state.Machine, inst environs.Instance) {
-        var wantId, gotId state.InstanceId
+func assertInstanceId(c *C, m *state.Machine, inst instance.Instance) {
+        var wantId, gotId instance.Id
         var err error
         if inst != nil {
                 wantId = inst.Id()
         }
         for a := waitAgent.Start(); a.Next(); {
                 err := m.Refresh()
                 c.Assert(err, IsNil)
                 var ok bool
                 gotId, ok = m.InstanceId()
                 if !ok {
@@ skipping 46 matching lines @@
         checkFileDoesNotExist(c, storage, name, t.Attempt)
         // removing a file that does not exist should not be an error.
         err = storage.Remove(name)
         c.Check(err, IsNil)
 }
 
 // Check that we can't start an instance running tools that correspond with no
 // available platform.  The first thing start instance should do is find
 // appropriate tools.
 func (t *LiveTests) TestStartInstanceOnUnknownPlatform(c *C) {
-        inst, err := t.Env.StartInstance("4", "fake_nonce", "unknownseries", constraints.Value{}, testing.InvalidStateInfo("4"), testing.InvalidAPIInfo("4"))
+        inst, err := t.Env.StartInstance("4", "fake_nonce", "unknownseries", constraints.Value{}, testing.FakeStateInfo("4"), testing.FakeAPIInfo("4"))
         if inst != nil {
-                err := t.Env.StopInstances([]environs.Instance{inst})
+                err := t.Env.StopInstances([]instance.Instance{inst})
                 c.Check(err, IsNil)
         }
         c.Assert(inst, IsNil)
         var notFoundError *errors.NotFoundError
         c.Assert(err, FitsTypeOf, notFoundError)
         c.Assert(err, ErrorMatches, "no matching tools available")
 }
 
 // Check that we can't start an instance with an empty nonce value.
 func (t *LiveTests) TestStartInstanceWithEmptyNonceFails(c *C) {
-        inst, err := t.Env.StartInstance("4", "", config.DefaultSeries, constraints.Value{}, testing.InvalidStateInfo("4"), testing.InvalidAPIInfo("4"))
+        inst, err := t.Env.StartInstance("4", "", config.DefaultSeries, constraints.Value{}, testing.FakeStateInfo("4"), testing.FakeAPIInfo("4"))
         if inst != nil {
-                err := t.Env.StopInstances([]environs.Instance{inst})
+                err := t.Env.StopInstances([]instance.Instance{inst})
                 c.Check(err, IsNil)
         }
         c.Assert(inst, IsNil)
         c.Assert(err, ErrorMatches, ".*missing machine nonce")
 }
 
 func (t *LiveTests) TestBootstrapWithDefaultSeries(c *C) {
         if !t.HasProvisioner {
                 c.Skip("HasProvisioner is false; cannot test deployment")
         }
@@ skipping 69 matching lines @@
                 return err
         }
         var buf bytes.Buffer
         _, err = io.Copy(&buf, rc)
         rc.Close()
         if err != nil {
                 return err
         }
         return target.Put(targetPath, &buf, int64(buf.Len()))
 }