Some of the DownloadResource functions are now class methods

Slightly refactored also the way those methods are used.

Author: cmaglie

common/releases/checksums.go

@@ -35,7 +35,6 @@ import (
 	"crypto/sha256"
 	"encoding/hex"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"hash"
 	"io"
@@ -45,65 +44,93 @@ import (
 	"strings"
 )
 
-func getHashAlgoAndComponent(checksum string) (hash.Hash, []byte) {
-	components := strings.SplitN(checksum, ":", 2)
-	hashAlgo := components[0]
-	hashMid, err := hex.DecodeString(components[1])
+// IsCached returns a bool representing if the release has already been downloaded
+func (r *DownloadResource) IsCached() (bool, error) {
+	archivePath, err := r.ArchivePath()
 	if err != nil {
-		return nil, nil
+		return false, fmt.Errorf("getting archive path: %s", err)
 	}
 
-	hash := []byte(hashMid)
-	switch hashAlgo {
+	_, err = os.Stat(archivePath)
+	if err != nil && !os.IsNotExist(err) {
+		return false, fmt.Errorf("checking archive existence: %s", err)
+	}
+
+	return !os.IsNotExist(err), nil
+}
+
+// TestLocalArchiveChecksum test if the checksum of the local archive match the checksum of the DownloadResource
+func (r *DownloadResource) TestLocalArchiveChecksum() (bool, error) {
+	split := strings.SplitN(r.Checksum, ":", 2)
+	if len(split) != 2 {
+		return false, fmt.Errorf("invalid checksum format: %s", r.Checksum)
+	}
+	digest, err := hex.DecodeString(split[1])
+	if err != nil {
+		return false, fmt.Errorf("invalid hash '%s': %s", split[1], err)
+	}
+
+	// names based on: https://docs.oracle.com/javase/8/docs/technotes/guides/security/StandardNames.html#MessageDigest
+	var algo hash.Hash
+	switch split[0] {
 	case "SHA-256":
-		return crypto.SHA256.New(), hash
-	case "SHA1":
-		return crypto.SHA1.New(), hash
+		algo = crypto.SHA256.New()
+	case "SHA-1":
+		algo = crypto.SHA1.New()
 	case "MD5":
-		return crypto.MD5.New(), hash
+		algo = crypto.MD5.New()
 	default:
-		return nil, nil
+		return false, fmt.Errorf("unsupported hash algorithm: %s", split[0])
 	}
-}
 
-// ChecksumMatches checks the checksum of a DownloadResource archive, in compliance with
-// What Checksum is expected.
-func checksumMatches(r *DownloadResource) bool {
-	hash, content := getHashAlgoAndComponent(r.Checksum)
 	filePath, err := r.ArchivePath()
 	if err != nil {
-		return false
+		return false, fmt.Errorf("getting archive path: %s", err)
 	}
 
 	file, err := os.Open(filePath)
 	if err != nil {
-		return false
+		return false, fmt.Errorf("opening archive file: %s", err)
 	}
 	defer file.Close()
-	io.Copy(hash, file)
-	return bytes.Compare(hash.Sum(nil), content) == 0
+	if _, err := io.Copy(algo, file); err != nil {
+		return false, fmt.Errorf("computing hash: %s", err)
+	}
+	return bytes.Compare(algo.Sum(nil), digest) == 0, nil
 }
 
-// checkLocalArchive check for integrity of the local archive.
-func checkLocalArchive(release *DownloadResource) error {
-	archivePath, err := release.ArchivePath()
+// TestLocalArchiveSize test if the local archive size match the DownloadResource size
+func (r *DownloadResource) TestLocalArchiveSize() (bool, error) {
+	filePath, err := r.ArchivePath()
 	if err != nil {
-		return err
-	}
-	stats, err := os.Stat(archivePath)
-	if os.IsNotExist(err) {
-		return errors.New("Archive does not exist")
+		return false, fmt.Errorf("getting archive path: %s", err)
 	}
+	info, err := os.Stat(filePath)
 	if err != nil {
-		return err
+		return false, fmt.Errorf("getting archive info: %s", err)
+	}
+	return info.Size() != r.Size, nil
+}
+
+// TestLocalArchiveIntegrity checks for integrity of the local archive.
+func (r *DownloadResource) TestLocalArchiveIntegrity() (bool, error) {
+	if cached, err := r.IsCached(); err != nil {
+		return false, fmt.Errorf("testing if archive is cached: %s", err)
+	} else if !cached {
+		return false, nil
 	}
-	if stats.Size() > release.Size {
-		return errors.New("Archive size does not match with specification of this release, assuming corruption")
+
+	if ok, err := r.TestLocalArchiveSize(); err != nil {
+		return false, fmt.Errorf("teting archive size: %s", err)
+	} else if !ok {
+		return false, nil
 	}
-	if !checksumMatches(release) {
-		return errors.New("Checksum does not match, assuming corruption")
+
+	ok, err := r.TestLocalArchiveChecksum()
+	if err != nil {
+		return false, fmt.Errorf("testing archive checksum: %s", err)
 	}
-	return nil
+	return ok, nil
 }
 
 const (

common/releases/helpers.go

@@ -39,17 +39,6 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-// IsCached returns a bool representing if the release has already been downloaded
-func IsCached(release *DownloadResource) bool {
-	archivePath, err := release.ArchivePath()
-	if err != nil {
-		return false
-	}
-
-	_, err = os.Stat(archivePath)
-	return !os.IsNotExist(err)
-}
-
 // downloadRelease downloads a generic release.
 //
 //   PARAMS:
@@ -72,8 +61,11 @@ func downloadRelease(item *DownloadResource, progressChangedHandler common.Downl
 	if err != nil {
 		return err
 	}
-	err = checkLocalArchive(item)
+	ok, err := item.TestLocalArchiveIntegrity()
 	if err != nil {
+		return fmt.Errorf("testing local archive integrity: %s", err)
+	}
+	if !ok {
 		return errors.New("Archive has been downloaded, but it seems corrupted. Try again to redownload it")
 	}
 	return nil
@@ -126,9 +118,19 @@ func ParallelDownload(items map[string]*DownloadResource, forced bool,
 	logrus.Info(fmt.Sprintf("Initiating parallel download of %d resources", len(items)))
 
 	for itemName, item := range items {
-		cached := IsCached(item)
-		releaseNotNil := item != nil
-		if forced || releaseNotNil && (!cached || checkLocalArchive(item) != nil) {
+		if item == nil {
+			continue
+		}
+		cached := false
+		if !forced {
+			if c, err := item.IsCached(); err != nil {
+				res[itemName] = &DownloadResult{Error: fmt.Errorf("detecting if item is cached:%s", err)}
+				continue
+			} else {
+				cached = c
+			}
+		}
+		if forced || !cached {
 			// Notify the progress handler of the new task
 			if progressHandler != nil {
 				progressHandler.OnNewDownloadTask(itemName, item.Size)
@@ -146,7 +148,7 @@ func ParallelDownload(items map[string]*DownloadResource, forced bool,
 			}
 
 			tasks[itemName] = downloadTask(item, getProgressHandler(itemName))
-		} else if !forced && releaseNotNil && cached {
+		} else {
 			// Item already downloaded
 			res[itemName] = &DownloadResult{AlreadyDownloaded: true}
 		}