func (s *SimpleStreamsToolsSuite) TestFindToolsFiltering(c *gc.C) {
tw := &loggo.TestWriter{}
c.Assert(loggo.RegisterWriter("filter-tester", tw, loggo.DEBUG), gc.IsNil)
defer loggo.RemoveWriter("filter-tester")
_, err := envtools.FindTools(
s.env, 1, -1, coretools.Filter{Number: version.Number{Major: 1, Minor: 2, Patch: 3}}, envtools.DoNotAllowRetry)
c.Assert(err, jc.Satisfies, errors.IsNotFound)
// This is slightly overly prescriptive, but feel free to change or add
// messages. This still helps to ensure that all log messages are
// properly formed.
messages := []jc.SimpleMessage{
{loggo.INFO, "reading tools with major version 1"},
{loggo.INFO, "filtering tools by version: \\d+\\.\\d+\\.\\d+"},
{loggo.DEBUG, "no architecture specified when finding tools, looking for any"},
{loggo.DEBUG, "no series specified when finding tools, looking for any"},
}
sources, err := envtools.GetMetadataSources(s.env)
c.Assert(err, gc.IsNil)
for i := 0; i < 2*len(sources); i++ {
messages = append(messages,
jc.SimpleMessage{loggo.DEBUG, `fetchData failed for .*`},
jc.SimpleMessage{loggo.DEBUG, `cannot load index .*`})
}
c.Check(tw.Log, jc.LogMatches, messages)
}
func (s *syncSuite) TestSyncing(c *gc.C) {
for i, test := range tests {
// Perform all tests in a "clean" environment.
func() {
s.setUpTest(c)
defer s.tearDownTest(c)
c.Logf("test %d: %s", i, test.description)
if test.source {
test.ctx.Source = s.localStorage
}
if test.version != version.Zero {
version.Current.Number = test.version
}
if test.major > 0 {
test.ctx.MajorVersion = test.major
test.ctx.MinorVersion = test.minor
}
test.ctx.Target = s.targetEnv.Storage()
err := sync.SyncTools(test.ctx)
c.Assert(err, gc.IsNil)
targetTools, err := envtools.FindTools(
s.targetEnv, test.ctx.MajorVersion, test.ctx.MinorVersion, coretools.Filter{}, envtools.DoNotAllowRetry)
c.Assert(err, gc.IsNil)
assertToolsList(c, targetTools, test.tools)
assertNoUnexpectedTools(c, s.targetEnv.Storage())
assertMirrors(c, s.targetEnv.Storage(), test.expectMirrors)
}()
}
}
func (s *SimpleStreamsToolsSuite) TestFindTools(c *gc.C) {
for i, test := range findToolsTests {
c.Logf("\ntest %d: %s", i, test.info)
s.reset(c, nil)
custom := s.uploadCustom(c, test.custom...)
public := s.uploadPublic(c, test.public...)
actual, err := envtools.FindTools(s.env, test.major, test.minor, coretools.Filter{}, envtools.DoNotAllowRetry)
if test.err != nil {
if len(actual) > 0 {
c.Logf(actual.String())
}
c.Check(err, jc.Satisfies, errors.IsNotFound)
continue
}
expect := map[version.Binary]string{}
for _, expected := range test.expect {
// If the tools exist in custom, that's preferred.
var ok bool
if expect[expected], ok = custom[expected]; !ok {
expect[expected] = public[expected]
}
}
c.Check(actual.URLs(), gc.DeepEquals, expect)
}
}
func (s *BootstrapSuite) TestAutoUploadAfterFailedSync(c *gc.C) {
s.PatchValue(&version.Current.Series, config.LatestLtsSeries())
otherSeries := "quantal"
env := s.setupAutoUploadTest(c, "1.7.3", otherSeries)
// Run command and check for that upload has been run for tools matching the current juju version.
opc, errc := runCommand(nullContext(c), new(BootstrapCommand))
c.Assert(<-errc, gc.IsNil)
c.Assert((<-opc).(dummy.OpPutFile).Env, gc.Equals, "peckham")
list, err := envtools.FindTools(env, version.Current.Major, version.Current.Minor, coretools.Filter{}, false)
c.Assert(err, gc.IsNil)
c.Logf("found: " + list.String())
urls := list.URLs()
// We expect:
// supported LTS series precise, trusty,
// the specified series (quantal),
// and the environment's default series (raring).
expectedVers := []version.Binary{
version.MustParseBinary(fmt.Sprintf("1.7.3.1-%s-%s", "quantal", version.Current.Arch)),
version.MustParseBinary(fmt.Sprintf("1.7.3.1-%s-%s", "raring", version.Current.Arch)),
version.MustParseBinary(fmt.Sprintf("1.7.3.1-%s-%s", "precise", version.Current.Arch)),
version.MustParseBinary(fmt.Sprintf("1.7.3.1-%s-%s", "trusty", version.Current.Arch)),
}
c.Assert(urls, gc.HasLen, len(expectedVers))
for _, vers := range expectedVers {
c.Logf("seeking: " + vers.String())
_, found := urls[vers]
c.Check(found, gc.Equals, true)
}
}
// checkTools check if the environment contains the passed envtools.
func checkTools(c *gc.C, env environs.Environ, expected []version.Binary) {
list, err := envtools.FindTools(
env, version.Current.Major, version.Current.Minor, coretools.Filter{}, envtools.DoNotAllowRetry)
c.Check(err, gc.IsNil)
c.Logf("found: " + list.String())
urls := list.URLs()
c.Check(urls, gc.HasLen, len(expected))
}
// findTools1dot17 allows 1.17.x versions to be upgraded.
func findTools1dot17(cfg *config.Config) (coretools.List, error) {
logger.Warningf("running find tools in 1.17 compatibility mode")
env, err := environs.New(cfg)
if err != nil {
return nil, err
}
clientVersion := version.Current.Number
return envtools.FindTools(env, clientVersion.Major, -1, coretools.Filter{}, envtools.DoNotAllowRetry)
}
func (s *SimpleStreamsToolsSuite) TestFindToolsInControlBucket(c *gc.C) {
s.reset(c, nil)
custom := ttesting.UploadToStorage(c, s.env.Storage(), envtesting.V110p...)
s.uploadPublic(c, envtesting.VAll...)
actual, err := envtools.FindTools(s.env, 1, 1, coretools.Filter{}, envtools.DoNotAllowRetry)
c.Assert(err, gc.IsNil)
expect := map[version.Binary]string{}
for _, expected := range envtesting.V110p {
expect[expected] = custom[expected]
}
c.Assert(actual.URLs(), gc.DeepEquals, expect)
}
func (s *BootstrapSuite) TestInvalidLocalSource(c *gc.C) {
s.PatchValue(&version.Current.Number, version.MustParse("1.2.0"))
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{"--metadata-source", c.MkDir()})
c.Check(code, gc.Equals, 1)
// Now check that there are no tools available.
_, err := envtools.FindTools(
env, version.Current.Major, version.Current.Minor, coretools.Filter{}, envtools.DoNotAllowRetry)
c.Assert(err, gc.FitsTypeOf, errors.NotFoundf(""))
}
// FindTools returns a List containing all tools matching the given parameters.
func (c *Client) FindTools(args params.FindToolsParams) (params.FindToolsResults, error) {
result := params.FindToolsResults{}
// Get the existing environment config from the state.
envConfig, err := c.api.state.EnvironConfig()
if err != nil {
return result, err
}
env, err := environs.New(envConfig)
if err != nil {
return result, err
}
filter := coretools.Filter{
Arch: args.Arch,
Series: args.Series,
}
result.List, err = envtools.FindTools(env, args.MajorVersion, args.MinorVersion, filter, envtools.DoNotAllowRetry)
result.Error = common.ServerError(err)
return result, nil
}
func (test bootstrapTest) run(c *gc.C) {
// Create home with dummy provider and remove all
// of its envtools.
env, fake := makeEmptyFakeHome(c)
defer fake.Restore()
if test.version != "" {
useVersion := strings.Replace(test.version, "%LTS%", config.LatestLtsSeries(), 1)
origVersion := version.Current
version.Current = version.MustParseBinary(useVersion)
defer func() { version.Current = origVersion }()
}
if test.hostArch != "" {
origVersion := arch.HostArch
arch.HostArch = func() string {
return test.hostArch
}
defer func() { arch.HostArch = origVersion }()
}
uploadCount := len(test.uploads)
if uploadCount == 0 {
usefulVersion := version.Current
usefulVersion.Series = config.PreferredSeries(env.Config())
envtesting.AssertUploadFakeToolsVersions(c, env.Storage(), usefulVersion)
}
// Run command and check for uploads.
opc, errc := runCommand(nullContext(c), new(BootstrapCommand), test.args...)
// Check for remaining operations/errors.
if test.err != "" {
err := <-errc
stripped := strings.Replace(err.Error(), "\n", "", -1)
c.Check(stripped, gc.Matches, test.err)
return
}
if !c.Check(<-errc, gc.IsNil) {
return
}
if uploadCount > 0 {
for i := 0; i < uploadCount; i++ {
c.Check((<-opc).(dummy.OpPutFile).Env, gc.Equals, "peckham")
}
list, err := envtools.FindTools(
env, version.Current.Major, version.Current.Minor, coretools.Filter{}, envtools.DoNotAllowRetry)
c.Check(err, gc.IsNil)
c.Logf("found: " + list.String())
urls := list.URLs()
c.Check(urls, gc.HasLen, len(test.uploads))
for _, v := range test.uploads {
v := strings.Replace(v, "%LTS%", config.LatestLtsSeries(), 1)
c.Logf("seeking: " + v)
vers := version.MustParseBinary(v)
_, found := urls[vers]
c.Check(found, gc.Equals, true)
}
}
if len(test.uploads) > 0 {
indexFile := (<-opc).(dummy.OpPutFile)
c.Check(indexFile.FileName, gc.Equals, "tools/streams/v1/index.json")
productFile := (<-opc).(dummy.OpPutFile)
c.Check(productFile.FileName, gc.Equals, "tools/streams/v1/com.ubuntu.juju:released:tools.json")
}
opPutBootstrapVerifyFile := (<-opc).(dummy.OpPutFile)
c.Check(opPutBootstrapVerifyFile.Env, gc.Equals, "peckham")
c.Check(opPutBootstrapVerifyFile.FileName, gc.Equals, environs.VerificationFilename)
opPutBootstrapInitFile := (<-opc).(dummy.OpPutFile)
c.Check(opPutBootstrapInitFile.Env, gc.Equals, "peckham")
c.Check(opPutBootstrapInitFile.FileName, gc.Equals, "provider-state")
opBootstrap := (<-opc).(dummy.OpBootstrap)
c.Check(opBootstrap.Env, gc.Equals, "peckham")
c.Check(opBootstrap.Args.Constraints, gc.DeepEquals, test.constraints)
c.Check(opBootstrap.Args.Placement, gc.Equals, test.placement)
store, err := configstore.Default()
c.Assert(err, gc.IsNil)
// Check a CA cert/key was generated by reloading the environment.
env, err = environs.NewFromName("peckham", store)
c.Assert(err, gc.IsNil)
_, hasCert := env.Config().CACert()
c.Check(hasCert, gc.Equals, true)
_, hasKey := env.Config().CAPrivateKey()
c.Check(hasKey, gc.Equals, true)
}
