Use docker config file and check latest for upgrade

Author: SamCHogg

cmd/images.go

@@ -11,8 +11,9 @@ import (
 
 const (
 	successIcon = "\xE2\x9C\x85"
-	failedIcon  = "\xE2\x9D\x97"
-	warningIcon = "\xE2\x9D\x8C"
+	warningIcon = "\xE2\x9D\x97"
+	failedIcon  = "\xE2\x9D\x8C"
+	upgradeIcon = "\xE2\xAC\x86"
 )
 
 var imagesCmd = &cobra.Command{
@@ -23,6 +24,11 @@ var imagesCmd = &cobra.Command{
 }
 
 func imagesCmdRun(cmd *cobra.Command, args []string) {
+	debug, err := cmd.Flags().GetBool("debug")
+	if err != nil {
+		log.Fatal(err)
+	}
+
 	k8sClient, err := k8s.NewKubernetesClient()
 	if err != nil {
 		log.Fatal(err)
@@ -31,17 +37,25 @@ func imagesCmdRun(cmd *cobra.Command, args []string) {
 	if err != nil {
 		log.Fatal(err)
 	}
-	fmt.Printf("Legends:\n%s - Supports arm64, %s - Do not support arm64, %s - Some error occurred\n", successIcon, warningIcon, failedIcon)
-	fmt.Print("------------------------------------------------------------------------\n\n")
+	fmt.Printf("Legends:\n%s - Supports arm64, %s - Does not support arm64, %s - Upgrade for arm64 support, %s - Some error occurred\n", successIcon, failedIcon, upgradeIcon, warningIcon)
+	fmt.Print("------------------------------------------------------------------------------------------------\n\n")
 	for _, image := range imageList {
 		var icon string
-		supportsArm, err := images.CheckLinuxArm64Support(images.ToFullURL(image))
+		supportsArm, err := images.CheckLinuxArm64Support(image)
 		if err != nil {
+			if debug {
+				fmt.Printf("error: %s\n", err)
+			}
 			icon = warningIcon
 		} else if supportsArm {
 			icon = successIcon
 		} else {
-			icon = failedIcon
+			latestSupportsArm, _ := images.CheckLatestLinuxArm64Support(image)
+			if latestSupportsArm {
+				icon = upgradeIcon
+			} else {
+				icon = failedIcon
+			}
 		}
 		fmt.Printf("%s %s\n", image, icon)
 	}
@@ -50,6 +64,8 @@ func imagesCmdRun(cmd *cobra.Command, args []string) {
 func init() {
 	rootCmd.AddCommand(imagesCmd)
 
+	imagesCmd.Flags().BoolP("debug", "d", false, "Enable debug mode")
+
 	// Here you will define your flags and configuration settings.
 
 	// Cobra supports Persistent Flags which will work for this command

internal/images/images.go

@@ -3,56 +3,75 @@ package images
 import (
 	"context"
 	"fmt"
+	"os"
+	"path/filepath"
 	"strings"
 
 	"github.com/containers/image/v5/manifest"
 	"github.com/containers/image/v5/transports/alltransports"
 	"github.com/containers/image/v5/types"
 )
 
-// ToFullURL converts the provided image name to the full URL, if already not in that format.
-// e.g. nginx becomes docker.io/library/nginx
-// If already in full URL format, image name is returned as is.
-func ToFullURL(imgName string) string {
-	splits := strings.Split(imgName, "/")
-	if len(splits) > 2 {
-		return imgName
-	}
-	if len(splits) == 2 {
-		return fmt.Sprintf("docker.io/%s", imgName)
+func getDockerConfigPath() string {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return ""
 	}
-	return fmt.Sprintf("docker.io/library/%s", imgName)
+	return filepath.Join(home, ".docker", "config.json")
 }
 
 // CheckLinuxArm64Support checks for the existance of an arm64 linux image in the manifest
 func CheckLinuxArm64Support(imgName string) (bool, error) {
 	sys := &types.SystemContext{
-		ArchitectureChoice: "arm64",
-		OSChoice:           "linux",
+		ArchitectureChoice:       "arm64",
+		OSChoice:                 "linux",
+		DockerCompatAuthFilePath: getDockerConfigPath(),
 	}
 
 	ref, err := alltransports.ParseImageName(fmt.Sprintf("docker://%s", imgName))
 	if err != nil {
-		return false, err
+		return false, fmt.Errorf("error parsing image name: %w", err)
 	}
 
 	imageSource, err := ref.NewImageSource(context.Background(), sys)
 	if err != nil {
-		return false, err
+		return false, fmt.Errorf("error getting image source: %w", err)
 	}
 	defer imageSource.Close()
 
 	rawManifest, mimeType, err := imageSource.GetManifest(context.Background(), nil)
 	if err != nil {
-		return false, err
+		return false, fmt.Errorf("error getting manifest: %w", err)
 	}
 
-	manifestList, err := manifest.ListFromBlob(rawManifest, mimeType)
-	if err != nil {
-		return false, err
+	if manifest.MIMETypeIsMultiImage(mimeType) {
+		manifestList, err := manifest.ListFromBlob(rawManifest, mimeType)
+		if err != nil {
+			return false, err
+		}
+
+		// This call will error if it cannot find a instance that supports linux arm64
+		_, err = manifestList.ChooseInstance(sys)
+		return err == nil, nil
+	} else {
+		// m, err := manifest.FromBlob(rawManifest, mimeType)
+		// if err != nil {
+		// 	return false, nil
+		// }
+		// mInfo, err := m.Inspect(nil)
+		// if err != nil {
+		// 	return false, nil
+		// }
+		// return mInfo.Architecture == "arm64", nil
+		return false, fmt.Errorf("image manifests not supported")
 	}
+}
 
-	// This call will error if it cannot find a instance that supports linux arm64
-	_, err = manifestList.ChooseInstance(sys)
-	return err == nil, nil
+func CheckLatestLinuxArm64Support(imgName string) (bool, error) {
+	split := strings.Split(imgName, ":")
+	if len(split) < 2 {
+		return false, fmt.Errorf("invalid image name")
+	}
+	latestImageName := split[0] + ":latest"
+	return CheckLinuxArm64Support(latestImageName)
 }