Add machine instance metadata to state

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"
         coretesting "launchpad.net/juju-core/testing"
+        . "launchpad.net/juju-core/testing/checkers"
         "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 {
         coretesting.LoggingSuite
@@ skipping 316 matching lines @@
         // Check that the constraints have been set in the environment.
         cons, err := conn.State.EnvironConstraints()
         c.Assert(err, IsNil)
         c.Assert(cons.String(), Equals, "mem=2048M")
 
         // 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)
 
-        instId0, ok := m0.InstanceId()
-        c.Assert(ok, Equals, true)
+        instId0, err := m0.InstanceId()
+        c.Assert(err, IsNil)
 
         // Check that the API connection is working.
         status, err := apiConn.State.Client().Status()
         c.Assert(err, IsNil)
         c.Assert(status.Machines["0"].InstanceId, Equals, string(instId0))
 
         mw0 := newMachineToolWaiter(m0)
         defer mw0.Stop()
 
         // If the series has not been specified, we expect the most recent Ubuntu LTS release to be used.
@@ skipping 20 matching lines @@
         mid1, err := unit.AssignedMachineId()
         c.Assert(err, IsNil)
         m1, err := conn.State.Machine(mid1)
         c.Assert(err, IsNil)
         mw1 := newMachineToolWaiter(m1)
         defer mw1.Stop()
         waitAgentTools(c, mw1, mtools0.Binary)
 
         err = m1.Refresh()
         c.Assert(err, IsNil)
-        instId1, ok := m1.InstanceId()
-        c.Assert(ok, Equals, true)
+        instId1, err := m1.InstanceId()
+        c.Assert(err, IsNil)
         uw := newUnitToolWaiter(unit)
         defer uw.Stop()
         utools := waitAgentTools(c, uw, expectedVersion)
 
         // Check that we can upgrade the environment.
         newVersion := utools.Binary
         newVersion.Patch++
         t.checkUpgrade(c, conn, newVersion, mw0, mw1, uw)
 
         // BUG(niemeyer): Logic below is very much wrong. Must be:
@@ skipping 196 matching lines @@
 var waitAgent = utils.AttemptStrategy{
         Total: 30 * time.Second,
         Delay: 1 * time.Second,
 }
 
 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 {
+                instId, err := m.InstanceId()
+                if err != nil {
+                        c.Assert(state.IsNotProvisionedError(err), IsTrue)
                         continue
                 }
                 _, 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 instance.Id) {
@@ skipping 16 matching lines @@
 // It asserts that the instance id is unset.
 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 {
+                gotId, err = m.InstanceId()
+                if err != nil {
+                        c.Assert(state.IsNotProvisionedError(err), IsTrue)
                         if inst == nil {
                                 return
                         }
                         continue
                 }
                 break
         }
         c.Assert(err, IsNil)
         c.Assert(gotId, Equals, wantId)
 }
@@ skipping 141 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()))
 }