~sidnei/juju-core/lxc-clone-with-overlayfs

        "bytes"

        "fmt"

        "strings"

        "launchpad.net/juju-core/environs/configstore"

        "launchpad.net/juju-core/environs/storage"

        envtools "launchpad.net/juju-core/environs/tools"

        "launchpad.net/juju-core/errors"

        "launchpad.net/juju-core/provider/dummy"

        "launchpad.net/juju-core/testing/testbase"

        coretools "launchpad.net/juju-core/tools"

        testbase.LoggingSuite

        envtesting.ToolsFixture

        s.ToolsFixture.SetUpTest(c)

        s.ToolsFixture.TearDownTest(c)

type bootstrapRetryTest struct {

        info               string

        args               []string

        expectedAllowRetry []bool

        err                string

        // If version != "", version.Current will be

        // set to it for the duration of the test.

        version string

        // If addVersionToSource is true, then "version"

        // above will be populated in the tools source.

        addVersionToSource bool

}

 

var bootstrapRetryTests = []bootstrapRetryTest{{

        info:               "no tools uploaded, first check has no retries; no matching binary in source; sync fails with no second attempt",

        expectedAllowRetry: []bool{false},

        err:                "no matching tools available",

        version:            "1.16.0-precise-amd64",

}, {

        info:               "no tools uploaded, first check has no retries; matching binary in source; check after sync has retries",

        expectedAllowRetry: []bool{false, true},

        err:                "tools not found",

        version:            "1.16.0-precise-amd64",

        addVersionToSource: true,

}, {

        info:               "no tools uploaded, first check has no retries; no matching binary in source; check after upload has retries",

        expectedAllowRetry: []bool{false, true},

        err:                "tools not found",

        version:            "1.15.1-precise-amd64", // dev version to force upload

}, {

        info:               "new tools uploaded, so we want to allow retries to give them a chance at showing up",

        args:               []string{"--upload-tools"},

        expectedAllowRetry: []bool{true},

        err:                "no matching tools available",

}}

 

// Test test checks that bootstrap calls FindTools with the expected allowRetry flag.

func (s *BootstrapSuite) TestAllowRetries(c *gc.C) {

        for i, test := range bootstrapRetryTests {

                c.Logf("test %d: %s\n", i, test.info)

                s.runAllowRetriesTest(c, test)

        }

}

 

func (s *BootstrapSuite) runAllowRetriesTest(c *gc.C, test bootstrapRetryTest) {

        var extraVersions []version.Binary

        if test.version != "" {

                testVersion := version.MustParseBinary(test.version)

                restore := testbase.PatchValue(&version.Current, testVersion)

                defer restore()

                if test.addVersionToSource {

                        extraVersions = append(extraVersions, testVersion)

                }

        }

        _, fake := makeEmptyFakeHome(c)

        defer fake.Restore()

        defer createToolsStore(c, extraVersions...)()

 

        var findToolsRetryValues []bool

        mockFindTools := func(cloudInst environs.ConfigGetter, majorVersion, minorVersion int,

                filter coretools.Filter, allowRetry bool) (list coretools.List, err error) {

                findToolsRetryValues = append(findToolsRetryValues, allowRetry)

                return nil, errors.NotFoundf("tools")

        }

 

        restore := envtools.TestingPatchBootstrapFindTools(mockFindTools)

        defer restore()

 

        _, errc := runCommand(nullContext(), new(BootstrapCommand), test.args...)

        err := <-errc

        c.Check(findToolsRetryValues, gc.DeepEquals, test.expectedAllowRetry)

        c.Assert(err, gc.ErrorMatches, test.err)

}

 

        defer func() { uploadTools = sync.Upload }()

        // of its envtools.

                envtesting.AssertUploadFakeToolsVersions(c, env.Storage(), usefulVersion)

        opc, errc := runCommand(nullContext(), new(BootstrapCommand), test.args...)

                list, err := envtools.FindTools(

                        env, version.Current.Major, version.Current.Minor, coretools.Filter{}, envtools.DoNotAllowRetry)

        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")

        }

        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")

        store, err := configstore.Default()

        c.Assert(err, gc.IsNil)

        env, err = environs.NewFromName("peckham", store)

        info:    "bad environment",

        version: "1.2.3-precise-amd64",

        args:    []string{"-e", "brokenenv"},

        err:     `dummy.Bootstrap is broken`,

        version: "1.2.3-saucy-amd64",

                "1.2.3.1-saucy-amd64",   // from version.Current

                "1.2.3.1-raring-amd64",  // from env.Config().DefaultSeries()

                "1.2.3.1-precise-amd64", // from environs/config.DefaultSeries

        version: "1.2.3-precise-amd64",

                "1.2.3.1-raring-amd64",

                "1.2.3.1-precise-amd64",

        info:    "--upload-tools rejects invalid series",

        version: "1.2.3-saucy-amd64",

        err:     `invalid series "ping"`,

        version: "1.2.3.4-raring-amd64",

                "1.2.3.5-raring-amd64",

                "1.2.3.5-precise-amd64",

func (s *BootstrapSuite) TestBootstrapTwice(c *gc.C) {

        env, fake := makeEmptyFakeHome(c)

        defer fake.Restore()

        defaultSeriesVersion := version.Current

        defaultSeriesVersion.Series = env.Config().DefaultSeries()

        restore := createToolsStore(c, defaultSeriesVersion)

        defer restore()

 

        ctx := coretesting.Context(c)

        code := cmd.Main(&BootstrapCommand{}, ctx, nil)

        c.Check(code, gc.Equals, 0)

 

        ctx2 := coretesting.Context(c)

        code2 := cmd.Main(&BootstrapCommand{}, ctx2, nil)

        c.Check(code2, gc.Equals, 1)

        c.Check(coretesting.Stderr(ctx2), gc.Equals, "error: environment is already bootstrapped\n")

        c.Check(coretesting.Stdout(ctx2), gc.Equals, "")

}

 

        version.Current.Number = version.MustParse("1.2.0")

        // of its envtools.

        // Now check the available tools which are the 1.2.0 envtools.

        checkTools(c, env, v120All)

        version.Current.Number = version.MustParse("1.2.0")

        // of its envtools.

        _, err := envtools.FindTools(

                env, version.Current.Major, version.Current.Minor, coretools.Filter{}, envtools.DoNotAllowRetry)

        c.Assert(err, gc.FitsTypeOf, errors.NotFoundf(""))

        // Now check the available tools which are the 1.2.0 envtools.

        checkTools(c, env, v120All)

}

 

func (s *BootstrapSuite) setupAutoUploadTest(c *gc.C, vers, series string) environs.Environ {

        uploadTools = mockUploadTools

        s.AddCleanup(func(*gc.C) { uploadTools = sync.Upload })

 

        // Prepare a mock storage for testing and store the

        // dummy tools in there.

        restore := createToolsStore(c)

        s.AddCleanup(func(*gc.C) { restore() })

 

        // Change the tools location to be the test location and also

        // the version and ensure their later restoring.

        // Set the current version to be something for which there are no tools

        // so we can test that an upload is forced.

        origVersion := version.Current

        version.Current.Number = version.MustParse(vers)

        version.Current.Series = series

        s.AddCleanup(func(*gc.C) { version.Current = origVersion })

 

        // Create home with dummy provider and remove all

        // of its envtools.

        env, fake := makeEmptyFakeHome(c)

        s.AddCleanup(func(*gc.C) { fake.Restore() })

        return env

}

 

func (s *BootstrapSuite) TestAutoUploadAfterFailedSync(c *gc.C) {

        otherSeries := "precise"

        if otherSeries == version.Current.Series {

                otherSeries = "raring"

        }

        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(), 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()

        c.Assert(urls, gc.HasLen, 2)

        expectedVers := []version.Binary{

                version.MustParseBinary(fmt.Sprintf("1.7.3.1-%s-%s", otherSeries, version.Current.Arch)),

                version.MustParseBinary(fmt.Sprintf("1.7.3.1-%s-%s", version.Current.Series, version.Current.Arch)),

        }

        for _, vers := range expectedVers {

                c.Logf("seeking: " + vers.String())

                _, found := urls[vers]

                c.Check(found, gc.Equals, true)

        }

}

 

func (s *BootstrapSuite) TestAutoUploadOnlyForDev(c *gc.C) {

        s.setupAutoUploadTest(c, "1.8.3", "precise")

        _, errc := runCommand(nullContext(), new(BootstrapCommand))

        err := <-errc

        c.Assert(err, gc.ErrorMatches, "no matching tools available")

}

 

func (s *BootstrapSuite) TestMissingToolsError(c *gc.C) {

        s.setupAutoUploadTest(c, "1.8.3", "precise")

        context := coretesting.Context(c)

        code := cmd.Main(&BootstrapCommand{}, context, nil)

        c.Assert(code, gc.Equals, 1)

        errText := context.Stderr.(*bytes.Buffer).String()

        errText = strings.Replace(errText, "\n", "", -1)

        expectedErrText := strings.Replace(fmt.Sprintf(".*%s.*", NoToolsNoUploadMessage), "\n", "", -1)

        c.Assert(errText, gc.Matches, expectedErrText)

}

 

func uploadToolsAlwaysFails(stor storage.Storage, forceVersion *version.Number, series ...string) (*coretools.Tools, error) {

        return nil, fmt.Errorf("an error")

}

 

func (s *BootstrapSuite) TestMissingToolsUploadFailedError(c *gc.C) {

        s.setupAutoUploadTest(c, "1.7.3", "precise")

        uploadTools = uploadToolsAlwaysFails

        context := coretesting.Context(c)

        code := cmd.Main(&BootstrapCommand{}, context, nil)

        c.Assert(code, gc.Equals, 1)

        errText := context.Stderr.(*bytes.Buffer).String()

        errText = strings.Replace(errText, "\n", "", -1)

        expectedErrText := strings.Replace(fmt.Sprintf(".*%s.*", NoToolsMessage), "\n", "", -1)

        c.Assert(errText, gc.Matches, expectedErrText)

func createToolsStore(c *gc.C, additionalBinaries ...version.Binary) func() {

        stor, err := envtesting.NewEC2HTTPTestStorage("127.0.0.1")

        sync.DefaultToolsLocation = stor.Location()

                stor.PutBinary(vers)

        }

        for _, vers := range additionalBinaries {

                stor.PutBinary(vers)

// directory and returns it.

                name := envtools.StorageName(vers)

// makeEmptyFakeHome creates a faked home without envtools.

        store, err := configstore.Default()

        c.Assert(err, gc.IsNil)

        env, err := environs.PrepareFromName("peckham", store)

// 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(urls, gc.HasLen, len(expected))

        v100d64 = version.MustParseBinary("1.0.0-raring-amd64")

        v120d64 = version.MustParseBinary("1.2.0-raring-amd64")

        v120p64 = version.MustParseBinary("1.2.0-precise-amd64")

        v120q32 = version.MustParseBinary("1.2.0-quantal-i386")

        v120q64 = version.MustParseBinary("1.2.0-quantal-amd64")

        v120All = []version.Binary{

                v120d64, v120p64, v120q64, v120q32,

        }

                v120d64, v120p64, v120q32, v120q64,