func (t *ToolsMetadata) productId() (string, error) {
seriesVersion, err := series.SeriesVersion(t.Release)
if err != nil {
return "", err
}
return fmt.Sprintf("com.ubuntu.juju:%s:%s", seriesVersion, t.Arch), nil
}
func (s *supportedSeriesWindowsSuite) TestSeriesVersion(c *gc.C) {
vers, err := series.SeriesVersion("win8")
if err != nil {
c.Assert(err, gc.Not(gc.ErrorMatches), `invalid series "win8"`, gc.Commentf(`unable to lookup series "win8"`))
} else {
c.Assert(err, jc.ErrorIsNil)
}
c.Assert(err, jc.ErrorIsNil)
c.Assert(vers, gc.Equals, "win8")
}
func (tc *testConstraint) ProductIds() ([]string, error) {
version, err := series.SeriesVersion(tc.Series[0])
if err != nil {
return nil, err
}
ids := make([]string, len(tc.Arches))
for i, arch := range tc.Arches {
ids[i] = fmt.Sprintf("com.ubuntu.cloud:server:%s:%s", version, arch)
}
return ids, nil
}
func (s *supportedSeriesSuite) TestSeriesVersion(c *gc.C) {
// There is no distro-info on Windows or CentOS.
if os.HostOS() != os.Ubuntu {
c.Skip("This test is only relevant on Ubuntu.")
}
vers, err := series.SeriesVersion("precise")
if err != nil && err.Error() == `invalid series "precise"` {
c.Fatalf(`Unable to lookup series "precise", you may need to: apt-get install distro-info`)
}
c.Assert(err, jc.ErrorIsNil)
c.Assert(vers, gc.Equals, "12.04")
}
// cloneToolsForSeries copies the built tools tarball into a tarball for the specified
// stream and series and generates corresponding metadata.
func cloneToolsForSeries(toolsInfo *BuiltTools, stream string, series ...string) error {
// Copy the tools to the target storage, recording a Tools struct for each one.
var targetTools coretools.List
targetTools = append(targetTools, &coretools.Tools{
Version: toolsInfo.Version,
Size: toolsInfo.Size,
SHA256: toolsInfo.Sha256Hash,
})
putTools := func(vers version.Binary) (string, error) {
name := envtools.StorageName(vers, stream)
src := filepath.Join(toolsInfo.Dir, toolsInfo.StorageName)
dest := filepath.Join(toolsInfo.Dir, name)
destDir := filepath.Dir(dest)
if err := os.MkdirAll(destDir, 0755); err != nil {
return "", err
}
if err := utils.CopyFile(dest, src); err != nil {
return "", err
}
// Append to targetTools the attributes required to write out tools metadata.
targetTools = append(targetTools, &coretools.Tools{
Version: vers,
Size: toolsInfo.Size,
SHA256: toolsInfo.Sha256Hash,
})
return name, nil
}
logger.Debugf("generating tarballs for %v", series)
for _, series := range series {
_, err := jujuseries.SeriesVersion(series)
if err != nil {
return err
}
if series != toolsInfo.Version.Series {
fakeVersion := toolsInfo.Version
fakeVersion.Series = series
if _, err := putTools(fakeVersion); err != nil {
return err
}
}
}
// The tools have been copied to a temp location from which they will be uploaded,
// now write out the matching simplestreams metadata so that SyncTools can find them.
metadataStore, err := filestorage.NewFileStorageWriter(toolsInfo.Dir)
if err != nil {
return err
}
logger.Debugf("generating tools metadata")
return envtools.MergeAndWriteMetadata(metadataStore, stream, stream, targetTools, false)
}
// MergeAndWriteMetadata reads the existing metadata from storage (if any),
// and merges it with supplied metadata, writing the resulting metadata is written to storage.
func MergeAndWriteMetadata(ser string, metadata []*ImageMetadata, cloudSpec *simplestreams.CloudSpec,
metadataStore storage.Storage) error {
existingMetadata, err := readMetadata(metadataStore)
if err != nil {
return err
}
seriesVersion, err := series.SeriesVersion(ser)
if err != nil {
return err
}
toWrite, allCloudSpec := mergeMetadata(seriesVersion, cloudSpec, metadata, existingMetadata)
return writeMetadata(toWrite, allCloudSpec, metadataStore)
}
// ProductIds generates a string array representing product ids formed similarly to an ISCSI qualified name (IQN).
func (tc *ToolsConstraint) ProductIds() ([]string, error) {
var allIds []string
for _, ser := range tc.Series {
version, err := series.SeriesVersion(ser)
if err != nil {
return nil, err
}
ids := make([]string, len(tc.Arches))
for i, arch := range tc.Arches {
ids[i] = fmt.Sprintf("com.ubuntu.juju:%s:%s", version, arch)
}
allIds = append(allIds, ids...)
}
return allIds, nil
}
// ProductIds generates a string array representing product ids formed similarly to an ISCSI qualified name (IQN).
func (ic *ImageConstraint) ProductIds() ([]string, error) {
stream := idStream(ic.Stream)
nrArches := len(ic.Arches)
nrSeries := len(ic.Series)
ids := make([]string, nrArches*nrSeries)
for i, arch := range ic.Arches {
for j, ser := range ic.Series {
version, err := series.SeriesVersion(ser)
if err != nil {
return nil, err
}
ids[j*nrArches+i] = fmt.Sprintf("com.ubuntu.cloud%s:server:%s:%s", stream, version, arch)
}
}
return ids, nil
}
func (s *providerSuite) makeTestMetadata(c *gc.C, ser, location string, im []*imagemetadata.ImageMetadata) {
cloudSpec := simplestreams.CloudSpec{
Region: location,
Endpoint: "https://management.core.windows.net/",
}
seriesVersion, err := series.SeriesVersion(ser)
c.Assert(err, jc.ErrorIsNil)
for _, im := range im {
im.Version = seriesVersion
im.RegionName = cloudSpec.Region
im.Endpoint = cloudSpec.Endpoint
}
index, products, err := imagemetadata.MarshalImageMetadataJSON(
im, []simplestreams.CloudSpec{cloudSpec}, time.Now(),
)
c.Assert(err, jc.ErrorIsNil)
files := map[string]string{
"/streams/v1/index.json": string(index),
"/" + imagemetadata.ProductMetadataPath: string(products),
}
s.PatchValue(&testRoundTripper.Sub, jujutest.NewCannedRoundTripper(files, nil))
}