migrate Podman to containers/common/libimage

Migrate the Podman code base over to `common/libimage` which replaces
`libpod/image` and a lot of glue code entirely.

Note that I tried to leave bread crumbs for changed tests.

Miscellaneous changes:

 * Some errors yield different messages which required to alter some
   tests.

 * I fixed some pre-existing issues in the code.  Others were marked as
   `//TODO`s to prevent the PR from exploding.

 * The `NamesHistory` of an image is returned as is from the storage.
   Previously, we did some filtering which I think is undesirable.
   Instead we should return the data as stored in the storage.

 * Touched handlers use the ABI interfaces where possible.

 * Local image resolution: previously Podman would match "foo" on
   "myfoo".  This behaviour has been changed and Podman will now
   only match on repository boundaries such that "foo" would match
   "my/foo" but not "myfoo".  I consider the old behaviour to be a
   bug, at the very least an exotic corner case.

 * Futhermore, "foo:none" does *not* resolve to a local image "foo"
   without tag anymore.  It's a hill I am (almost) willing to die on.

 * `image prune` prints the IDs of pruned images.  Previously, in some
   cases, the names were printed instead.  The API clearly states ID,
   so we should stick to it.

 * Compat endpoint image removal with _force_ deletes the entire not
   only the specified tag.

Signed-off-by: Valentin Rothberg <rothberg@redhat.com>

vendor/github.com/containers/common/libimage/push.go

@@ -0,0 +1,83 @@
+package libimage
+
+import (
+	"context"
+
+	dockerArchiveTransport "github.com/containers/image/v5/docker/archive"
+	"github.com/containers/image/v5/docker/reference"
+	"github.com/containers/image/v5/transports/alltransports"
+	"github.com/sirupsen/logrus"
+)
+
+// PushOptions allows for custommizing image pushes.
+type PushOptions struct {
+	CopyOptions
+}
+
+// Push pushes the specified source which must refer to an image in the local
+// containers storage.  It may or may not have the `containers-storage:`
+// prefix.  Use destination to push to a custom destination.  The destination
+// can refer to any supported transport.  If not transport is specified, the
+// docker transport (i.e., a registry) is implied.  If destination is left
+// empty, the docker destination will be extrapolated from the source.
+//
+// Return storage.ErrImageUnknown if source could not be found in the local
+// containers storage.
+func (r *Runtime) Push(ctx context.Context, source, destination string, options *PushOptions) ([]byte, error) {
+	if options == nil {
+		options = &PushOptions{}
+	}
+
+	// Look up the local image.
+	image, resolvedSource, err := r.LookupImage(source, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	srcRef, err := image.StorageReference()
+	if err != nil {
+		return nil, err
+	}
+
+	// Make sure we have a proper destination, and parse it into an image
+	// reference for copying.
+	if destination == "" {
+		// Doing an ID check here is tempting but false positives (due
+		// to a short partial IDs) are more painful than false
+		// negatives.
+		destination = resolvedSource
+	}
+
+	logrus.Debugf("Pushing image %s to %s", source, destination)
+
+	destRef, err := alltransports.ParseImageName(destination)
+	if err != nil {
+		// If the input does not include a transport assume it refers
+		// to a registry.
+		dockerRef, dockerErr := alltransports.ParseImageName("docker://" + destination)
+		if dockerErr != nil {
+			return nil, err
+		}
+		destRef = dockerRef
+	}
+
+	// Buildah compat: Make sure to tag the destination image if it's a
+	// Docker archive. This way, we preseve the image name.
+	if destRef.Transport().Name() == dockerArchiveTransport.Transport.Name() {
+		if named, err := reference.ParseNamed(resolvedSource); err == nil {
+			tagged, isTagged := named.(reference.NamedTagged)
+			if isTagged {
+				options.dockerArchiveAdditionalTags = []reference.NamedTagged{tagged}
+			}
+		}
+	}
+
+	c, err := r.newCopier(&options.CopyOptions)
+	if err != nil {
+		return nil, err
+	}
+
+	defer c.close()
+
+	return c.copy(ctx, srcRef, destRef)
+}