func (s *uploadSuite) TestSyncTools(c *gc.C) { builtTools, err := sync.BuildToolsTarball(nil) c.Assert(err, gc.IsNil) t, err := sync.SyncBuiltTools(s.env.Storage(), builtTools) 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 *uploadSuite) TestSyncToolsFakeSeries(c *gc.C) { seriesToUpload := "precise" if seriesToUpload == version.Current.Series { seriesToUpload = "raring" } builtTools, err := sync.BuildToolsTarball(nil) c.Assert(err, gc.IsNil) t, err := sync.SyncBuiltTools(s.env.Storage(), builtTools, "quantal", seriesToUpload) c.Assert(err, gc.IsNil) s.assertUploadedTools(c, t, seriesToUpload) }
func (s *uploadSuite) TestSyncAndForceVersion(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++ builtTools, err := sync.BuildToolsTarball(&vers.Number) c.Assert(err, gc.IsNil) t, err := sync.SyncBuiltTools(s.env.Storage(), builtTools) c.Assert(err, gc.IsNil) c.Assert(t.Version, gc.Equals, vers) }
// uploadTools compiles jujud from $GOPATH and uploads it into the supplied // storage. If no version has been explicitly chosen, the version number // reported by the built tools will be based on the client version number. // In any case, the version number reported will have a build component higher // than that of any otherwise-matching available envtools. // uploadTools resets the chosen version and replaces the available tools // with the ones just uploaded. func (context *upgradeContext) uploadTools(series []string) (err error) { // TODO(fwereade): this is kinda crack: we should not assume that // version.Current matches whatever source happens to be built. The // ideal would be: // 1) compile jujud from $GOPATH into some build dir // 2) get actual version with `jujud version` // 3) check actual version for compatibility with CLI tools // 4) generate unique build version with reference to available tools // 5) force-version that unique version into the dir directly // 6) archive and upload the build dir // ...but there's no way we have time for that now. In the meantime, // considering the use cases, this should work well enough; but it // won't detect an incompatible major-version change, which is a shame. if context.chosen == version.Zero { context.chosen = context.client } context.chosen = uploadVersion(context.chosen, context.tools) builtTools, err := sync.BuildToolsTarball(&context.chosen) if err != nil { return err } defer os.RemoveAll(builtTools.Dir) var uploaded *coretools.Tools toolsPath := path.Join(builtTools.Dir, builtTools.StorageName) logger.Infof("uploading tools %v (%dkB) to Juju state server", builtTools.Version, (builtTools.Size+512)/1024) uploaded, err = context.apiClient.UploadTools(toolsPath, builtTools.Version, series...) if params.IsCodeNotImplemented(err) { uploaded, err = context.uploadTools1dot17(builtTools, series...) } if err != nil { return err } context.tools = coretools.List{uploaded} return nil }