func (s *StorageSuite) TestUpload(c *gc.C) {
t, err := tools.Upload(s.env.Storage(), nil)
c.Assert(err, gc.IsNil)
c.Assert(t.Version, gc.Equals, version.Current)
c.Assert(t.URL, gc.Not(gc.Equals), "")
dir := downloadTools(c, t)
out, err := exec.Command(filepath.Join(dir, "jujud"), "version").CombinedOutput()
c.Assert(err, gc.IsNil)
c.Assert(string(out), gc.Equals, version.Current.String()+"\n")
}
func (s *StorageSuite) TestUploadAndForceVersion(c *gc.C) {
// This test actually tests three things:
// the writing of the FORCE-VERSION file;
// the reading of the FORCE-VERSION file by the version package;
// and the reading of the version from jujud.
vers := version.Current
vers.Patch++
t, err := tools.Upload(s.env.Storage(), &vers.Number)
c.Assert(err, gc.IsNil)
c.Assert(t.Version, gc.Equals, vers)
}
func (t *LiveTests) BootstrapOnce(c *C) {
if t.bootstrapped {
return
}
// We only build and upload tools if there will be a state agent that
// we could connect to (actual live tests, rather than local-only)
cons := constraints.MustParse("mem=2G")
if t.CanOpenState {
_, err := tools.Upload(t.Env.Storage(), nil, config.DefaultSeries)
c.Assert(err, IsNil)
}
err := environs.Bootstrap(t.Env, cons)
c.Assert(err, IsNil)
t.bootstrapped = true
}
// Test that the upload procedure fails correctly
// when the build process fails (because of a bad Go source
// file in this case).
func (s *StorageSuite) TestUploadBadBuild(c *gc.C) {
gopath := c.MkDir()
join := append([]string{gopath, "src"}, strings.Split("launchpad.net/juju-core/cmd/broken", "/")...)
pkgdir := filepath.Join(join...)
err := os.MkdirAll(pkgdir, 0777)
c.Assert(err, gc.IsNil)
err = ioutil.WriteFile(filepath.Join(pkgdir, "broken.go"), []byte("nope"), 0666)
c.Assert(err, gc.IsNil)
defer os.Setenv("GOPATH", os.Getenv("GOPATH"))
os.Setenv("GOPATH", gopath)
t, err := tools.Upload(s.env.Storage(), nil)
c.Assert(t, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `build command "go" failed: exit status 1; can't load package:(.|\n)*`)
}
func (s *StorageSuite) TestUploadFakeSeries(c *gc.C) {
t, err := tools.Upload(s.env.Storage(), nil, "sham", "fake")
c.Assert(err, gc.IsNil)
c.Assert(t.Version, gc.Equals, version.Current)
expectRaw := downloadToolsRaw(c, t)
list, err := tools.ReadList(s.env.Storage(), version.Current.Major)
c.Assert(err, gc.IsNil)
c.Assert(list, gc.HasLen, 3)
expectSeries := []string{"fake", "sham", version.CurrentSeries()}
sort.Strings(expectSeries)
c.Assert(list.Series(), gc.DeepEquals, expectSeries)
for _, t := range list {
c.Logf("checking %s", t.URL)
c.Assert(t.Version.Number, gc.Equals, version.CurrentNumber())
actualRaw := downloadToolsRaw(c, t)
c.Assert(string(actualRaw), gc.Equals, string(expectRaw))
}
}
// 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, waiters ...*toolsWaiter) {
c.Logf("putting testing version of juju tools")
upgradeTools, err := tools.Upload(t.Env.Storage(), &newVersion.Number, newVersion.Series)
c.Assert(err, IsNil)
// tools.Upload always returns tools for the series on which the tests are running.
// We are only interested in checking the version.Number below so need to fake the
// upgraded tools series to match that of newVersion.
upgradeTools.Series = newVersion.Series
// Check that the put version really is the version we expect.
c.Assert(upgradeTools.Binary, Equals, newVersion)
err = statetesting.SetAgentVersion(conn.State, newVersion.Number)
c.Assert(err, IsNil)
for i, w := range waiters {
c.Logf("waiting for upgrade of %d: %v", i, w.tooler.String())
waitAgentTools(c, w, newVersion)
c.Logf("upgrade %d successful", i)
}
}
func (t *LiveTests) TestBootstrapWithDefaultSeries(c *C) {
if !t.HasProvisioner {
c.Skip("HasProvisioner is false; cannot test deployment")
}
current := version.Current
other := current
other.Series = "quantal"
if current == other {
other.Series = "precise"
}
cfg := t.Env.Config()
cfg, err := cfg.Apply(map[string]interface{}{"default-series": other.Series})
c.Assert(err, IsNil)
env, err := environs.New(cfg)
c.Assert(err, IsNil)
dummyenv, err := environs.NewFromAttrs(map[string]interface{}{
"type": "dummy",
"name": "dummy storage",
"secret": "pizza",
"state-server": false,
"ca-cert": coretesting.CACert,
"ca-private-key": coretesting.CAKey,
})
c.Assert(err, IsNil)
defer dummyenv.Destroy(nil)
// BUG: We destroy the environment, then write to its storage.
// This is bogus, strictly speaking, but it works on
// existing providers for the time being and means
// this test does not fail when the environment is
// already bootstrapped.
t.Destroy(c)
currentName := tools.StorageName(current)
otherName := tools.StorageName(other)
envStorage := env.Storage()
dummyStorage := dummyenv.Storage()
defer envStorage.Remove(otherName)
_, err = tools.Upload(dummyStorage, ¤t.Number)
c.Assert(err, IsNil)
// This will only work while cross-compiling across releases is safe,
// which depends on external elements. Tends to be safe for the last
// few releases, but we may have to refactor some day.
err = storageCopy(dummyStorage, currentName, envStorage, otherName)
c.Assert(err, IsNil)
err = environs.Bootstrap(env, constraints.Value{})
c.Assert(err, IsNil)
defer env.Destroy(nil)
conn, err := juju.NewConn(env)
c.Assert(err, IsNil)
defer conn.Close()
// Wait for machine agent to come up on the bootstrap
// machine and ensure it deployed the proper series.
m0, err := conn.State.Machine("0")
c.Assert(err, IsNil)
mw0 := newMachineToolWaiter(m0)
defer mw0.Stop()
waitAgentTools(c, mw0, other)
}