// initVersions collects state relevant to an upgrade decision. The returned
// agent and client versions, and the list of currently available tools, will
// always be accurate; the chosen version, and the flag indicating development
// mode, may remain blank until uploadTools or validate is called.
func (c *UpgradeJujuCommand) initVersions(cfg *config.Config, env environs.Environ) (*upgradeVersions, error) {
agent, ok := cfg.AgentVersion()
if !ok {
// Can't happen. In theory.
return nil, fmt.Errorf("incomplete environment configuration")
}
if c.Version == agent {
return nil, errUpToDate
}
client := version.Current.Number
available, err := environs.FindAvailableTools(env, client.Major)
if err != nil {
if !errors.IsNotFoundError(err) {
return nil, err
}
if !c.UploadTools {
if c.Version == version.Zero {
return nil, errUpToDate
}
return nil, err
}
}
dev := c.Development || cfg.Development() || agent.IsDev() || client.IsDev()
return &upgradeVersions{
dev: dev,
agent: agent,
client: client,
chosen: c.Version,
tools: available,
}, nil
}
func (s *ToolsSuite) TestFindAvailableTools(c *C) {
for i, test := range findAvailableToolsTests {
c.Logf("\ntest %d: %s", i, test.info)
s.Reset(c, nil)
private := s.uploadPrivate(c, test.private...)
public := s.uploadPublic(c, test.public...)
actual, err := environs.FindAvailableTools(s.env, test.major)
if test.err != nil {
if len(actual) > 0 {
c.Logf(actual.String())
}
c.Check(err, DeepEquals, &errors.NotFoundError{test.err, ""})
continue
}
source := private
if len(source) == 0 {
// We only use the public bucket if the private one has *no* tools.
source = public
}
expect := map[version.Binary]string{}
for _, expected := range test.expect {
expect[expected] = source[expected]
}
c.Check(actual.URLs(), DeepEquals, expect)
}
}
// checkTools check if the environment contains the passed tools.
func checkTools(c *gc.C, env environs.Environ, tools []version.Binary) {
list, err := environs.FindAvailableTools(env, version.Current.Major)
c.Check(err, gc.IsNil)
c.Logf("found: " + list.String())
urls := list.URLs()
c.Check(urls, gc.HasLen, len(tools))
}
func (s *syncSuite) TestSyncing(c *gc.C) {
for _, test := range tests {
// Perform all tests in a "clean" environment.
func() {
s.setUpTest(c)
defer s.tearDownTest(c)
c.Log(test.description)
if test.source {
test.ctx.Source = s.localStorage
}
err := sync.SyncTools(test.ctx)
c.Assert(err, gc.IsNil)
targetTools, err := environs.FindAvailableTools(s.targetEnv, 1)
c.Assert(err, gc.IsNil)
assertToolsList(c, targetTools, test.tools)
if test.emptyPublic {
assertEmpty(c, s.targetEnv.PublicStorage())
} else {
assertEmpty(c, s.targetEnv.Storage())
}
}()
}
}
func (s *syncToolsSuite) TestCopyToDummyPublic(c *C) {
ctx, err := runSyncToolsCommand(c, "-e", "test-target", "--public")
c.Assert(err, IsNil)
c.Assert(ctx, NotNil)
// Newest released tools made available to target env.
targetTools, err := environs.FindAvailableTools(s.targetEnv, 1)
c.Assert(err, IsNil)
assertToolsList(c, targetTools, v100all)
// Private bucket was not touched.
assertEmpty(c, s.targetEnv.Storage())
}
func (s *syncToolsSuite) TestCopyAllDevFromDummy(c *C) {
ctx, err := runSyncToolsCommand(c, "-e", "test-target", "--all", "--dev")
c.Assert(err, IsNil)
c.Assert(ctx, NotNil)
// All v1 tools, dev and release, made available to target env.
targetTools, err := environs.FindAvailableTools(s.targetEnv, 1)
c.Assert(err, IsNil)
assertToolsList(c, targetTools, v1all)
// Public bucket was not touched.
assertEmpty(c, s.targetEnv.PublicStorage())
}
func (s *syncToolsSuite) TestCopyNewestFromFilesystem(c *C) {
ctx, err := runSyncToolsCommand(c, "-e", "test-target", "--source", s.localStorage)
c.Assert(err, IsNil)
c.Assert(ctx, NotNil)
// Newest released v1 tools made available to target env.
targetTools, err := environs.FindAvailableTools(s.targetEnv, 1)
c.Assert(err, IsNil)
assertToolsList(c, targetTools, v100all)
// Public bucket was not touched.
assertEmpty(c, s.targetEnv.PublicStorage())
}
func (s *BootstrapSuite) TestAutoSyncLocalSource(c *gc.C) {
// Prepare a tools directory for testing and store the
// dummy tools in there.
source := createToolsSource(c)
// Change the version and ensure its later restoring.
origVersion := version.Current
version.Current.Number = version.MustParse("1.2.3")
defer func() {
version.Current = origVersion
}()
// Create home with dummy provider and remove all
// of its tools.
env, fake := makeEmptyFakeHome(c)
defer fake.Restore()
// Bootstrap the environment with an invalid source.
// The command returns with an error.
ctx := coretesting.Context(c)
code := cmd.Main(&BootstrapCommand{}, ctx, []string{"--source", c.MkDir()})
c.Check(code, gc.Equals, 1)
// Now check that there are no tools available.
_, err := environs.FindAvailableTools(env, version.Current.Major)
c.Assert(err, gc.ErrorMatches, "no tools available")
// Bootstrap the environment with the valid source. This time
// the bootstrapping has to show no error, because the tools
// are automatically synchronized.
ctx = coretesting.Context(c)
code = cmd.Main(&BootstrapCommand{}, ctx, []string{"--source", source})
c.Check(code, gc.Equals, 0)
// Now check the available tools which are the 1.0.0 tools.
checkTools(c, env, v100All)
}
func (test bootstrapTest) run(c *C) {
defer testing.MakeFakeHome(c, envConfig).Restore()
dummy.Reset()
env, err := environs.NewFromName("peckham")
c.Assert(err, IsNil)
envtesting.RemoveAllTools(c, env)
if test.version != "" {
origVersion := version.Current
version.Current = version.MustParseBinary(test.version)
defer func() { version.Current = origVersion }()
}
uploadCount := len(test.uploads)
if uploadCount == 0 {
usefulVersion := version.Current
usefulVersion.Series = env.Config().DefaultSeries()
envtesting.UploadFakeToolsVersion(c, env.Storage(), usefulVersion)
}
// Run command and check for uploads.
opc, errc := runCommand(new(BootstrapCommand), test.args...)
if uploadCount > 0 {
for i := 0; i < uploadCount; i++ {
c.Check((<-opc).(dummy.OpPutFile).Env, Equals, "peckham")
}
list, err := environs.FindAvailableTools(env, version.Current.Major)
c.Check(err, IsNil)
c.Logf("found: " + list.String())
urls := list.URLs()
c.Check(urls, HasLen, len(test.uploads))
for _, v := range test.uploads {
c.Logf("seeking: " + v)
vers := version.MustParseBinary(v)
_, found := urls[vers]
c.Check(found, Equals, true)
}
}
// Check for remaining operations/errors.
if test.err != "" {
c.Check(<-errc, ErrorMatches, test.err)
return
}
if !c.Check(<-errc, IsNil) {
return
}
opPutBootstrapVerifyFile := (<-opc).(dummy.OpPutFile)
c.Check(opPutBootstrapVerifyFile.Env, Equals, "peckham")
c.Check(opPutBootstrapVerifyFile.FileName, Equals, "bootstrap-verify")
opBootstrap := (<-opc).(dummy.OpBootstrap)
c.Check(opBootstrap.Env, Equals, "peckham")
c.Check(opBootstrap.Constraints, DeepEquals, test.constraints)
// Check a CA cert/key was generated by reloading the environment.
env, err = environs.NewFromName("peckham")
c.Assert(err, IsNil)
_, hasCert := env.Config().CACert()
c.Check(hasCert, Equals, true)
_, hasKey := env.Config().CAPrivateKey()
c.Check(hasKey, Equals, true)
}