Fix tools metadata generation for null provider

environs/tools/simplestreams.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 // The tools package supports locating, parsing, and filtering Ubuntu tools metadata in simplestreams format.
 // See http://launchpad.net/simplestreams and in particular the doc/README file in that project for more information
 // about the file formats.
 package tools
 
 import (
         "bytes"
@@ skipping 196 matching lines @@
                         FileType: "tar.gz",
                         Size:     t.Size,
                         SHA256:   t.SHA256,
                 }
         }
         return metadata
 }
 
 // ResolveMetadata resolves incomplete metadata
 // by fetching the tools from storage and computing
-// the metadata locally.
+// the size and hash locally.
 func ResolveMetadata(stor storage.StorageReader, metadata []*ToolsMetadata) error {
         for _, md := range metadata {
-                if md.Size == 0 {
-                        binary := md.binary()
-                        logger.Infof("Fetching tools to generate hash: %v", binary)
-                        var sha256hash hash.Hash
-                        size, sha256hash, err := fetchToolsHash(stor, binary)
-                        if err != nil {
-                                return err
-                        }
-                        md.Size = size
-                        md.SHA256 = fmt.Sprintf("%x", sha256hash.Sum(nil))
-                }
+                if md.Size != 0 {
+                        continue
+                }
+                binary := md.binary()
+                logger.Infof("Fetching tools to generate hash: %v", binary)
+                var sha256hash hash.Hash
+                size, sha256hash, err := fetchToolsHash(stor, binary)
+                if err != nil {
+                        return err
+                }
+                md.Size = size
+                md.SHA256 = fmt.Sprintf("%x", sha256hash.Sum(nil))
         }
         return nil
 }
 
 // MergeMetadata merges the given tools metadata.
 // If metadata for the same tools version exists in both lists,
-// an entry with non-empty size/SHA256 takes precedence. If
-// both entries have information, prefer the entry from
-// "newMetadata".
-func MergeMetadata(newMetadata, oldMetadata []*ToolsMetadata) []*ToolsMetadata {
+// an entry with non-empty size/SHA256 takes precedence; if
+// the two entries have different sizes/hashes, then an error is
+// returned.
+func MergeMetadata(tmlist1, tmlist2 []*ToolsMetadata) ([]*ToolsMetadata, error) {
         merged := make(map[version.Binary]*ToolsMetadata)
-        for _, tm := range newMetadata {
+        for _, tm := range tmlist1 {
                 merged[tm.binary()] = tm
         }
-        for _, tm := range oldMetadata {
+        for _, tm := range tmlist2 {
                 binary := tm.binary()
-                if existing, ok := merged[binary]; !ok || existing.Size == 0 {
+                if existing, ok := merged[binary]; ok {
+                        if tm.Size != 0 {
+                                if existing.Size == 0 {
+                                        merged[binary] = tm
+                                } else if existing.Size != tm.Size || existing.SHA256 != tm.SHA256 {
+                                        return nil, fmt.Errorf(
+                                                "metadata mismatch for %s: sizes=(%v,%v) sha256=(%v,%v)",
+                                                binary.String(),
+                                                existing.Size, tm.Size,
+                                                existing.SHA256, tm.SHA256,
+                                        )
+                                }
+                        }
+                } else {
                         merged[binary] = tm
                 }
         }
         list := make([]*ToolsMetadata, 0, len(merged))
         for _, metadata := range merged {
                 list = append(list, metadata)
         }
-        return list
+        return list, nil
 }
 
 // ReadMetadata returns the tools metadata from the given storage.
 func ReadMetadata(store storage.StorageReader) ([]*ToolsMetadata, error) {
         dataSource := storage.NewStorageSimpleStreamsDataSource(store, "tools")
         toolsConstraint, err := makeToolsConstraint(simplestreams.CloudSpec{}, -1, -1, coretools.Filter{})
         if err != nil {
                 return nil, err
         }
         metadata, err := Fetch([]simplestreams.DataSource{dataSource}, simplestreams.DefaultIndexPath, toolsConstraint, false)
@@ skipping 16 matching lines @@
         for _, md := range metadataInfo {
                 logger.Infof("Writing %s", "tools/"+md.Path)
                 err = stor.Put("tools/"+md.Path, bytes.NewReader(md.Data), int64(len(md.Data)))
                 if err != nil {
                         return err
                 }
         }
         return nil
 }
 
-type ResolveFlag bool
-
-const (
-        DontResolve ResolveFlag = false
-        Resolve     ResolveFlag = true
-)
-
 // MergeAndWriteMetadata reads the existing metadata from storage (if any),
-// and merges it with metadata generated from the given tools list.
-// If resolve is true, incomplete metadata is resolved by fetching the tools
-// from the target storage. Finally, the resulting metadata is written to
-// storage.
-func MergeAndWriteMetadata(stor storage.Storage, targetTools coretools.List, resolve ResolveFlag) error {
+// and merges it with metadata generated from the given tools list. The
+// resulting metadata is written to storage.
+func MergeAndWriteMetadata(stor storage.Storage, tools coretools.List) error {
         existing, err := ReadMetadata(stor)
         if err != nil {
                 return err
         }
-        metadata := MetadataFromTools(targetTools)
-        metadata = MergeMetadata(metadata, existing)
-        if resolve {
-                if err = ResolveMetadata(stor, metadata); err != nil {
-                        return err
-                }
+        metadata := MetadataFromTools(tools)
+        if metadata, err = MergeMetadata(metadata, existing); err != nil {
+                return err
         }
         return WriteMetadata(stor, metadata)
 }
 
 // fetchToolsHash fetches the tools from storage and calculates
 // its size in bytes and computes a SHA256 hash of its contents.
 func fetchToolsHash(stor storage.StorageReader, ver version.Binary) (size int64, sha256hash hash.Hash, err error) {
         r, err := storage.Get(stor, StorageName(ver))
         if err != nil {
                 return 0, nil, err
         }
         defer r.Close()
         sha256hash = sha256.New()
         size, err = io.Copy(sha256hash, r)
         return size, sha256hash, err
 }