From 0d99d18803f742e25834074858483241476994e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Sat, 13 Mar 2021 14:22:50 +0100 Subject: [PATCH 01/12] Allow loading local images as well as from cache Previously only allowed loading from daemon or remote via the cache, and not directly from local tarball. --- cmd/minikube/cmd/image.go | 48 ++++++++++++++++-- pkg/minikube/bootstrapper/kubeadm/kubeadm.go | 2 +- pkg/minikube/machine/cache_images.go | 51 ++++++++++++++++---- site/content/en/docs/commands/image.md | 18 ++++++- 4 files changed, 102 insertions(+), 17 deletions(-) diff --git a/cmd/minikube/cmd/image.go b/cmd/minikube/cmd/image.go index 3186c7120a76..84bb302d6b0e 100644 --- a/cmd/minikube/cmd/image.go +++ b/cmd/minikube/cmd/image.go @@ -17,6 +17,9 @@ limitations under the License. package cmd import ( + "os" + "strings" + "github.com/spf13/cobra" "github.com/spf13/viper" "k8s.io/minikube/pkg/minikube/config" @@ -32,11 +35,17 @@ var imageCmd = &cobra.Command{ Long: "Load a local image into minikube", } +var ( + imgDaemon bool + imgRemote bool +) + // loadImageCmd represents the image load command var loadImageCmd = &cobra.Command{ - Use: "load", - Short: "Load a local image into minikube", - Long: "Load a local image into minikube", + Use: "load", + Short: "Load a image into minikube", + Long: "Load a image into minikube", + Example: "minikube image load image\nminikube image load image.tar", Run: func(cmd *cobra.Command, args []string) { if len(args) == 0 { exit.Message(reason.Usage, "Please provide an image in your local daemon to load into minikube via ") @@ -47,12 +56,41 @@ var loadImageCmd = &cobra.Command{ exit.Error(reason.Usage, "loading profile", err) } img := args[0] - if err := machine.CacheAndLoadImages([]string{img}, []*config.Profile{profile}); err != nil { - exit.Error(reason.GuestImageLoad, "Failed to load image", err) + + var local bool + if imgRemote || imgDaemon { + local = false + } else if strings.HasPrefix(img, "/") || strings.HasPrefix(img, ".") { + local = true + imgDaemon = false + imgRemote = false + } else if _, err := os.Stat(img); err == nil { + local = true + imgDaemon = false + imgRemote = false + } else { + imgDaemon = true + imgRemote = true + } + + // Currently "image.retrieveImage" always tries to load both from daemon and from remote + // There is no way to skip daemon.Image or remote.Image, for the vague "ref" string given. + if imgDaemon || imgRemote { + if err := machine.CacheAndLoadImages([]string{img}, []*config.Profile{profile}); err != nil { + exit.Error(reason.GuestImageLoad, "Failed to load image", err) + } + // Load images from local files, without doing any caching or checks in container runtime + // This is similar to tarball.Image but it is done by the container runtime in the cluster. + } else if local { + if err := machine.DoLoadImages([]string{img}, []*config.Profile{profile}, ""); err != nil { + exit.Error(reason.GuestImageLoad, "Failed to load image", err) + } } }, } func init() { imageCmd.AddCommand(loadImageCmd) + loadImageCmd.Flags().BoolVar(&imgDaemon, "daemon", false, "Cache image from docker daemon") + loadImageCmd.Flags().BoolVar(&imgRemote, "remote", false, "Cache image from remote registry") } diff --git a/pkg/minikube/bootstrapper/kubeadm/kubeadm.go b/pkg/minikube/bootstrapper/kubeadm/kubeadm.go index 883136ab1d98..8ef7000c8007 100644 --- a/pkg/minikube/bootstrapper/kubeadm/kubeadm.go +++ b/pkg/minikube/bootstrapper/kubeadm/kubeadm.go @@ -859,7 +859,7 @@ func (k *Bootstrapper) UpdateCluster(cfg config.ClusterConfig) error { } if cfg.KubernetesConfig.ShouldLoadCachedImages { - if err := machine.LoadImages(&cfg, k.c, images, constants.ImageCacheDir); err != nil { + if err := machine.LoadCachedImages(&cfg, k.c, images, constants.ImageCacheDir); err != nil { out.FailureT("Unable to load cached images: {{.error}}", out.V{"error": err}) } } diff --git a/pkg/minikube/machine/cache_images.go b/pkg/minikube/machine/cache_images.go index 1288e7117bf2..304d9a6b7085 100644 --- a/pkg/minikube/machine/cache_images.go +++ b/pkg/minikube/machine/cache_images.go @@ -61,8 +61,8 @@ func CacheImagesForBootstrapper(imageRepository string, version string, clusterB return nil } -// LoadImages loads previously cached images into the container runtime -func LoadImages(cc *config.ClusterConfig, runner command.Runner, images []string, cacheDir string) error { +// LoadCachedImages loads previously cached images into the container runtime +func LoadCachedImages(cc *config.ClusterConfig, runner command.Runner, images []string, cacheDir string) error { cr, err := cruntime.New(cruntime.Config{Type: cc.KubernetesConfig.ContainerRuntime, Runner: runner}) if err != nil { return errors.Wrap(err, "runtime") @@ -73,6 +73,7 @@ func LoadImages(cc *config.ClusterConfig, runner command.Runner, images []string klog.Infof("Images are preloaded, skipping loading") return nil } + klog.Infof("LoadImages start: %s", images) start := time.Now() @@ -102,7 +103,7 @@ func LoadImages(cc *config.ClusterConfig, runner command.Runner, images []string return nil } klog.Infof("%q needs transfer: %v", image, err) - return transferAndLoadImage(runner, cc.KubernetesConfig, image, cacheDir) + return transferAndLoadCachedImage(runner, cc.KubernetesConfig, image, cacheDir) }) } if err := g.Wait(); err != nil { @@ -157,6 +158,22 @@ func needsTransfer(imgClient *client.Client, imgName string, cr cruntime.Manager return nil } +// LoadLocalImages loads images into the container runtime +func LoadLocalImages(cc *config.ClusterConfig, runner command.Runner, images []string) error { + var g errgroup.Group + for _, image := range images { + image := image + g.Go(func() error { + return transferAndLoadImage(runner, cc.KubernetesConfig, image) + }) + } + if err := g.Wait(); err != nil { + return errors.Wrap(err, "loading images") + } + klog.Infoln("Successfully loaded all images") + return nil +} + // CacheAndLoadImages caches and loads images to all profiles func CacheAndLoadImages(images []string, profiles []*config.Profile) error { if len(images) == 0 { @@ -168,6 +185,11 @@ func CacheAndLoadImages(images []string, profiles []*config.Profile) error { return errors.Wrap(err, "save to dir") } + return DoLoadImages(images, profiles, constants.ImageCacheDir) +} + +// DoLoadImages loads images to all profiles +func DoLoadImages(images []string, profiles []*config.Profile, cacheDir string) error { api, err := NewAPIClient() if err != nil { return errors.Wrap(err, "api") @@ -209,7 +231,13 @@ func CacheAndLoadImages(images []string, profiles []*config.Profile) error { if err != nil { return err } - err = LoadImages(c, cr, images, constants.ImageCacheDir) + if cacheDir != "" { + // loading image names, from cache + err = LoadCachedImages(c, cr, images, cacheDir) + } else { + // loading image files + err = LoadLocalImages(c, cr, images) + } if err != nil { failed = append(failed, m) klog.Warningf("Failed to load cached images for profile %s. make sure the profile is running. %v", pName, err) @@ -226,15 +254,20 @@ func CacheAndLoadImages(images []string, profiles []*config.Profile) error { return nil } -// transferAndLoadImage transfers and loads a single image from the cache -func transferAndLoadImage(cr command.Runner, k8s config.KubernetesConfig, imgName string, cacheDir string) error { +// transferAndLoadCachedImage transfers and loads a single image from the cache +func transferAndLoadCachedImage(cr command.Runner, k8s config.KubernetesConfig, imgName string, cacheDir string) error { + src := filepath.Join(cacheDir, imgName) + src = localpath.SanitizeCacheDir(src) + return transferAndLoadImage(cr, k8s, src) +} + +// transferAndLoadImage transfers and loads a single image +func transferAndLoadImage(cr command.Runner, k8s config.KubernetesConfig, src string) error { r, err := cruntime.New(cruntime.Config{Type: k8s.ContainerRuntime, Runner: cr}) if err != nil { return errors.Wrap(err, "runtime") } - src := filepath.Join(cacheDir, imgName) - src = localpath.SanitizeCacheDir(src) - klog.Infof("Loading image from cache: %s", src) + klog.Infof("Loading image from: %s", src) filename := filepath.Base(src) if _, err := os.Stat(src); err != nil { return err diff --git a/site/content/en/docs/commands/image.md b/site/content/en/docs/commands/image.md index e98ceb45ebb7..858e9cfec8e4 100644 --- a/site/content/en/docs/commands/image.md +++ b/site/content/en/docs/commands/image.md @@ -72,16 +72,30 @@ minikube image help [command] [flags] ## minikube image load -Load a local image into minikube +Load a image into minikube ### Synopsis -Load a local image into minikube +Load a image into minikube ```shell minikube image load [flags] ``` +### Examples + +``` +minikube image load image +minikube image load image.tar +``` + +### Options + +``` + --daemon Cache image from docker daemon + --remote Cache image from remote registry +``` + ### Options inherited from parent commands ``` From ea1d023c8a51597f11b31fc83a7aac81a5570ce2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Sat, 13 Mar 2021 14:28:10 +0100 Subject: [PATCH 02/12] Allow loading more than one image at a time They need to all be cached or all be local, though. If one appears to be local, then assume that all are. --- cmd/minikube/cmd/image.go | 31 ++++++++++++++++++------------- 1 file changed, 18 insertions(+), 13 deletions(-) diff --git a/cmd/minikube/cmd/image.go b/cmd/minikube/cmd/image.go index 84bb302d6b0e..8fad132fd435 100644 --- a/cmd/minikube/cmd/image.go +++ b/cmd/minikube/cmd/image.go @@ -55,34 +55,39 @@ var loadImageCmd = &cobra.Command{ if err != nil { exit.Error(reason.Usage, "loading profile", err) } - img := args[0] var local bool if imgRemote || imgDaemon { local = false - } else if strings.HasPrefix(img, "/") || strings.HasPrefix(img, ".") { - local = true - imgDaemon = false - imgRemote = false - } else if _, err := os.Stat(img); err == nil { - local = true - imgDaemon = false - imgRemote = false } else { - imgDaemon = true - imgRemote = true + for _, img := range args { + if strings.HasPrefix(img, "/") || strings.HasPrefix(img, ".") { + local = true + imgDaemon = false + imgRemote = false + } else if _, err := os.Stat(img); err == nil { + local = true + imgDaemon = false + imgRemote = false + } + } + + if !local { + imgDaemon = true + imgRemote = true + } } // Currently "image.retrieveImage" always tries to load both from daemon and from remote // There is no way to skip daemon.Image or remote.Image, for the vague "ref" string given. if imgDaemon || imgRemote { - if err := machine.CacheAndLoadImages([]string{img}, []*config.Profile{profile}); err != nil { + if err := machine.CacheAndLoadImages(args, []*config.Profile{profile}); err != nil { exit.Error(reason.GuestImageLoad, "Failed to load image", err) } // Load images from local files, without doing any caching or checks in container runtime // This is similar to tarball.Image but it is done by the container runtime in the cluster. } else if local { - if err := machine.DoLoadImages([]string{img}, []*config.Profile{profile}, ""); err != nil { + if err := machine.DoLoadImages(args, []*config.Profile{profile}, ""); err != nil { exit.Error(reason.GuestImageLoad, "Failed to load image", err) } } From 3e4a0202cbf8a5060b9545178c7d01e0bab06d2e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Mon, 15 Mar 2021 20:27:28 +0100 Subject: [PATCH 03/12] Allow loading image from standard input stream --- cmd/minikube/cmd/image.go | 32 +++++++++++++++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/cmd/minikube/cmd/image.go b/cmd/minikube/cmd/image.go index 8fad132fd435..68b5cebbc3d0 100644 --- a/cmd/minikube/cmd/image.go +++ b/cmd/minikube/cmd/image.go @@ -17,6 +17,8 @@ limitations under the License. package cmd import ( + "io" + "io/ioutil" "os" "strings" @@ -40,6 +42,22 @@ var ( imgRemote bool ) +func saveFile(r io.Reader) (string, error) { + tmp, err := ioutil.TempFile("", "build.*.tar") + if err != nil { + return "", err + } + _, err = io.Copy(tmp, r) + if err != nil { + return "", err + } + err = tmp.Close() + if err != nil { + return "", err + } + return tmp.Name(), nil +} + // loadImageCmd represents the image load command var loadImageCmd = &cobra.Command{ Use: "load", @@ -61,7 +79,11 @@ var loadImageCmd = &cobra.Command{ local = false } else { for _, img := range args { - if strings.HasPrefix(img, "/") || strings.HasPrefix(img, ".") { + if img == "-" { // stdin + local = true + imgDaemon = false + imgRemote = false + } else if strings.HasPrefix(img, "/") || strings.HasPrefix(img, ".") { local = true imgDaemon = false imgRemote = false @@ -78,6 +100,14 @@ var loadImageCmd = &cobra.Command{ } } + if args[0] == "-" { + tmp, err := saveFile(os.Stdin) + if err != nil { + exit.Error(reason.GuestImageLoad, "Failed to save stdin", err) + } + args = []string{tmp} + } + // Currently "image.retrieveImage" always tries to load both from daemon and from remote // There is no way to skip daemon.Image or remote.Image, for the vague "ref" string given. if imgDaemon || imgRemote { From eea380fc0e9155d3e0cd6e6108b48b4e18c3b276 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Tue, 16 Mar 2021 19:36:59 +0100 Subject: [PATCH 04/12] Add example parameters to the usage help text --- cmd/minikube/cmd/image.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/minikube/cmd/image.go b/cmd/minikube/cmd/image.go index 68b5cebbc3d0..07ac58bbb4a1 100644 --- a/cmd/minikube/cmd/image.go +++ b/cmd/minikube/cmd/image.go @@ -60,7 +60,7 @@ func saveFile(r io.Reader) (string, error) { // loadImageCmd represents the image load command var loadImageCmd = &cobra.Command{ - Use: "load", + Use: "load IMAGE | ARCHIVE | -", Short: "Load a image into minikube", Long: "Load a image into minikube", Example: "minikube image load image\nminikube image load image.tar", From e1eaeba691cd5be8ea0ac01c44b0daa74a4df2a8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Mon, 22 Mar 2021 20:43:16 +0100 Subject: [PATCH 05/12] Fix whitespace to make goimports happy --- cmd/minikube/cmd/image.go | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/cmd/minikube/cmd/image.go b/cmd/minikube/cmd/image.go index 07ac58bbb4a1..6d100924e614 100644 --- a/cmd/minikube/cmd/image.go +++ b/cmd/minikube/cmd/image.go @@ -43,19 +43,19 @@ var ( ) func saveFile(r io.Reader) (string, error) { - tmp, err := ioutil.TempFile("", "build.*.tar") - if err != nil { - return "", err - } - _, err = io.Copy(tmp, r) - if err != nil { - return "", err - } - err = tmp.Close() - if err != nil { - return "", err - } - return tmp.Name(), nil + tmp, err := ioutil.TempFile("", "build.*.tar") + if err != nil { + return "", err + } + _, err = io.Copy(tmp, r) + if err != nil { + return "", err + } + err = tmp.Close() + if err != nil { + return "", err + } + return tmp.Name(), nil } // loadImageCmd represents the image load command @@ -101,11 +101,11 @@ var loadImageCmd = &cobra.Command{ } if args[0] == "-" { - tmp, err := saveFile(os.Stdin) - if err != nil { - exit.Error(reason.GuestImageLoad, "Failed to save stdin", err) - } - args = []string{tmp} + tmp, err := saveFile(os.Stdin) + if err != nil { + exit.Error(reason.GuestImageLoad, "Failed to save stdin", err) + } + args = []string{tmp} } // Currently "image.retrieveImage" always tries to load both from daemon and from remote From fd4a62f77fe1da0e4ed88452395c9a6b6bb4bfc3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Mon, 22 Mar 2021 20:45:55 +0100 Subject: [PATCH 06/12] Make it possible to choose daemon or remote --- cmd/minikube/cmd/image.go | 5 ++-- pkg/minikube/image/image.go | 46 ++++++++++++++++++++++++++----------- 2 files changed, 35 insertions(+), 16 deletions(-) diff --git a/cmd/minikube/cmd/image.go b/cmd/minikube/cmd/image.go index 6d100924e614..78c853db59a7 100644 --- a/cmd/minikube/cmd/image.go +++ b/cmd/minikube/cmd/image.go @@ -26,6 +26,7 @@ import ( "github.com/spf13/viper" "k8s.io/minikube/pkg/minikube/config" "k8s.io/minikube/pkg/minikube/exit" + "k8s.io/minikube/pkg/minikube/image" "k8s.io/minikube/pkg/minikube/machine" "k8s.io/minikube/pkg/minikube/reason" ) @@ -108,9 +109,9 @@ var loadImageCmd = &cobra.Command{ args = []string{tmp} } - // Currently "image.retrieveImage" always tries to load both from daemon and from remote - // There is no way to skip daemon.Image or remote.Image, for the vague "ref" string given. if imgDaemon || imgRemote { + image.UseDaemon = imgDaemon + image.UseRemote = imgRemote if err := machine.CacheAndLoadImages(args, []*config.Profile{profile}); err != nil { exit.Error(reason.GuestImageLoad, "Failed to load image", err) } diff --git a/pkg/minikube/image/image.go b/pkg/minikube/image/image.go index ece5fb4e324d..cefac3c940bb 100644 --- a/pkg/minikube/image/image.go +++ b/pkg/minikube/image/image.go @@ -46,6 +46,12 @@ var defaultPlatform = v1.Platform{ OS: "linux", } +// UseDaemon is if we should look in local daemon for image ref +var UseDaemon = true + +// UseRemote is if we should look in remote registry for image ref +var UseRemote = true + // DigestByDockerLib uses client by docker lib to return image digest // img.ID in as same as image digest func DigestByDockerLib(imgClient *client.Client, imgName string) string { @@ -165,25 +171,37 @@ func WriteImageToDaemon(img string) error { } func retrieveImage(ref name.Reference) (v1.Image, error) { + var err error + var img v1.Image + klog.Infof("retrieving image: %+v", ref) - img, err := daemon.Image(ref) - if err == nil { - klog.Infof("found %s locally: %+v", ref.Name(), img) - return img, nil - } - // reference does not exist in the local daemon - if err != nil { - klog.Infof("daemon lookup for %+v: %v", ref, err) + if UseDaemon { + img, err = daemon.Image(ref) + if err == nil { + klog.Infof("found %s locally: %+v", ref.Name(), img) + return img, nil + } + // reference does not exist in the local daemon + if err != nil { + klog.Infof("daemon lookup for %+v: %v", ref, err) + } } - platform := defaultPlatform - img, err = remote.Image(ref, remote.WithAuthFromKeychain(authn.DefaultKeychain), remote.WithPlatform(platform)) - if err == nil { - return img, nil + if UseRemote { + platform := defaultPlatform + img, err = remote.Image(ref, remote.WithAuthFromKeychain(authn.DefaultKeychain), remote.WithPlatform(platform)) + if err == nil { + return img, nil + } + + klog.Warningf("authn lookup for %+v (trying anon): %+v", ref, err) + img, err = remote.Image(ref) + // reference does not exist in the remote registry + if err != nil { + klog.Infof("remote lookup for %+v: %v", ref, err) + } } - klog.Warningf("authn lookup for %+v (trying anon): %+v", ref, err) - img, err = remote.Image(ref) return img, err } From 1ab1eada298560c05751ef2e33c3956ac02af354 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Mon, 22 Mar 2021 20:54:47 +0100 Subject: [PATCH 07/12] Cleanup the weird-looking comment indentation --- cmd/minikube/cmd/image.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/minikube/cmd/image.go b/cmd/minikube/cmd/image.go index 78c853db59a7..52e112c86cf5 100644 --- a/cmd/minikube/cmd/image.go +++ b/cmd/minikube/cmd/image.go @@ -115,9 +115,9 @@ var loadImageCmd = &cobra.Command{ if err := machine.CacheAndLoadImages(args, []*config.Profile{profile}); err != nil { exit.Error(reason.GuestImageLoad, "Failed to load image", err) } + } else if local { // Load images from local files, without doing any caching or checks in container runtime // This is similar to tarball.Image but it is done by the container runtime in the cluster. - } else if local { if err := machine.DoLoadImages(args, []*config.Profile{profile}, ""); err != nil { exit.Error(reason.GuestImageLoad, "Failed to load image", err) } From 99454629018c375fb6733d38de7e7f75d82ddfce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Tue, 23 Mar 2021 07:08:51 +0100 Subject: [PATCH 08/12] Refactor: add daemon function matching remote --- pkg/minikube/image/image.go | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/pkg/minikube/image/image.go b/pkg/minikube/image/image.go index 64d3814c25f8..49809be2b814 100644 --- a/pkg/minikube/image/image.go +++ b/pkg/minikube/image/image.go @@ -209,13 +209,10 @@ func retrieveImage(ref name.Reference) (v1.Image, error) { klog.Infof("retrieving image: %+v", ref) if UseDaemon { - img, err := daemon.Image(ref) - if err == nil { - klog.Infof("found %s locally: %+v", ref.Name(), img) - return img, nil + img, err = retrieveDaemon(ref) + if err != nil { + return nil, err } - // reference does not exist in the local daemon - klog.Infof("daemon lookup for %+v: %v", ref, err) } if UseRemote { @@ -229,6 +226,17 @@ func retrieveImage(ref name.Reference) (v1.Image, error) { return img, err } +func retrieveDaemon(ref name.Reference) (v1.Image, error) { + img, err := daemon.Image(ref) + if err == nil { + klog.Infof("found %s locally: %+v", ref.Name(), img) + return img, nil + } + // reference does not exist in the local daemon + klog.Infof("daemon lookup for %+v: %v", ref, err) + return img, err +} + func retrieveRemote(ref name.Reference, p v1.Platform) (v1.Image, error) { img, err := remote.Image(ref, remote.WithAuthFromKeychain(authn.DefaultKeychain), remote.WithPlatform(p)) if err == nil { From 3bcb5a1e093c012e991e16af9d052ef9b5d18457 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Tue, 23 Mar 2021 07:53:55 +0100 Subject: [PATCH 09/12] Regenerate documentation with the new load help --- site/content/en/docs/commands/image.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/site/content/en/docs/commands/image.md b/site/content/en/docs/commands/image.md index dfaf5c41c697..af13106b244d 100644 --- a/site/content/en/docs/commands/image.md +++ b/site/content/en/docs/commands/image.md @@ -79,7 +79,7 @@ Load a image into minikube Load a image into minikube ```shell -minikube image load [flags] +minikube image load IMAGE | ARCHIVE | - [flags] ``` ### Examples From e35057ae7d2bb94fb4a6622a273c0515a11c46d8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Tue, 23 Mar 2021 12:34:43 +0100 Subject: [PATCH 10/12] Use accessor methods instead of just variables --- cmd/minikube/cmd/image.go | 4 ++-- pkg/minikube/image/image.go | 17 +++++++++++++---- 2 files changed, 15 insertions(+), 6 deletions(-) diff --git a/cmd/minikube/cmd/image.go b/cmd/minikube/cmd/image.go index 52e112c86cf5..de3e80e389fa 100644 --- a/cmd/minikube/cmd/image.go +++ b/cmd/minikube/cmd/image.go @@ -110,8 +110,8 @@ var loadImageCmd = &cobra.Command{ } if imgDaemon || imgRemote { - image.UseDaemon = imgDaemon - image.UseRemote = imgRemote + image.UseDaemon(imgDaemon) + image.UseRemote(imgRemote) if err := machine.CacheAndLoadImages(args, []*config.Profile{profile}); err != nil { exit.Error(reason.GuestImageLoad, "Failed to load image", err) } diff --git a/pkg/minikube/image/image.go b/pkg/minikube/image/image.go index 49809be2b814..9089550068a3 100644 --- a/pkg/minikube/image/image.go +++ b/pkg/minikube/image/image.go @@ -49,11 +49,20 @@ var defaultPlatform = v1.Platform{ OS: "linux", } +var ( + useDaemon = true + useRemote = true +) + // UseDaemon is if we should look in local daemon for image ref -var UseDaemon = true +func UseDaemon(use bool) { + useDaemon = use +} // UseRemote is if we should look in remote registry for image ref -var UseRemote = true +func UseRemote(use bool) { + useRemote = use +} // DigestByDockerLib uses client by docker lib to return image digest // img.ID in as same as image digest @@ -208,14 +217,14 @@ func retrieveImage(ref name.Reference) (v1.Image, error) { var img v1.Image klog.Infof("retrieving image: %+v", ref) - if UseDaemon { + if useDaemon { img, err = retrieveDaemon(ref) if err != nil { return nil, err } } - if UseRemote { + if useRemote { img, err = retrieveRemote(ref, defaultPlatform) if err != nil { return nil, err From 8a027b553964edcf71db907577987d0da4d39e09 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Wed, 24 Mar 2021 13:49:02 +0100 Subject: [PATCH 11/12] Don't fail after daemon errors without remote --- pkg/minikube/image/image.go | 4 ---- 1 file changed, 4 deletions(-) diff --git a/pkg/minikube/image/image.go b/pkg/minikube/image/image.go index 9089550068a3..4650e4f89d60 100644 --- a/pkg/minikube/image/image.go +++ b/pkg/minikube/image/image.go @@ -219,11 +219,7 @@ func retrieveImage(ref name.Reference) (v1.Image, error) { klog.Infof("retrieving image: %+v", ref) if useDaemon { img, err = retrieveDaemon(ref) - if err != nil { - return nil, err - } } - if useRemote { img, err = retrieveRemote(ref, defaultPlatform) if err != nil { From 6ce802b87016f1205266768d89ce25d115ad82f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20F=20Bj=C3=B6rklund?= Date: Wed, 24 Mar 2021 14:14:04 +0100 Subject: [PATCH 12/12] Clean up and fix logic after all refactoring --- pkg/minikube/image/image.go | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/pkg/minikube/image/image.go b/pkg/minikube/image/image.go index 4650e4f89d60..6817f3c05d88 100644 --- a/pkg/minikube/image/image.go +++ b/pkg/minikube/image/image.go @@ -216,19 +216,25 @@ func retrieveImage(ref name.Reference) (v1.Image, error) { var err error var img v1.Image + if !useDaemon && !useRemote { + return nil, fmt.Errorf("neither daemon nor remote") + } + klog.Infof("retrieving image: %+v", ref) if useDaemon { img, err = retrieveDaemon(ref) + if err == nil { + return img, nil + } } if useRemote { img, err = retrieveRemote(ref, defaultPlatform) - if err != nil { - return nil, err + if err == nil { + return fixPlatform(ref, img, defaultPlatform) } - return fixPlatform(ref, img, defaultPlatform) } - return img, err + return nil, err } func retrieveDaemon(ref name.Reference) (v1.Image, error) {