Method Push

src/cmd/linuxkit/cache/push.go:25–160

Push push an image along with a multi-arch index. name is the name as referenced in the local cache, remoteName is the name to give it remotely. If remoteName is empty, it is the same as name. If withArchSpecificTags is true, it will push all arch-specific images in the index, each as their own tag

(name, remoteName string, withArchSpecificTags, override bool)

// their own tag with the same name as the index, but with the architecture appended, e.g.
// image:foo will have image:foo-amd64, image:foo-arm64, image:foo-riscv64, etc.
func (p *Provider) Push(name, remoteName string, withArchSpecificTags, override bool) error {
	var (
		err     error
		options []remote.Option
	)
	if remoteName == "" {
		remoteName = name
	}
	ref, err := namepkg.ParseReference(remoteName)
	if err != nil {
		return err
	}
	options = append(options, remote.WithAuthFromKeychain(authn.DefaultKeychain))

	fmt.Printf("Pushing local %s as %s\n", name, remoteName)

	// check if it already exists, unless override is explicit
	if !override {
		if _, err := registry.GetRemote().Get(ref, options...); err == nil {
			log.Infof("image %s already exists in the registry, skipping", remoteName)
			return nil
		}
	}

	// if we made it this far, either we had a specific override, or we do not have the image remotely

	// do we even have the given one?
	root, err := p.FindRoot(name)
	if err != nil {
		return err
	}

	img, err1 := root.Image()
	ii, err2 := root.ImageIndex()
	// before we even try to push, let us see if it exists remotely
	remoteOptions := []remote.Option{remote.WithAuthFromKeychain(authn.DefaultKeychain)}

	switch {
	case err1 == nil:
		dig, err := img.Digest()
		if err != nil {
			return fmt.Errorf("could not get digest for local image %s: %v", name, err)
		}
		desc, err := registry.GetRemote().Get(ref, remoteOptions...)
		if err == nil && desc != nil && dig == desc.Digest {
			fmt.Printf("%s image already available on remote registry, skipping push\n", remoteName)
			return nil
		}
		log.Debugf("pushing image %s as %s", name, remoteName)
		if err := remote.Write(ref, img, options...); err != nil {
			return err
		}
		fmt.Printf("Pushed image %s\n", name)
	case err2 == nil:
		dig, err := ii.Digest()
		if err != nil {
			return fmt.Errorf("could not get digest for index %s: %v", name, err)
		}