func (s *mongoRestoreSuite) TestMongoRestoreArgsForOldVersion(c *gc.C) {
versionNumber := version.Number{}
versionNumber.Major = 0
versionNumber.Minor = 0
_, err := backups.MongoRestoreArgsForVersion(versionNumber, "/some/fake/path")
c.Assert(err, gc.ErrorMatches, "this backup file is incompatible with the current version of juju")
}
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
}
}
func checkUpgradeInfoSanity(st *State, machineId string, previousVersion, targetVersion version.Number) (bson.D, error) {
if previousVersion.Compare(targetVersion) != -1 {
return nil, errors.Errorf("cannot sanely upgrade from %s to %s", previousVersion, targetVersion)
}
controllerInfo, err := st.ControllerInfo()
if err != nil {
return nil, errors.Annotate(err, "cannot read controllers")
}
validIds := set.NewStrings(controllerInfo.MachineIds...)
if !validIds.Contains(machineId) {
return nil, errors.Errorf("machine %q is not a controller", machineId)
}
return assertExpectedVersions(previousVersion, targetVersion), nil
}
// 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
}
// UpdateLatestToolsVersion looks up for the latest available version of
// juju tools and updates environementDoc with it.
func (e *Environment) UpdateLatestToolsVersion(ver version.Number) error {
v := ver.String()
// TODO(perrito666): I need to assert here that there isn't a newer
// version in place.
ops := []txn.Op{{
C: environmentsC,
Id: e.doc.UUID,
Update: bson.D{{"$set", bson.D{{"available-tools", v}}}},
}}
err := e.st.runTransaction(ops)
if err != nil {
return errors.Trace(err)
}
return e.Refresh()
}
func (s *mongoRestoreSuite) TestMongoRestoreArgsForVersion121(c *gc.C) {
dir := filepath.Join(agent.DefaultPaths.DataDir, "db")
versionNumber := version.Number{}
versionNumber.Major = 1
versionNumber.Minor = 21
args, err := backups.MongoRestoreArgsForVersion(versionNumber, "/some/fake/path")
c.Assert(err, jc.ErrorIsNil)
c.Assert(args, gc.HasLen, 5)
c.Assert(args[0:5], jc.DeepEquals, []string{
"--drop",
"--journal",
"--dbpath",
dir,
"/some/fake/path",
})
}
// PreferredStream returns the tools stream used to search for tools, based
// on the required version, whether devel mode is required, and any user specified stream.
func PreferredStream(vers *version.Number, forceDevel bool, stream string) string {
// If the use has already nominated a specific stream, we'll use that.
if stream != "" && stream != ReleasedStream {
return stream
}
// If we're not upgrading from a known version, we use the
// currently running version.
if vers == nil {
vers = &version.Current.Number
}
// Devel versions are alpha or beta etc as defined by the version tag.
// The user can also force the use of devel streams via config.
if forceDevel || vers.IsDev() {
return DevelStream
}
return ReleasedStream
}
func (s *mongoRestoreSuite) TestMongoRestoreArgsForVersion(c *gc.C) {
dir := filepath.Join(agent.DefaultDataDir, "db")
versionNumber := version.Number{}
versionNumber.Major = 1
versionNumber.Minor = 21
args, err := backups.MongoRestoreArgsForVersion(versionNumber, "/some/fake/path")
c.Assert(err, jc.ErrorIsNil)
c.Assert(args, gc.HasLen, 5)
c.Assert(args[0:5], jc.DeepEquals, []string{
"--drop",
"--journal",
"--dbpath",
dir,
"/some/fake/path",
})
versionNumber.Major = 1
versionNumber.Minor = 22
args, err = backups.MongoRestoreArgsForVersion(versionNumber, "/some/fake/path")
c.Assert(err, jc.ErrorIsNil)
c.Assert(args, gc.HasLen, 6)
c.Assert(args[0:6], jc.DeepEquals, []string{
"--drop",
"--journal",
"--oplogReplay",
"--dbpath",
dir,
"/some/fake/path",
})
versionNumber.Major = 0
versionNumber.Minor = 0
_, err = backups.MongoRestoreArgsForVersion(versionNumber, "/some/fake/path")
c.Assert(err, gc.ErrorMatches, "this backup file is incompatible with the current version of juju")
}
// 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
}
func newOpsIterator(from, to version.Number, ops []Operation) *opsIterator {
// If from is not known, it is 1.16.
if from == version.Zero {
from = version.MustParse("1.16.0")
}
// Clear the version tag of the target release to ensure that all
// upgrade steps for the release are run for alpha and beta
// releases.
// ...but only do this if the agent version has actually changed,
// lest we trigger upgrade mode unnecessarily for non-final
// versions.
if from.Compare(to) != 0 {
to.Tag = ""
}
return &opsIterator{
from: from,
to: to,
allOps: ops,
current: -1,
}
}
// 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, names.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 := archiveAndSHA256(w, dir)
if err != nil {
return version.Binary{}, "", err
}
return tvers, sha256hash, err
}
// 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
}
// 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
}
// 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) (err error) {
buildTxn := func(attempt int) ([]txn.Op, error) {
settings, err := readSettings(st, environGlobalKey)
if err != nil {
return nil, err
}
agentVersion, ok := settings.Get("agent-version")
if !ok {
return nil, fmt.Errorf("no agent version set in the environment")
}
currentVersion, ok := agentVersion.(string)
if !ok {
return nil, fmt.Errorf("invalid agent version format: expected string, got %v", agentVersion)
}
if newVersion.String() == currentVersion {
// Nothing to do.
return nil, jujutxn.ErrNoOperations
}
if err := st.checkCanUpgrade(currentVersion, newVersion.String()); err != nil {
return nil, 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()}}}},
}}
return ops, nil
}
if err = st.run(buildTxn); err == jujutxn.ErrExcessiveContention {
err = errors.Annotate(err, "cannot set agent version")
}
return err
}
func isPreHAVersion(v version.Number) bool {
return v.Compare(version.MustParse("1.19.0")) < 0
}
func isCompatibleVersion(v1, v2 version.Number) bool {
v1.Build = 0
v2.Build = 0
return v1.Compare(v2) == 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)
}