func (s *badBuildSuite) TestUploadToolsBadBuild(c *gc.C) {
// Test that original Upload Func fails as expected
t, err := sync.Upload(s.env.Storage(), nil)
c.Assert(t, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `build command "go" failed: exit status 1; `)
// Test that Upload func passes after BundleTools func is mocked out
s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c))
t, err = sync.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), "")
}
func (s *badBuildSuite) TestUploadToolsBadBuild(c *gc.C) {
stor, err := filestorage.NewFileStorageWriter(c.MkDir())
c.Assert(err, jc.ErrorIsNil)
// Test that original Upload Func fails as expected
t, err := sync.Upload(stor, "released", nil)
c.Assert(t, gc.IsNil)
c.Assert(err, gc.ErrorMatches, `cannot build jujud agent binary from source: build command \"go\" failed: exit status 1; `)
// Test that Upload func passes after BundleTools func is mocked out
s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c, nil))
t, err = sync.Upload(stor, "released", nil)
c.Assert(err, jc.ErrorIsNil)
s.assertEqualsCurrentVersion(c, t.Version)
c.Assert(t.URL, gc.Not(gc.Equals), "")
}
func (s *uploadSuite) TestUpload(c *gc.C) {
t, err := sync.Upload(s.targetStorage, "released", nil)
c.Assert(err, jc.ErrorIsNil)
s.assertEqualsCurrentVersion(c, t.Version)
c.Assert(t.URL, gc.Not(gc.Equals), "")
s.assertUploadedTools(c, t, []string{series.HostSeries()}, "released")
}
func (s *uploadSuite) TestUploadAndForceVersion(c *gc.C) {
vers := jujuversion.Current
vers.Patch++
s.patchBundleTools(c, &vers)
t, err := sync.Upload(s.targetStorage, "released", &vers)
c.Assert(err, jc.ErrorIsNil)
c.Assert(t.Version, gc.Equals, version.Binary{Number: jujuversion.Current, Arch: arch.HostArch(), Series: series.HostSeries()})
}
func (t *LiveTests) TestBootstrapWithDefaultSeries(c *gc.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"
}
dummyCfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Merge(coretesting.Attrs{
"state-server": false,
"name": "dummy storage",
}))
dummyenv, err := environs.Prepare(dummyCfg, coretesting.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
defer dummyenv.Destroy()
t.Destroy(c)
attrs := t.TestConfig.Merge(coretesting.Attrs{"default-series": other.Series})
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, coretesting.Context(c), t.ConfigStore)
c.Assert(err, gc.IsNil)
defer environs.Destroy(env, t.ConfigStore)
currentName := envtools.StorageName(current)
otherName := envtools.StorageName(other)
envStorage := env.Storage()
dummyStorage := dummyenv.Storage()
defer envStorage.Remove(otherName)
_, err = sync.Upload(dummyStorage, ¤t.Number)
c.Assert(err, gc.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, gc.IsNil)
err = bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
st := t.Env.(testing.GetStater).GetStateInAPIServer()
// Wait for machine agent to come up on the bootstrap
// machine and ensure it deployed the proper series.
m0, err := st.Machine("0")
c.Assert(err, gc.IsNil)
mw0 := newMachineToolWaiter(m0)
defer mw0.Stop()
waitAgentTools(c, mw0, other)
}
func (s *uploadSuite) TestUploadFakeSeries(c *gc.C) {
seriesToUpload := "precise"
if seriesToUpload == version.Current.Series {
seriesToUpload = "raring"
}
t, err := sync.Upload(s.env.Storage(), nil, "quantal", seriesToUpload)
c.Assert(err, gc.IsNil)
s.assertUploadedTools(c, t, seriesToUpload)
}
func (s *uploadSuite) TestUploadFakeSeries(c *gc.C) {
seriesToUpload := "precise"
if seriesToUpload == series.HostSeries() {
seriesToUpload = "raring"
}
t, err := sync.Upload(s.targetStorage, "released", nil, "quantal", seriesToUpload)
c.Assert(err, jc.ErrorIsNil)
s.assertUploadedTools(c, t, []string{seriesToUpload, "quantal", series.HostSeries()}, "released")
}
func (s *uploadSuite) 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 := sync.Upload(s.env.Storage(), &vers.Number)
c.Assert(err, gc.IsNil)
c.Assert(t.Version, gc.Equals, vers)
}
func (s *uploadSuite) 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 := sync.Upload(s.targetStorage, "released", &vers)
c.Assert(err, jc.ErrorIsNil)
c.Assert(t.Version, gc.Equals, version.Binary{Number: vers, Arch: arch.HostArch(), Series: series.HostSeries()})
}
func (s *uploadSuite) TestUpload(c *gc.C) {
t, err := sync.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), "")
// TODO(waigani) Does this test need to download tools? If not,
// sync.bundleTools can be mocked to improve test speed.
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")
}
// UploadTools uploads tools for the specified series and any other relevant series to
// the environment storage, after which it sets the agent-version. If forceVersion is true,
// we allow uploading even when the agent-version is already set in the environment.
func UploadTools(ctx environs.BootstrapContext, env environs.Environ, toolsArch *string, forceVersion bool, bootstrapSeries ...string) error {
logger.Infof("checking that upload is possible")
// Check the series are valid.
for _, series := range bootstrapSeries {
if _, err := ubuntu.SeriesVersion(series); err != nil {
return err
}
}
// See that we are allowed to upload the tools.
if err := validateUploadAllowed(env, toolsArch, forceVersion); err != nil {
return err
}
// Make storage interruptible.
interrupted := make(chan os.Signal, 1)
interruptStorage := make(chan struct{})
ctx.InterruptNotify(interrupted)
defer ctx.StopInterruptNotify(interrupted)
defer close(interrupted)
go func() {
defer close(interruptStorage) // closing interrupts all uploads
if _, ok := <-interrupted; ok {
ctx.Infof("cancelling tools upload")
}
}()
stor := newInterruptibleStorage(env.Storage(), interruptStorage)
cfg := env.Config()
explicitVersion := uploadVersion(version.Current.Number, nil)
uploadSeries := SeriesToUpload(cfg, bootstrapSeries)
ctx.Infof("uploading tools for series %s", uploadSeries)
tools, err := sync.Upload(stor, &explicitVersion, uploadSeries...)
if err != nil {
return err
}
cfg, err = cfg.Apply(map[string]interface{}{
"agent-version": tools.Version.Number.String(),
})
if err == nil {
err = env.SetConfig(cfg)
}
if err != nil {
return fmt.Errorf("failed to update environment configuration: %v", err)
}
return nil
}
func (t *LiveTests) BootstrapOnce(c *gc.C) {
if t.bootstrapped {
return
}
t.PrepareOnce(c)
// 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 := sync.Upload(t.toolsStorage, "released", nil, coretesting.FakeDefaultSeries)
c.Assert(err, jc.ErrorIsNil)
}
err := bootstrap.EnsureNotBootstrapped(t.Env)
c.Assert(err, jc.ErrorIsNil)
err = bootstrap.Bootstrap(envtesting.BootstrapContext(c), t.Env, bootstrap.BootstrapParams{Constraints: cons})
c.Assert(err, jc.ErrorIsNil)
t.bootstrapped = true
}
func (t *LiveTests) BootstrapOnce(c *gc.C) {
if t.bootstrapped {
return
}
t.PrepareOnce(c)
// 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 := sync.Upload(t.toolsStorage, "released", nil, series.LatestLts())
c.Assert(err, jc.ErrorIsNil)
}
args := t.bootstrapParams()
args.BootstrapConstraints = cons
args.ModelConstraints = cons
err := bootstrap.Bootstrap(envtesting.BootstrapContext(c), t.Env, args)
c.Assert(err, jc.ErrorIsNil)
t.bootstrapped = true
}
// checkUpgrade sets the environment agent version and checks that
// all the provided watchers upgrade to the requested version.
func (t *LiveTests) checkUpgrade(c *gc.C, st *state.State, newVersion version.Binary, waiters ...*toolsWaiter) {
c.Logf("putting testing version of juju tools")
upgradeTools, err := sync.Upload(t.Env.Storage(), &newVersion.Number, newVersion.Series)
c.Assert(err, gc.IsNil)
// sync.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.Version.Series = newVersion.Series
// Check that the put version really is the version we expect.
c.Assert(upgradeTools.Version, gc.Equals, newVersion)
err = statetesting.SetAgentVersion(st, newVersion.Number)
c.Assert(err, gc.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)
}
}