func (s *upgradeSuite) TestUpgradeOperationsOrdered(c *gc.C) {
var previous version.Number
for i, utv := range (*upgrades.UpgradeOperations)() {
vers := utv.TargetVersion()
if i > 0 {
c.Check(previous.Compare(vers), gc.Equals, -1)
}
previous = vers
}
}
// Newest returns the greatest version in src, and the tools with that version.
func (src List) Newest() (version.Number, List) {
var result List
var best version.Number
for _, tools := range src {
if best.Compare(tools.Version.Number) < 0 {
// Found new best number; reset result list.
best = tools.Version.Number
result = append(result[:0], tools)
} else if tools.Version.Number == best {
result = append(result, tools)
}
}
return best, result
}
// uploadVersion returns a copy of the supplied version with a build number
// higher than any of the supplied tools that share its major, minor and patch.
func uploadVersion(vers version.Number, existing coretools.List) version.Number {
vers.Build++
for _, t := range existing {
if t.Version.Major != vers.Major || t.Version.Minor != vers.Minor || t.Version.Patch != vers.Patch {
continue
}
if t.Version.Build >= vers.Build {
vers.Build = t.Version.Build + 1
}
}
return vers
}
// SetBootstrapTools returns the newest tools from the given tools list,
// and updates the agent-version configuration attribute.
func SetBootstrapTools(environ environs.Environ, possibleTools coretools.List) (coretools.List, error) {
if len(possibleTools) == 0 {
return nil, fmt.Errorf("no bootstrap tools available")
}
var newVersion version.Number
newVersion, toolsList := possibleTools.Newest()
logger.Infof("newest version: %s", newVersion)
cfg := environ.Config()
if agentVersion, _ := cfg.AgentVersion(); agentVersion != newVersion {
cfg, err := cfg.Apply(map[string]interface{}{
"agent-version": newVersion.String(),
})
if err == nil {
err = environ.SetConfig(cfg)
}
if err != nil {
return nil, fmt.Errorf("failed to update environment configuration: %v", err)
}
}
bootstrapVersion := newVersion
// We should only ever bootstrap the exact same version as the client,
// or we risk bootstrap incompatibility. We still set agent-version to
// the newest version, so the agent will immediately upgrade itself.
if !isCompatibleVersion(newVersion, version.Current.Number) {
compatibleVersion, compatibleTools := findCompatibleTools(possibleTools, version.Current.Number)
if len(compatibleTools) == 0 {
logger.Warningf(
"failed to find %s tools, will attempt to use %s",
version.Current.Number, newVersion,
)
} else {
bootstrapVersion, toolsList = compatibleVersion, compatibleTools
}
}
logger.Infof("picked bootstrap tools version: %s", bootstrapVersion)
return toolsList, nil
}
// BundleTools bundles all the current juju tools in gzipped tar
// format to the given writer.
// If forceVersion is not nil, a FORCE-VERSION file is included in
// the tools bundle so it will lie about its current version number.
func BundleTools(w io.Writer, forceVersion *version.Number) (tvers version.Binary, sha256Hash string, err error) {
dir, err := ioutil.TempDir("", "juju-tools")
if err != nil {
return version.Binary{}, "", err
}
defer os.RemoveAll(dir)
if err := copyExistingJujud(dir); err != nil {
logger.Debugf("copy existing failed: %v", err)
if err := buildJujud(dir); err != nil {
return version.Binary{}, "", err
}
}
if forceVersion != nil {
logger.Debugf("forcing version to %s", forceVersion)
if err := ioutil.WriteFile(filepath.Join(dir, "FORCE-VERSION"), []byte(forceVersion.String()), 0666); err != nil {
return version.Binary{}, "", err
}
}
cmd := exec.Command(filepath.Join(dir, "jujud"), "version")
out, err := cmd.CombinedOutput()
if err != nil {
return version.Binary{}, "", fmt.Errorf("cannot get version from %q: %v; %s", cmd.Args[0], err, out)
}
tvs := strings.TrimSpace(string(out))
tvers, err = version.ParseBinary(tvs)
if err != nil {
return version.Binary{}, "", fmt.Errorf("invalid version %q printed by jujud", tvs)
}
sha256Hash, err = archive(w, dir)
if err != nil {
return version.Binary{}, "", err
}
return tvers, sha256Hash, err
}
// SetEnvironAgentVersion changes the agent version for the
// environment to the given version, only if the environment is in a
// stable state (all agents are running the current version).
func (st *State) SetEnvironAgentVersion(newVersion version.Number) error {
for i := 0; i < 5; i++ {
settings, err := readSettings(st, environGlobalKey)
if err != nil {
return err
}
agentVersion, ok := settings.Get("agent-version")
if !ok {
return fmt.Errorf("no agent version set in the environment")
}
currentVersion, ok := agentVersion.(string)
if !ok {
return fmt.Errorf("invalid agent version format: expected string, got %v", agentVersion)
}
if newVersion.String() == currentVersion {
// Nothing to do.
return nil
}
if err := st.checkCanUpgrade(currentVersion, newVersion.String()); err != nil {
return err
}
ops := []txn.Op{{
C: st.settings.Name,
Id: environGlobalKey,
Assert: bson.D{{"txn-revno", settings.txnRevno}},
Update: bson.D{{"$set", bson.D{{"agent-version", newVersion.String()}}}},
}}
if err := st.runTransaction(ops); err == nil {
return nil
} else if err != txn.ErrAborted {
return fmt.Errorf("cannot set agent-version: %v", err)
}
}
return ErrExcessiveContention
}
func isPreHAVersion(v version.Number) bool {
return v.Compare(version.MustParse("1.19.0")) < 0
}
// SetAgentVersion sets the current agent version in the state's
// environment configuration.
// This is similar to state.SetEnvironAgentVersion but it doesn't require that
// the environment have all agents at the same version already.
func SetAgentVersion(st *state.State, vers version.Number) error {
return st.UpdateEnvironConfig(map[string]interface{}{"agent-version": vers.String()}, nil, nil)
}
func isCompatibleVersion(v1, v2 version.Number) bool {
v1.Build = 0
v2.Build = 0
return v1.Compare(v2) == 0
}