func (s *toolsSuite) TestFindAvailableToolsCompleteNoValidate(c *gc.C) {
s.PatchValue(&arch.HostArch, func() string {
return "amd64"
})
s.PatchValue(&version.Current.Arch, "amd64")
var allTools tools.List
for _, series := range version.SupportedSeries() {
binary := version.Current
binary.Series = series
allTools = append(allTools, &tools.Tools{
Version: binary,
URL: "http://testing.invalid/tools.tar.gz",
})
}
s.PatchValue(bootstrap.FindTools, func(_ environs.ConfigGetter, major, minor int, f tools.Filter, retry bool) (tools.List, error) {
return allTools, nil
})
env := newEnviron("foo", useDefaultKeys, nil)
availableTools, err := bootstrap.FindAvailableTools(env, nil, false)
c.Assert(err, gc.IsNil)
c.Assert(availableTools, gc.HasLen, len(allTools))
c.Assert(env.supportedArchitecturesCount, gc.Equals, 0)
}
func (s *BootstrapSuite) testToolsMetadata(c *gc.C, exploded bool) {
provider, err := environs.Provider(s.envcfg.Type())
c.Assert(err, gc.IsNil)
env, err := provider.Open(s.envcfg)
c.Assert(err, gc.IsNil)
oldMetadata, err := envtools.ReadMetadata(env.Storage())
c.Assert(err, gc.IsNil)
_, cmd, err := s.initBootstrapCommand(c, nil, "--env-config", s.b64yamlEnvcfg, "--instance-id", string(s.instanceId))
c.Assert(err, gc.IsNil)
err = cmd.Run(nil)
c.Assert(err, gc.IsNil)
newMetadata, err := envtools.ReadMetadata(env.Storage())
c.Assert(err, gc.IsNil)
if !exploded {
c.Assert(newMetadata, gc.HasLen, len(oldMetadata))
} else {
// new metadata should have more tools.
c.Assert(len(newMetadata), jc.GreaterThan, len(oldMetadata))
var expectedSeries set.Strings
for _, series := range version.SupportedSeries() {
os, err := version.GetOSFromSeries(series)
c.Assert(err, gc.IsNil)
if os == version.Ubuntu {
expectedSeries.Add(series)
}
}
c.Assert(newMetadata, gc.HasLen, expectedSeries.Size())
for _, m := range newMetadata {
c.Assert(expectedSeries.Contains(m.Release), jc.IsTrue)
}
}
}
func NewImageConstraint(params simplestreams.LookupParams) *ImageConstraint {
if len(params.Series) == 0 {
params.Series = version.SupportedSeries()
}
if len(params.Arches) == 0 {
params.Arches = arch.AllSupportedArches
}
return &ImageConstraint{LookupParams: params}
}
func (s *supportedSeriesSuite) TestSupportedSeries(c *gc.C) {
d := c.MkDir()
filename := filepath.Join(d, "ubuntu.csv")
err := ioutil.WriteFile(filename, []byte(distInfoData), 0644)
c.Assert(err, jc.ErrorIsNil)
s.PatchValue(version.DistroInfo, filename)
expectedSeries := []string{"precise", "quantal", "raring", "saucy"}
series := version.SupportedSeries()
sort.Strings(series)
c.Assert(series, gc.DeepEquals, expectedSeries)
}
func (s *BootstrapSuite) testToolsMetadata(c *gc.C, exploded bool) {
provider, err := environs.Provider(s.envcfg.Type())
c.Assert(err, gc.IsNil)
env, err := provider.Open(s.envcfg)
c.Assert(err, gc.IsNil)
envtesting.RemoveFakeToolsMetadata(c, env.Storage())
_, cmd, err := s.initBootstrapCommand(c, nil, "--env-config", s.b64yamlEnvcfg, "--instance-id", string(s.instanceId))
c.Assert(err, gc.IsNil)
err = cmd.Run(nil)
c.Assert(err, gc.IsNil)
// We don't write metadata at bootstrap anymore.
simplestreamsMetadata, err := envtools.ReadMetadata(env.Storage())
c.Assert(err, gc.IsNil)
c.Assert(simplestreamsMetadata, gc.HasLen, 0)
// The tools should have been added to state, and
// exploded into each of the supported series of
// the same operating system if the tools were uploaded.
st, err := state.Open(&mongo.MongoInfo{
Info: mongo.Info{
Addrs: []string{gitjujutesting.MgoServer.Addr()},
CACert: testing.CACert,
},
Password: testPasswordHash(),
}, mongo.DefaultDialOpts(), environs.NewStatePolicy())
c.Assert(err, gc.IsNil)
defer st.Close()
var expectedSeries set.Strings
if exploded {
for _, series := range version.SupportedSeries() {
os, err := version.GetOSFromSeries(series)
c.Assert(err, gc.IsNil)
if os == version.Current.OS {
expectedSeries.Add(series)
}
}
} else {
expectedSeries.Add(version.Current.Series)
}
storage, err := st.ToolsStorage()
c.Assert(err, gc.IsNil)
defer storage.Close()
metadata, err := storage.AllMetadata()
c.Assert(err, gc.IsNil)
c.Assert(metadata, gc.HasLen, expectedSeries.Size())
for _, m := range metadata {
c.Assert(expectedSeries.Contains(m.Version.Series), jc.IsTrue)
}
}
// locallyBuildableTools returns the list of tools that
// can be built locally, for series of the same OS.
func locallyBuildableTools() (buildable coretools.List) {
for _, series := range version.SupportedSeries() {
if os, err := version.GetOSFromSeries(series); err != nil || os != version.Current.OS {
continue
}
binary := version.Current
binary.Series = series
// Increment the build number so we know it's a development build.
binary.Build++
buildable = append(buildable, &coretools.Tools{Version: binary})
}
return buildable
}
func (s *localServerSuite) TestStartInstanceHardwareCharacteristics(c *gc.C) {
// Ensure amd64 tools are available, to ensure an amd64 image.
amd64Version := version.Current
amd64Version.Arch = arch.AMD64
for _, series := range version.SupportedSeries() {
amd64Version.Series = series
envtesting.AssertUploadFakeToolsVersions(c, s.toolsMetadataStorage, amd64Version)
}
env := s.Prepare(c)
err := bootstrap.Bootstrap(coretesting.Context(c), env, bootstrap.BootstrapParams{})
c.Assert(err, gc.IsNil)
_, hc := testing.AssertStartInstanceWithConstraints(c, env, "100", constraints.MustParse("mem=1024"))
c.Check(*hc.Arch, gc.Equals, "amd64")
c.Check(*hc.Mem, gc.Equals, uint64(2048))
c.Check(*hc.CpuCores, gc.Equals, uint64(1))
c.Assert(hc.CpuPower, gc.IsNil)
}
func makeToolsConstraint(cloudSpec simplestreams.CloudSpec, majorVersion, minorVersion int,
filter coretools.Filter) (*ToolsConstraint, error) {
var toolsConstraint *ToolsConstraint
if filter.Number != version.Zero {
// A specific tools version is required, however, a general match based on major/minor
// version may also have been requested. This is used to ensure any agent version currently
// recorded in the environment matches the Juju cli version.
// We can short circuit any lookup here by checking the major/minor numbers against
// the filter version and exiting early if there is a mismatch.
majorMismatch := majorVersion > 0 && majorVersion != filter.Number.Major
minorMismacth := minorVersion != -1 && minorVersion != filter.Number.Minor
if majorMismatch || minorMismacth {
return nil, coretools.ErrNoMatches
}
toolsConstraint = NewVersionedToolsConstraint(filter.Number,
simplestreams.LookupParams{CloudSpec: cloudSpec})
} else {
toolsConstraint = NewGeneralToolsConstraint(majorVersion, minorVersion, filter.Released,
simplestreams.LookupParams{CloudSpec: cloudSpec})
}
if filter.Arch != "" {
toolsConstraint.Arches = []string{filter.Arch}
} else {
logger.Debugf("no architecture specified when finding tools, looking for any")
toolsConstraint.Arches = arch.AllSupportedArches
}
// The old tools search allowed finding tools without needing to specify a series.
// The simplestreams metadata is keyed off series, so series must be specified in
// the search constraint. If no series is specified, we gather all the series from
// lucid onwards and add those to the constraint.
var seriesToSearch []string
if filter.Series != "" {
seriesToSearch = []string{filter.Series}
} else {
logger.Debugf("no series specified when finding tools, looking for any")
seriesToSearch = version.SupportedSeries()
}
toolsConstraint.Series = seriesToSearch
return toolsConstraint, nil
}
func (s *supportedSeriesWindowsSuite) TestSupportedSeries(c *gc.C) {
expectedSeries := []string{
"centos7",
"precise",
"quantal",
"raring",
"saucy",
"trusty",
"utopic",
"vivid",
"win2012",
"win2012hv",
"win2012hvr2",
"win2012r2",
"win7",
"win8",
"win81",
}
series := version.SupportedSeries()
sort.Strings(series)
c.Assert(series, gc.DeepEquals, expectedSeries)
}
func (s *supportedSeriesSuite) TestSupportedSeries(c *gc.C) {
series := version.SupportedSeries()
sort.Strings(series)
c.Assert(series, gc.DeepEquals, []string{"precise", "quantal", "raring", "saucy", "trusty", "utopic"})
}
