Merge pull request #1271 from mrunalp/bump_1.9.1

Release 1.9.1

.mailmap

@@ -1,10 +0,0 @@
-Aleksa Sarai <asarai@suse.de> <asarai@suse.com>
-Antonio Murdaca <runcom@redhat.com> <runcom@users.noreply.github.com>
-CuiHaozhi <cuihaozhi@chinacloud.com.cn> <cuihz@wise2c.com>
-Daniel J Walsh <dwalsh@redhat.com>
-Haiyan Meng <hmeng@redhat.com> <haiyanalady@gmail.com>
-Lorenzo Fontana <lo@linux.com> <fontanalorenz@gmail.com>
-Mrunal Patel <mrunalp@gmail.com> <mpatel@redhat.com>
-Mrunal Patel <mrunalp@gmail.com> <mrunal@me.com>
-Pengfei Ni <feiskyer@gmail.com> <feiskyer@users.noreply.github.com>
-Tobias Klauser <tklauser@distanz.ch> <tobias.klauser@gmail.com>

Dockerfile

@@ -38,7 +38,6 @@ RUN apt-get update && apt-get install -y \
     netcat \
     socat \
     --no-install-recommends \
-    bsdmainutils \
     && apt-get clean
 
 # install bats
@@ -57,7 +56,7 @@ RUN mkdir -p /usr/src/criu \
     && rm -rf /usr/src/criu
 
 # Install runc
-ENV RUNC_COMMIT c6e4a1ebeb1a72b529c6f1b6ee2b1ae5b868b14f
+ENV RUNC_COMMIT 84a082bfef6f932de921437815355186db37aeb1
 RUN set -x \
 	&& export GOPATH="$(mktemp -d)" \
 	&& git clone https://github.com/opencontainers/runc.git "$GOPATH/src/github.com/opencontainers/runc" \

Makefile

@@ -11,7 +11,7 @@ LIBEXECDIR ?= ${PREFIX}/libexec
 MANDIR ?= ${PREFIX}/share/man
 ETCDIR ?= ${DESTDIR}/etc
 ETCDIR_CRIO ?= ${ETCDIR}/crio
-BUILDTAGS ?= seccomp $(shell hack/btrfs_tag.sh) $(shell hack/libdm_installed.sh) $(shell hack/libdm_no_deferred_remove_tag.sh) $(shell hack/btrfs_installed_tag.sh) $(shell hack/ostree_tag.sh) $(shell hack/selinux_tag.sh)
+BUILDTAGS ?= seccomp $(shell hack/btrfs_tag.sh) $(shell hack/libdm_tag.sh) $(shell hack/btrfs_installed_tag.sh) $(shell hack/ostree_tag.sh) $(shell hack/selinux_tag.sh)
 CRICTL_CONFIG_DIR=${DESTDIR}/etc
 
 BASHINSTALLDIR=${PREFIX}/share/bash-completion/completions
@@ -64,8 +64,7 @@ lint: .gopathok
 	@./.tool/lint
 
 gofmt:
-	find . -name '*.go' ! -path './vendor/*' -exec gofmt -s -w {} \+
-	git diff --exit-code
+	@./hack/verify-gofmt.sh
 
 conmon:
 	$(MAKE) -C $@
@@ -74,16 +73,16 @@ pause:
 	$(MAKE) -C $@
 
 test/bin2img/bin2img: .gopathok $(wildcard test/bin2img/*.go)
-	$(GO) build -i $(LDFLAGS) -tags "$(BUILDTAGS) containers_image_ostree_stub" -o $@ $(PROJECT)/test/bin2img
+	$(GO) build $(LDFLAGS) -tags "$(BUILDTAGS) containers_image_ostree_stub" -o $@ $(PROJECT)/test/bin2img
 
 test/copyimg/copyimg: .gopathok $(wildcard test/copyimg/*.go)
-	$(GO) build -i $(LDFLAGS) -tags "$(BUILDTAGS) containers_image_ostree_stub" -o $@ $(PROJECT)/test/copyimg
+	$(GO) build $(LDFLAGS) -tags "$(BUILDTAGS) containers_image_ostree_stub" -o $@ $(PROJECT)/test/copyimg
 
 test/checkseccomp/checkseccomp: .gopathok $(wildcard test/checkseccomp/*.go)
-	$(GO) build -i $(LDFLAGS) -tags "$(BUILDTAGS) containers_image_ostree_stub" -o $@ $(PROJECT)/test/checkseccomp
+	$(GO) build $(LDFLAGS) -tags "$(BUILDTAGS) containers_image_ostree_stub" -o $@ $(PROJECT)/test/checkseccomp
 
 crio: .gopathok $(shell hack/find-godeps.sh $(GOPKGDIR) cmd/crio $(PROJECT))
-	$(GO) build -i $(LDFLAGS) -tags "$(BUILDTAGS) containers_image_ostree_stub" -o bin/$@ $(PROJECT)/cmd/crio
+	$(GO) build $(LDFLAGS) -tags "$(BUILDTAGS) containers_image_ostree_stub" -o bin/$@ $(PROJECT)/cmd/crio
 
 crio.conf: crio
 	./bin/crio --config="" config --default > crio.conf
@@ -146,7 +145,7 @@ install.man:
 	install ${SELINUXOPT} -m 644 $(filter %.5,$(MANPAGES)) -t $(MANDIR)/man5
 	install ${SELINUXOPT} -m 644 $(filter %.8,$(MANPAGES)) -t $(MANDIR)/man8
 
-install.config: crio.conf
+install.config:
 	install ${SELINUXOPT} -D -m 644 crio.conf $(ETCDIR_CRIO)/crio.conf
 	install ${SELINUXOPT} -D -m 644 seccomp.json $(ETCDIR_CRIO)/seccomp.json
 	install ${SELINUXOPT} -D -m 644 crio-umount.conf $(OCIUMOUNTINSTALLDIR)/crio-umount.conf

README.md

@@ -12,7 +12,6 @@
 |----------------------------|-------------------------------|--------------------|
 | CRI-O 1.0.x  - release-1.0 | Kubernetes 1.7 branch, v1.7.x | =                  |
 | CRI-O 1.8.x  - release-1.8 | Kubernetes 1.8 branch, v1.8.x | =                  |
-| CRI-O 1.9.x  - release-1.9 | Kubernetes 1.9 branch, v1.9.x | =                  |
 | CRI-O HEAD - master        | Kubernetes master branch      | ✓                  |
 
 Key:

cmd/crio/main.go

@@ -509,7 +509,7 @@ func main() {
 				if graceful && strings.Contains(strings.ToLower(err.Error()), "use of closed network connection") {
 					err = nil
 				} else {
-					logrus.Errorf("Failed to serve grpc request: %v", err)
+					logrus.Errorf("Failed to serve grpc grpc request: %v", err)
 				}
 			}
 		}()

code-of-conduct.md

@@ -1,3 +1,55 @@
-# Kubernetes Community Code of Conduct
+## Kubernetes Community Code of Conduct
 
-Please refer to our [Kubernetes Community Code of Conduct](https://git.k8s.io/community/code-of-conduct.md)
+### Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of fostering
+an open and welcoming community, we pledge to respect all people who contribute
+through reporting issues, posting feature requests, updating documentation,
+submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for
+everyone, regardless of level of experience, gender, gender identity and expression,
+sexual orientation, disability, personal appearance, body size, race, ethnicity, age,
+religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery.
+* Personal attacks.
+* Trolling or insulting/derogatory comments.
+* Public or private harassment.
+* Publishing other's private information, such as physical or electronic addresses,
+ without explicit permission.
+* Other unethical or unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are not
+aligned to this Code of Conduct.  By adopting this Code of Conduct, project maintainers
+commit themselves to fairly and consistently applying these principles to every aspect
+of managing this project.  Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting a Kubernetes maintainer, Sarah Novotny <sarahnovotny@google.com>, and/or Dan Kohn <dan@linuxfoundation.org>.
+
+This Code of Conduct is adapted from the Contributor Covenant
+(http://contributor-covenant.org), version 1.2.0, available at
+http://contributor-covenant.org/version/1/2/0/
+
+### Kubernetes Events Code of Conduct
+
+Kubernetes events are working conferences intended for professional networking and collaboration in the
+Kubernetes community.  Attendees are expected to behave according to professional standards and in accordance
+with their employer's policies on appropriate workplace behavior.
+
+While at Kubernetes events or related social networking opportunities, attendees should not engage in
+discriminatory or offensive speech or actions regarding gender, sexuality, race, or religion.  Speakers should
+be especially aware of these concerns.
+
+The Kubernetes team does not condone any statements by speakers contrary to these standards.  The Kubernetes
+team reserves the right to deny entrance and/or eject from an event (without refund) any individual found to
+be engaging in discriminatory or offensive speech or actions.
+
+Please bring any concerns to the immediate attention of the Kubernetes event staff.

conmon/conmon.c

@@ -12,6 +12,7 @@
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/un.h>
+#include <sys/stat.h>
 #include <sys/wait.h>
 #include <sys/eventfd.h>
 #include <sys/stat.h>
@@ -349,7 +350,7 @@ static int write_k8s_log(int fd, stdpipe_t pipe, const char *buf, ssize_t buflen
 			/* Open the log path file again */
 			log_fd = open(opt_log_path, O_WRONLY | O_APPEND | O_CREAT | O_CLOEXEC, 0600);
 			if (log_fd < 0)
-				pexit("Failed to open log file %s: %s", opt_log_path, strerror(errno));
+				pexit("Failed to open log file");
 			fd = log_fd;
 		}
 
@@ -1120,8 +1121,6 @@ int main(int argc, char *argv[])
 
 	if (opt_runtime_path == NULL)
 		nexit("Runtime path not provided. Use --runtime");
-	if (access(opt_runtime_path, X_OK) < 0)
-		pexit("Runtime path %s is not valid: %s", opt_runtime_path, strerror(errno));
 
 	if (!opt_exec && opt_exit_dir == NULL)
 		nexit("Container exit directory not provided. Use --exit-dir");

contrib/test/integration/build/kubernetes.yml

@@ -43,12 +43,10 @@
       export CONTAINER_RUNTIME_ENDPOINT='{{ crio_socket }} --runtime-request-timeout=5m'
       export ALLOW_SECURITY_CONTEXT=","
       export ALLOW_PRIVILEGED=1
-      export DNS_SERVER_IP={{ ansible_default_ipv4.address }}
-      export API_HOST={{ ansible_default_ipv4.address }}
-      export API_HOST_IP={{ ansible_default_ipv4.address }}
+      export DNS_SERVER_IP={{ ansible_eth0.ipv4.address }}
+      export API_HOST={{ ansible_eth0.ipv4.address }}
+      export API_HOST_IP={{ ansible_eth0.ipv4.address }}
       export KUBE_ENABLE_CLUSTER_DNS=true
-      export ENABLE_HOSTPATH_PROVISIONER=true
-      export KUBE_ENABLE_CLUSTER_DASHBOARD=true
       ./hack/local-up-cluster.sh
     mode: "u=rwx,g=rwx,o=x"
 

contrib/test/integration/build/runc.yml

@@ -4,7 +4,7 @@
   git:
     repo: "https://github.com/opencontainers/runc.git"
     dest: "{{ ansible_env.GOPATH }}/src/github.com/opencontainers/runc"
-    version: "c6e4a1ebeb1a72b529c6f1b6ee2b1ae5b868b14f"
+    version: "84a082bfef6f932de921437815355186db37aeb1"
 
 - name: build runc
   make:

contrib/test/integration/critest.yml

@@ -16,21 +16,24 @@
 - name: Add masquerade for localhost
   command: iptables -t nat -I POSTROUTING -s 127.0.0.1 ! -d 127.0.0.1 -j MASQUERADE
 
+  # TODO(runcom): enable skipped tests once we fix them (image list related)
+  # https://github.com/kubernetes-incubator/cri-o/issues/1048
 - name: run critest validation
-  shell: "critest -c --runtime-endpoint /var/run/crio/crio.sock --image-endpoint /var/run/crio/crio.sock v"
+  shell: "critest -c --runtime-endpoint /var/run/crio/crio.sock --image-endpoint /var/run/crio/crio.sock -s 'listImage should get exactly 2 repoTags in the result image' v"
   args:
     chdir: "{{ ansible_env.GOPATH }}/src/github.com/kubernetes-incubator/cri-o"
   async: 5400
   poll: 30
   when: ansible_distribution not in ['RedHat', 'CentOS']
 
-  # XXX: RHEL has an additional test which fails because of selinux but disabling
+  # XXX: RHEL has an additional test which fails beacuse of selinux but disabling
   # it doesn't solve the issue.
-  # TODO(runcom): enable skipped tests once we fix them (selinux)
+  # TODO(runcom): enable skipped tests once we fix them (image list related and selinux)
+  # https://github.com/kubernetes-incubator/cri-o/issues/1048
   # https://bugzilla.redhat.com/show_bug.cgi?id=1414236
   # https://access.redhat.com/solutions/2897781
 - name: run critest validation
-  shell: "critest -c --runtime-endpoint /var/run/crio/crio.sock --image-endpoint /var/run/crio/crio.sock -s 'should not allow privilege escalation when true' v"
+  shell: "critest -c --runtime-endpoint /var/run/crio/crio.sock --image-endpoint /var/run/crio/crio.sock -s 'listImage should get exactly 2 repoTags in the result image|should not allow privilege escalation when true' v"
   args:
     chdir: "{{ ansible_env.GOPATH }}/src/github.com/kubernetes-incubator/cri-o"
   async: 5400

contrib/test/integration/e2e.yml

@@ -10,7 +10,7 @@
 - name: update the server address for the custom cluster
   lineinfile:
     dest: /usr/local/bin/createcluster.sh
-    line: "export {{ item }}={{ ansible_default_ipv4.address }}"
+    line: "export {{ item }}={{ ansible_eth0.ipv4.address }}"
     regexp: "^export {{ item }}="
     state: present
   with_items:
@@ -37,14 +37,13 @@
     path: "{{ artifacts }}"
     state: directory
 
-# TODO remove the last test skipped once https://github.com/kubernetes-incubator/cri-o/pull/1217 is merged
 - name: Buffer the e2e testing command to workaround Ansible YAML folding "feature"
   set_fact:
     e2e_shell_cmd: >
         /usr/bin/go run hack/e2e.go
             --test
             --test_args="-host=https://{{ ansible_default_ipv4.address }}:6443
-                        --ginkgo.skip=\[Slow\]|\[Serial\]|\[Disruptive\]|\[Flaky\]|\[Feature:.+\]|PersistentVolumes|\[HPA\]|should.support.building.a.client.with.a.CSR|should.support.inline.execution.and.attach
+                        --ginkgo.focus=\[Conformance\]
                         --report-dir={{ artifacts }}"
             &> {{ artifacts }}/e2e.log
   # Fix vim syntax hilighting: "

contrib/test/integration/main.yml

@@ -41,8 +41,6 @@
   tags:
     - integration
     - e2e
-    - node-e2e
-    - critest
   tasks:
     - name: clone build and install cri-o
       include: "build/cri-o.yml"
@@ -67,7 +65,7 @@
   vars_files:
     - "{{ playbook_dir }}/vars.yml"
   tags:
-    - critest
+    - e2e
   tasks:
     - name: install Golang tools
       include: golang.yml
@@ -80,46 +78,12 @@
           cri_tools_git_version: "a9e38a4a000bc1a4052fb33de1c967b8cfe9ad40"
     - name: run critest validation and benchmarks
       include: critest.yml
-
-- hosts: all
-  remote_user: root
-  vars_files:
-    - "{{ playbook_dir }}/vars.yml"
-  tags:
-    - node-e2e
-  tasks:
-    - name: install Golang tools
-      include: golang.yml
-      vars:
-          version: "1.9.2"
     - name: clone build and install kubernetes
       include: "build/kubernetes.yml"
       vars:
           force_clone: True
-          k8s_git_version: "master"
+          k8s_git_version: "release-1.9"
           k8s_github_fork: "kubernetes"
           crio_socket: "/var/run/crio/crio.sock"
-    - name: run k8s node-e2e tests
-      include: node-e2e.yml
-
-- hosts: all
-  remote_user: root
-  vars_files:
-    - "{{ playbook_dir }}/vars.yml"
-  tags:
-    - e2e
-  tasks:
-    - name: install Golang tools
-      include: golang.yml
-      vars:
-          version: "1.9.2"
-    - name: clone build and install kubernetes
-      include: "build/kubernetes.yml"
-      vars:
-          force_clone: True
-          # master as of 12/11/2017
-          k8s_git_version: "master-nfs-fix"
-          k8s_github_fork: "runcom"
-          crio_socket: "/var/run/crio/crio.sock"
     - name: run k8s e2e tests
       include: e2e.yml

contrib/test/integration/node-e2e.yml

@@ -1,26 +0,0 @@
----
-
-- name: enable and start CRI-O
-  systemd:
-    name: crio
-    state: started
-    enabled: yes
-    daemon_reload: yes
-
-- name: disable SELinux
-  command: setenforce 0
-
-- name: Flush the iptables
-  command: iptables -F
-
-- name: run node-e2e tests
-  shell: |
-    # parametrize crio socket
-    # cgroup-driver???
-    # TODO(runcom): remove conformance focus, we want everything for testgrid
-    make test-e2e-node PARALLELISM=1 RUNTIME=remote CONTAINER_RUNTIME_ENDPOINT=/var/run/crio.sock IMAGE_SERVICE_ENDPOINT=/var/run/crio/crio.sock TEST_ARGS='--prepull-images=true --kubelet-flags="--cgroup-driver=systemd"' FOCUS="\[Conformance\]" &> {{ artifacts }}/node-e2e.log
-  args:
-    chdir: "{{ ansible_env.GOPATH }}/src/k8s.io/kubernetes"
-  async: 7200
-  poll: 10
-  ignore_errors: true

contrib/test/integration/system.yml

@@ -5,7 +5,6 @@
     name: "{{ item }}"
     state: present
   with_items:
-    - atomic-registries
     - container-selinux
     - curl
     - device-mapper-devel
@@ -42,9 +41,9 @@
     - ostree-devel
     - pkgconfig
     - python
+    - python2-boto
     - python2-crypto
     - python-devel
-    - python-rhsm-certificates
     - python-virtualenv
     - PyYAML
     - redhat-rpm-config
@@ -58,22 +57,6 @@
   async: 600
   poll: 10
 
-- name: Add python2-boto for Fedora
-  package:
-    name: "{{ item }}"
-    state: present
-  with_items:
-   - python2-boto
-  when: ansible_distribution in ['Fedora']
-
-- name: Add python-boto for RHEL and CentOS
-  package:
-    name: "{{ item }}"
-    state: present
-  with_items:
-   - python-boto
-  when: ansible_distribution in ['RedHat', 'CentOS']
-
 - name: Add Btrfs for Fedora
   package:
     name: "{{ item }}"

hack/libdm_installed.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-cc -E - > /dev/null 2> /dev/null << EOF
-#include <libdevmapper.h>
-EOF
-if test $? -ne 0 ; then
-	echo exclude_graphdriver_devicemapper
-fi

hack/verify-gofmt.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+find_files() {
+  find . -not \( \
+      \( \
+        -wholename '*/vendor/*' \
+      \) -prune \
+    \) -name '*.go'
+}
+
+GOFMT="gofmt -s"
+bad_files=$(find_files | xargs $GOFMT -l)
+if [[ -n "${bad_files}" ]]; then
+  echo "!!! '$GOFMT' needs to be run on the following files: "
+  echo "${bad_files}"
+  exit 1
+fi

hooks.md

@@ -53,7 +53,6 @@ type HookParams struct {
 	Cmds          []string `json:"cmds"`
 	Annotations   []string `json:"annotations"`
 	HasBindMounts bool     `json:"hasbindmounts"`
-	Arguments     []string `json:"arguments"`
 }
 ```
 
@@ -64,7 +63,6 @@ type HookParams struct {
 | cmds   | List of regular expressions to match the command for running the container.  If the command matches a regex, the hook will be run  | Optional |
 | annotations | List of regular expressions to match against the Annotations in the container runtime spec, if an Annotation matches the hook will be run|optional |
 | hasbindmounts | Tells CRI-O to run the hook if the container has bind mounts from the host into the container | Optional |
-| arguments | Additional arguments to append to the hook command when executing it. For example --debug | Optional |
 
 ### Example
 
@@ -87,7 +85,6 @@ cat /etc/containers/oci/hooks.d/oci-systemd-hook.json
     "hasbindmounts": true,
     "hook": "/usr/libexec/oci/hooks.d/oci-umount",
     "stages": [ "prestart" ]
-    "arguments": [ "--debug" ]
 }
 ```
-In this example the oci-umount will only be run during the prestart phase if the container has volume/bind mounts from the host into the container, it will also execute oci-umount with the --debug argument.
+In this example the oci-umount will only be run during the prestart phase if the container has volume/bind mounts from the host into the container.

kubernetes.md

@@ -13,15 +13,17 @@ Below, you can find an instruction how to switch one or more nodes on running ku
 
 ### Preparing crio
 
-You must prepare and install `crio` on each node you would like to switch.
-Besides the files installed by `make install install.config`, here's the list of files that must be provided:
+You must prepare and install `crio` on each node you would like to switch. Here's the list of files that must be provided:
 
-| File path                                  | Description                 | Location                                                |
-|--------------------------------------------|-----------------------------|---------------------------------------------------------|
-| `/etc/containers/policy.json`              | containers policy           | [Example](test/policy.json) stored in cri-o repository  |
-| `/bin/runc`                                | `runc` or other OCI runtime | Can be build from sources `opencontainers/runc`         |
-| `/opt/cni/bin/{flannel, bridge,...}`       | CNI plugins binaries        | Can be built from sources `containernetworking/plugins` |
-| `/etc/cni/net.d/...`                       | CNI network config          | Example [here](contrib/cni)                             |
+| File path                                  | Description                | Location                                            |
+|--------------------------------------------|----------------------------|-----------------------------------------------------|
+| `/etc/crio/crio.conf`                      | crio configuration         | Generated on cri-o `make install`                   |
+| `/etc/crio/seccomp.conf`                   | seccomp config             | Example stored in cri-o repository                  |
+| `/etc/containers/policy.json`              | containers policy          | Example stored in cri-o repository                  |
+| `/bin/{crio, runc}`                        | `crio` and `runc` binaries | Built from cri-o repository                         |
+| `/usr/local/libexec/crio/conmon`           | `conmon` binary            | Built from cri-o repository                         |
+| `/opt/cni/bin/{flannel, bridge,...}`       | CNI plugins binaries       | Can be built from sources `containernetworking/cni` |
+| `/etc/cni/net.d/10-mynet.conf`             | Network config             | Example stored in [README file](README.md)          |
 
 `crio` binary can be executed directly on host, inside the container or in any way.
 However, recommended way is to set it as a systemd service.

lib/hooks.go

@@ -27,7 +27,6 @@ type HookParams struct {
 	Cmds          []string `json:"cmd"`
 	Annotations   []string `json:"annotation"`
 	HasBindMounts bool     `json:"hasbindmounts"`
-	Arguments     []string `json:"arguments"`
 }
 
 // readHook reads hooks json files, verifies it and returns the json config

pkg/storage/image.go

@@ -3,13 +3,12 @@ package storage
 import (
 	"errors"
 	"net"
-	"path"
+	"path/filepath"
 	"strings"
 
 	"github.com/containers/image/copy"
 	"github.com/containers/image/docker/reference"
 	"github.com/containers/image/image"
-	"github.com/containers/image/manifest"
 	"github.com/containers/image/signature"
 	istorage "github.com/containers/image/storage"
 	"github.com/containers/image/transports/alltransports"
@@ -18,26 +17,20 @@ import (
 	digest "github.com/opencontainers/go-digest"
 )
 
-const (
-	minimumTruncatedIDLength = 3
-)
-
 var (
 	// ErrCannotParseImageID is returned when we try to ResolveNames for an image ID
 	ErrCannotParseImageID = errors.New("cannot parse an image ID")
-	// ErrImageMultiplyTagged is returned when we try to remove an image that still has multiple names
-	ErrImageMultiplyTagged = errors.New("image still has multiple names applied")
 )
 
 // ImageResult wraps a subset of information about an image: its ID, its names,
 // and the size, if known, or nil if it isn't.
 type ImageResult struct {
-	ID           string
-	Name         string
-	RepoTags     []string
-	RepoDigests  []string
-	Size         *uint64
-	Digest       digest.Digest
+	ID    string
+	Names []string
+	Size  *uint64
+	// TODO(runcom): this is an hack for https://github.com/kubernetes-incubator/cri-o/pull/1136
+	// drop this when we have proper image IDs (as in, image IDs should be just
+	// the config blog digest which is stable across same images).
 	ConfigDigest digest.Digest
 }
 
@@ -54,11 +47,6 @@ type imageService struct {
 	registries            []string
 }
 
-// sizer knows its size.
-type sizer interface {
-	Size() (int64, error)
-}
-
 // ImageServer wraps up various CRI-related activities into a reusable
 // implementation.
 type ImageServer interface {
@@ -71,9 +59,6 @@ type ImageServer interface {
 	PrepareImage(systemContext *types.SystemContext, imageName string, options *copy.Options) (types.Image, error)
 	// PullImage imports an image from the specified location.
 	PullImage(systemContext *types.SystemContext, imageName string, options *copy.Options) (types.ImageReference, error)
-	// UntagImage removes a name from the specified image, and if it was
-	// the only name the image had, removes the image.
-	UntagImage(systemContext *types.SystemContext, imageName string) error
 	// RemoveImage deletes the specified image.
 	RemoveImage(systemContext *types.SystemContext, imageName string) error
 	// GetStore returns the reference to the storage library Store which
@@ -103,66 +88,6 @@ func (svc *imageService) getRef(name string) (types.ImageReference, error) {
 	return ref, nil
 }
 
-func sortNamesByType(names []string) (bestName string, tags, digests []string) {
-	for _, name := range names {
-		if len(name) > 72 && name[len(name)-72:len(name)-64] == "@sha256:" {
-			digests = append(digests, name)
-		} else {
-			tags = append(tags, name)
-		}
-	}
-	if len(digests) > 0 {
-		bestName = digests[0]
-	}
-	if len(tags) > 0 {
-		bestName = tags[0]
-	}
-	return bestName, tags, digests
-}
-
-func (svc *imageService) makeRepoDigests(knownRepoDigests, tags []string, imageID string) (imageDigest digest.Digest, repoDigests []string) {
-	// Look up the image's digest.
-	img, err := svc.store.Image(imageID)
-	if err != nil {
-		return "", knownRepoDigests
-	}
-	imageDigest = img.Digest
-	if imageDigest == "" {
-		imgDigest, err := svc.store.ImageBigDataDigest(imageID, storage.ImageDigestBigDataKey)
-		if err != nil || imgDigest == "" {
-			return "", knownRepoDigests
-		}
-		imageDigest = imgDigest
-	}
-	// If there are no names to convert to canonical references, we're done.
-	if len(tags) == 0 {
-		return imageDigest, knownRepoDigests
-	}
-	// We only want to supplement what's already explicitly in the list, so keep track of values
-	// that we already know.
-	digestMap := make(map[string]struct{})
-	repoDigests = knownRepoDigests
-	for _, repoDigest := range knownRepoDigests {
-		digestMap[repoDigest] = struct{}{}
-	}
-	// For each tagged name, parse the name, and if we can extract a named reference, convert
-	// it into a canonical reference using the digest and add it to the list.
-	for _, tag := range tags {
-		if ref, err2 := reference.ParseAnyReference(tag); err2 == nil {
-			if name, ok := ref.(reference.Named); ok {
-				trimmed := reference.TrimNamed(name)
-				if imageRef, err3 := reference.WithDigest(trimmed, imageDigest); err3 == nil {
-					if _, ok := digestMap[imageRef.String()]; !ok {
-						repoDigests = append(repoDigests, imageRef.String())
-						digestMap[imageRef.String()] = struct{}{}
-					}
-				}
-			}
-		}
-	}
-	return imageDigest, repoDigests
-}
-
 func (svc *imageService) ListImages(systemContext *types.SystemContext, filter string) ([]ImageResult, error) {
 	results := []ImageResult{}
 	if filter != "" {
@@ -171,26 +96,16 @@ func (svc *imageService) ListImages(systemContext *types.SystemContext, filter s
 			return nil, err
 		}
 		if image, err := istorage.Transport.GetStoreImage(svc.store, ref); err == nil {
-			img, err := ref.NewImageSource(systemContext)
+			img, err := ref.NewImage(systemContext)
 			if err != nil {
 				return nil, err
 			}
 			size := imageSize(img)
-			configDigest, err := imageConfigDigest(img, nil)
 			img.Close()
-			if err != nil {
-				return nil, err
-			}
-			name, tags, digests := sortNamesByType(image.Names)
-			imageDigest, repoDigests := svc.makeRepoDigests(digests, tags, image.ID)
 			results = append(results, ImageResult{
-				ID:           image.ID,
-				Name:         name,
-				RepoTags:     tags,
-				RepoDigests:  repoDigests,
-				Size:         size,
-				Digest:       imageDigest,
-				ConfigDigest: configDigest,
+				ID:    image.ID,
+				Names: image.Names,
+				Size:  size,
 			})
 		}
 	} else {
@@ -203,26 +118,16 @@ func (svc *imageService) ListImages(systemContext *types.SystemContext, filter s
 			if err != nil {
 				return nil, err
 			}
-			img, err := ref.NewImageSource(systemContext)
+			img, err := ref.NewImage(systemContext)
 			if err != nil {
 				return nil, err
 			}
 			size := imageSize(img)
-			configDigest, err := imageConfigDigest(img, nil)
 			img.Close()
-			if err != nil {
-				return nil, err
-			}
-			name, tags, digests := sortNamesByType(image.Names)
-			imageDigest, repoDigests := svc.makeRepoDigests(digests, tags, image.ID)
 			results = append(results, ImageResult{
-				ID:           image.ID,
-				Name:         name,
-				RepoTags:     tags,
-				RepoDigests:  repoDigests,
-				Size:         size,
-				Digest:       imageDigest,
-				ConfigDigest: configDigest,
+				ID:    image.ID,
+				Names: image.Names,
+				Size:  size,
 			})
 		}
 	}
@@ -247,54 +152,29 @@ func (svc *imageService) ImageStatus(systemContext *types.SystemContext, nameOrI
 		return nil, err
 	}
 
-	img, err := ref.NewImageSource(systemContext)
+	img, err := ref.NewImage(systemContext)
 	if err != nil {
 		return nil, err
 	}
 	defer img.Close()
 	size := imageSize(img)
-	configDigest, err := imageConfigDigest(img, nil)
-	if err != nil {
-		return nil, err
-	}
 
-	name, tags, digests := sortNamesByType(image.Names)
-	imageDigest, repoDigests := svc.makeRepoDigests(digests, tags, image.ID)
-	result := ImageResult{
+	return &ImageResult{
 		ID:           image.ID,
-		Name:         name,
-		RepoTags:     tags,
-		RepoDigests:  repoDigests,
+		Names:        image.Names,
 		Size:         size,
-		Digest:       imageDigest,
-		ConfigDigest: configDigest,
-	}
-
-	return &result, nil
+		ConfigDigest: img.ConfigInfo().Digest,
+	}, nil
 }
 
-func imageSize(img types.ImageSource) *uint64 {
-	if s, ok := img.(sizer); ok {
-		if sum, err := s.Size(); err == nil {
-			usum := uint64(sum)
-			return &usum
-		}
+func imageSize(img types.Image) *uint64 {
+	if sum, err := img.Size(); err == nil {
+		usum := uint64(sum)
+		return &usum
 	}
 	return nil
 }
 
-func imageConfigDigest(img types.ImageSource, instanceDigest *digest.Digest) (digest.Digest, error) {
-	manifestBytes, manifestType, err := img.GetManifest(instanceDigest)
-	if err != nil {
-		return "", err
-	}
-	imgManifest, err := manifest.FromBlob(manifestBytes, manifestType)
-	if err != nil {
-		return "", err
-	}
-	return imgManifest.ConfigInfo().Digest, nil
-}
-
 func (svc *imageService) CanPull(imageName string, options *copy.Options) (bool, error) {
 	srcRef, err := svc.prepareReference(imageName, options)
 	if err != nil {
@@ -304,11 +184,7 @@ func (svc *imageService) CanPull(imageName string, options *copy.Options) (bool,
 	if err != nil {
 		return false, err
 	}
-	sourceCtx := &types.SystemContext{}
-	if options.SourceCtx != nil {
-		sourceCtx = options.SourceCtx
-	}
-	src, err := image.FromSource(sourceCtx, rawSource)
+	src, err := image.FromSource(rawSource)
 	if err != nil {
 		rawSource.Close()
 		return false, err
@@ -398,57 +274,6 @@ func (svc *imageService) PullImage(systemContext *types.SystemContext, imageName
 	return destRef, nil
 }
 
-func (svc *imageService) UntagImage(systemContext *types.SystemContext, nameOrID string) error {
-	ref, err := alltransports.ParseImageName(nameOrID)
-	if err != nil {
-		ref2, err2 := istorage.Transport.ParseStoreReference(svc.store, "@"+nameOrID)
-		if err2 != nil {
-			ref3, err3 := istorage.Transport.ParseStoreReference(svc.store, nameOrID)
-			if err3 != nil {
-				return err
-			}
-			ref2 = ref3
-		}
-		ref = ref2
-	}
-
-	img, err := istorage.Transport.GetStoreImage(svc.store, ref)
-	if err != nil {
-		return err
-	}
-
-	if !strings.HasPrefix(img.ID, nameOrID) {
-		namedRef, err := svc.prepareReference(nameOrID, &copy.Options{})
-		if err != nil {
-			return err
-		}
-
-		name := nameOrID
-		if namedRef.DockerReference() != nil {
-			name = namedRef.DockerReference().Name()
-			if tagged, ok := namedRef.DockerReference().(reference.NamedTagged); ok {
-				name = name + ":" + tagged.Tag()
-			}
-			if canonical, ok := namedRef.DockerReference().(reference.Canonical); ok {
-				name = name + "@" + canonical.Digest().String()
-			}
-		}
-
-		prunedNames := make([]string, 0, len(img.Names))
-		for _, imgName := range img.Names {
-			if imgName != name && imgName != nameOrID {
-				prunedNames = append(prunedNames, imgName)
-			}
-		}
-
-		if len(prunedNames) > 0 {
-			return svc.store.SetNames(img.ID, prunedNames)
-		}
-	}
-
-	return ref.DeleteImage(systemContext)
-}
-
 func (svc *imageService) RemoveImage(systemContext *types.SystemContext, nameOrID string) error {
 	ref, err := alltransports.ParseImageName(nameOrID)
 	if err != nil {
@@ -516,14 +341,6 @@ func splitDockerDomain(name string) (domain, remainder string) {
 }
 
 func (svc *imageService) ResolveNames(imageName string) ([]string, error) {
-	// _Maybe_ it's a truncated image ID.  Don't prepend a registry name, then.
-	if len(imageName) >= minimumTruncatedIDLength && svc.store != nil {
-		if img, err := svc.store.Image(imageName); err == nil && img != nil && strings.HasPrefix(img.ID, imageName) {
-			// It's a truncated version of the ID of an image that's present in local storage;
-			// we need to expand it.
-			return []string{img.ID}, nil
-		}
-	}
 	// This to prevent any image ID to go through this routine
 	_, err := reference.ParseNormalizedNamed(imageName)
 	if err != nil {
@@ -551,7 +368,7 @@ func (svc *imageService) ResolveNames(imageName string) ([]string, error) {
 		if r == "docker.io" && !strings.ContainsRune(remainder, '/') {
 			rem = "library/" + rem
 		}
-		images = append(images, path.Join(r, rem))
+		images = append(images, filepath.Join(r, rem))
 	}
 	return images, nil
 }

server/container_create.go

@@ -14,6 +14,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/docker/distribution/reference"
 	dockermounts "github.com/docker/docker/pkg/mount"
 	"github.com/docker/docker/pkg/stringid"
 	"github.com/docker/docker/pkg/symlink"
@@ -426,18 +427,15 @@ func buildOCIProcessArgs(containerKubeConfig *pb.ContainerConfig, imageOCIConfig
 func addOCIHook(specgen *generate.Generator, hook lib.HookParams) error {
 	logrus.Debugf("AddOCIHook", hook)
 	for _, stage := range hook.Stage {
-		h := rspec.Hook{
-			Path: hook.Hook,
-			Args: append([]string{hook.Hook}, hook.Arguments...),
-			Env:  []string{fmt.Sprintf("stage=%s", stage)},
-		}
 		switch stage {
 		case "prestart":
-			specgen.AddPreStartHook(h)
+			specgen.AddPreStartHook(hook.Hook, []string{hook.Hook, "prestart"})
+
 		case "poststart":
-			specgen.AddPostStartHook(h)
+			specgen.AddPostStartHook(hook.Hook, []string{hook.Hook, "poststart"})
+
 		case "poststop":
-			specgen.AddPostStopHook(h)
+			specgen.AddPostStopHook(hook.Hook, []string{hook.Hook, "poststop"})
 		}
 	}
 	return nil
@@ -490,110 +488,6 @@ func setupContainerUser(specgen *generate.Generator, rootfs string, sc *pb.Linux
 	return nil
 }
 
-// setupCapabilities sets process.capabilities in the OCI runtime config.
-func setupCapabilities(specgen *generate.Generator, capabilities *pb.Capability) error {
-	if capabilities == nil {
-		return nil
-	}
-
-	toCAPPrefixed := func(cap string) string {
-		if !strings.HasPrefix(strings.ToLower(cap), "cap_") {
-			return "CAP_" + strings.ToUpper(cap)
-		}
-		return cap
-	}
-
-	// Add/drop all capabilities if "all" is specified, so that
-	// following individual add/drop could still work. E.g.
-	// AddCapabilities: []string{"ALL"}, DropCapabilities: []string{"CHOWN"}
-	// will be all capabilities without `CAP_CHOWN`.
-	// see https://github.com/kubernetes/kubernetes/issues/51980
-	if inStringSlice(capabilities.GetAddCapabilities(), "ALL") {
-		for _, c := range getOCICapabilitiesList() {
-			if err := specgen.AddProcessCapabilityAmbient(c); err != nil {
-				return err
-			}
-			if err := specgen.AddProcessCapabilityBounding(c); err != nil {
-				return err
-			}
-			if err := specgen.AddProcessCapabilityEffective(c); err != nil {
-				return err
-			}
-			if err := specgen.AddProcessCapabilityInheritable(c); err != nil {
-				return err
-			}
-			if err := specgen.AddProcessCapabilityPermitted(c); err != nil {
-				return err
-			}
-		}
-	}
-	if inStringSlice(capabilities.GetDropCapabilities(), "ALL") {
-		for _, c := range getOCICapabilitiesList() {
-			if err := specgen.DropProcessCapabilityAmbient(c); err != nil {
-				return err
-			}
-			if err := specgen.DropProcessCapabilityBounding(c); err != nil {
-				return err
-			}
-			if err := specgen.DropProcessCapabilityEffective(c); err != nil {
-				return err
-			}
-			if err := specgen.DropProcessCapabilityInheritable(c); err != nil {
-				return err
-			}
-			if err := specgen.DropProcessCapabilityPermitted(c); err != nil {
-				return err
-			}
-		}
-	}
-
-	for _, cap := range capabilities.GetAddCapabilities() {
-		if strings.ToUpper(cap) == "ALL" {
-			continue
-		}
-		capPrefixed := toCAPPrefixed(cap)
-		if err := specgen.AddProcessCapabilityAmbient(capPrefixed); err != nil {
-			return err
-		}
-		if err := specgen.AddProcessCapabilityBounding(capPrefixed); err != nil {
-			return err
-		}
-		if err := specgen.AddProcessCapabilityEffective(capPrefixed); err != nil {
-			return err
-		}
-		if err := specgen.AddProcessCapabilityInheritable(capPrefixed); err != nil {
-			return err
-		}
-		if err := specgen.AddProcessCapabilityPermitted(capPrefixed); err != nil {
-			return err
-		}
-	}
-
-	for _, cap := range capabilities.GetDropCapabilities() {
-		if strings.ToUpper(cap) == "ALL" {
-			continue
-		}
-		capPrefixed := toCAPPrefixed(cap)
-		if err := specgen.DropProcessCapabilityAmbient(capPrefixed); err != nil {
-			return fmt.Errorf("failed to drop cap %s %v", capPrefixed, err)
-		}
-		if err := specgen.DropProcessCapabilityBounding(capPrefixed); err != nil {
-			return fmt.Errorf("failed to drop cap %s %v", capPrefixed, err)
-		}
-		if err := specgen.DropProcessCapabilityEffective(capPrefixed); err != nil {
-			return fmt.Errorf("failed to drop cap %s %v", capPrefixed, err)
-		}
-		if err := specgen.DropProcessCapabilityInheritable(capPrefixed); err != nil {
-			return fmt.Errorf("failed to drop cap %s %v", capPrefixed, err)
-		}
-		if err := specgen.DropProcessCapabilityPermitted(capPrefixed); err != nil {
-			return fmt.Errorf("failed to drop cap %s %v", capPrefixed, err)
-		}
-	}
-
-	return nil
-}
-
 func hostNetwork(containerConfig *pb.ContainerConfig) bool {
 	securityContext := containerConfig.GetLinux().GetSecurityContext()
 	if securityContext == nil || securityContext.GetNamespaceOptions() == nil {
@@ -669,11 +563,7 @@ func (s *Server) CreateContainer(ctx context.Context, req *pb.CreateContainerReq
 		return nil, fmt.Errorf("CreateContainerRequest.ContainerConfig is nil")
 	}
 
-	if containerConfig.GetMetadata() == nil {
-		return nil, fmt.Errorf("CreateContainerRequest.ContainerConfig.Metadata is nil")
-	}
-
-	name := containerConfig.GetMetadata().GetName()
+	name := containerConfig.GetMetadata().Name
 	if name == "" {
 		return nil, fmt.Errorf("CreateContainerRequest.ContainerConfig.Name is empty")
 	}
@@ -821,14 +711,8 @@ func (s *Server) createSandboxContainer(ctx context.Context, containerID string,
 	}
 	specgen.AddAnnotation(annotations.Volumes, string(volumesJSON))
 
-	mnt := rspec.Mount{
-		Destination: "/sys/fs/cgroup",
-		Type:        "cgroup",
-		Source:      "cgroup",
-		Options:     []string{"nosuid", "noexec", "nodev", "relatime", "ro"},
-	}
 	// Add cgroup mount so container process can introspect its own limits
-	specgen.AddMount(mnt)
+	specgen.AddCgroupsMount("ro")
 
 	if err := addDevices(sb, containerConfig, &specgen); err != nil {
 		return nil, err
@@ -902,13 +786,28 @@ func (s *Server) createSandboxContainer(ctx context.Context, containerID string,
 	if linux != nil {
 		resources := linux.GetResources()
 		if resources != nil {
-			specgen.SetLinuxResourcesCPUPeriod(uint64(resources.GetCpuPeriod()))
-			specgen.SetLinuxResourcesCPUQuota(resources.GetCpuQuota())
-			specgen.SetLinuxResourcesCPUShares(uint64(resources.GetCpuShares()))
-			specgen.SetLinuxResourcesMemoryLimit(resources.GetMemoryLimitInBytes())
-			specgen.SetProcessOOMScoreAdj(int(resources.GetOomScoreAdj()))
-			specgen.SetLinuxResourcesCPUCpus(resources.GetCpusetCpus())
-			specgen.SetLinuxResourcesCPUMems(resources.GetCpusetMems())
+			cpuPeriod := resources.CpuPeriod
+			if cpuPeriod != 0 {
+				specgen.SetLinuxResourcesCPUPeriod(uint64(cpuPeriod))
+			}
+
+			cpuQuota := resources.CpuQuota
+			if cpuQuota != 0 {
+				specgen.SetLinuxResourcesCPUQuota(cpuQuota)
+			}
+
+			cpuShares := resources.CpuShares
+			if cpuShares != 0 {
+				specgen.SetLinuxResourcesCPUShares(uint64(cpuShares))
+			}
+
+			memoryLimit := resources.MemoryLimitInBytes
+			if memoryLimit != 0 {
+				specgen.SetLinuxResourcesMemoryLimit(memoryLimit)
+			}
+
+			oomScoreAdj := resources.OomScoreAdj
+			specgen.SetProcessOOMScoreAdj(int(oomScoreAdj))
 		}
 
 		var cgPath string
@@ -927,13 +826,57 @@ func (s *Server) createSandboxContainer(ctx context.Context, containerID string,
 		}
 		specgen.SetLinuxCgroupsPath(cgPath)
 
+		capabilities := linux.GetSecurityContext().GetCapabilities()
 		if privileged {
+			// this is setting correct capabilities as well for privileged mode
 			specgen.SetupPrivileged(true)
 			setOCIBindMountsPrivileged(&specgen)
 		} else {
-			err = setupCapabilities(&specgen, linux.GetSecurityContext().GetCapabilities())
-			if err != nil {
-				return nil, err
+			toCAPPrefixed := func(cap string) string {
+				if !strings.HasPrefix(strings.ToLower(cap), "cap_") {
+					return "CAP_" + strings.ToUpper(cap)
+				}
+				return cap
+			}
+
+			// Add/drop all capabilities if "all" is specified, so that
+			// following individual add/drop could still work. E.g.
+			// AddCapabilities: []string{"ALL"}, DropCapabilities: []string{"CHOWN"}
+			// will be all capabilities without `CAP_CHOWN`.
+			// see https://github.com/kubernetes/kubernetes/issues/51980
+			if inStringSlice(capabilities.GetAddCapabilities(), "ALL") {
+				for _, c := range getOCICapabilitiesList() {
+					if err := specgen.AddProcessCapability(c); err != nil {
+						return nil, err
+					}
+				}
+			}
+			if inStringSlice(capabilities.GetDropCapabilities(), "ALL") {
+				for _, c := range getOCICapabilitiesList() {
+					if err := specgen.DropProcessCapability(c); err != nil {
+						return nil, err
+					}
+				}
+			}
+
+			if capabilities != nil {
+				for _, cap := range capabilities.GetAddCapabilities() {
+					if strings.ToUpper(cap) == "ALL" {
+						continue
+					}
+					if err := specgen.AddProcessCapability(toCAPPrefixed(cap)); err != nil {
+						return nil, err
+					}
+				}
+
+				for _, cap := range capabilities.GetDropCapabilities() {
+					if strings.ToUpper(cap) == "ALL" {
+						continue
+					}
+					if err := specgen.DropProcessCapability(toCAPPrefixed(cap)); err != nil {
+						return nil, fmt.Errorf("failed to drop cap %s %v", toCAPPrefixed(cap), err)
+					}
+				}
 			}
 		}
 		specgen.SetProcessSelinuxLabel(processLabel)
@@ -1020,31 +963,46 @@ func (s *Server) createSandboxContainer(ctx context.Context, containerID string,
 			return nil, err
 		}
 	}
+	image = images[0]
 
-	// Get imageName and imageRef that are later requested in container status
-	status, err := s.StorageImageServer().ImageStatus(s.ImageContext(), images[0])
+	// Get imageName and imageRef that are requested in container status
+	imageName := image
+	status, err := s.StorageImageServer().ImageStatus(s.ImageContext(), image)
 	if err != nil {
 		return nil, err
 	}
-	imageName := status.Name
+
 	imageRef := status.ID
-	if len(status.RepoDigests) > 0 {
-		imageRef = status.RepoDigests[0]
+	//
+	// TODO: https://github.com/kubernetes-incubator/cri-o/issues/531
+	//
+	//for _, n := range status.Names {
+	//r, err := reference.ParseNormalizedNamed(n)
+	//if err != nil {
+	//return nil, fmt.Errorf("failed to normalize image name for ImageRef: %v", err)
+	//}
+	//if digested, isDigested := r.(reference.Canonical); isDigested {
+	//imageRef = reference.FamiliarString(digested)
+	//break
+	//}
+	//}
+	for _, n := range status.Names {
+		r, err := reference.ParseNormalizedNamed(n)
+		if err != nil {
+			return nil, fmt.Errorf("failed to normalize image name for Image: %v", err)
+		}
+		if tagged, isTagged := r.(reference.Tagged); isTagged {
+			imageName = reference.FamiliarString(tagged)
+			break
+		}
 	}
 
-	specgen.AddAnnotation(annotations.Image, image)
 	specgen.AddAnnotation(annotations.ImageName, imageName)
 	specgen.AddAnnotation(annotations.ImageRef, imageRef)
 	specgen.AddAnnotation(annotations.IP, sb.IP())
 
-	mnt = rspec.Mount{
-		Type:        "bind",
-		Source:      sb.ShmPath(),
-		Destination: "/etc/shm",
-		Options:     []string{"rw", "bind"},
-	}
 	// bind mount the pod shm
-	specgen.AddMount(mnt)
+	specgen.AddBindMount(sb.ShmPath(), "/dev/shm", []string{"rw"})
 
 	options := []string{"rw"}
 	if readOnlyRootfs {
@@ -1055,14 +1013,8 @@ func (s *Server) createSandboxContainer(ctx context.Context, containerID string,
 			return nil, err
 		}
 
-		mnt = rspec.Mount{
-			Type:        "bind",
-			Source:      sb.ResolvPath(),
-			Destination: "/etc/resolv.conf",
-			Options:     append(options, "bind"),
-		}
 		// bind mount the pod resolver file
-		specgen.AddMount(mnt)
+		specgen.AddBindMount(sb.ResolvPath(), "/etc/resolv.conf", options)
 	}
 
 	if sb.HostnamePath() != "" {
@@ -1070,24 +1022,12 @@ func (s *Server) createSandboxContainer(ctx context.Context, containerID string,
 			return nil, err
 		}
 
-		mnt = rspec.Mount{
-			Type:        "bind",
-			Source:      sb.HostnamePath(),
-			Destination: "/etc/hostname",
-			Options:     append(options, "bind"),
-		}
-		specgen.AddMount(mnt)
+		specgen.AddBindMount(sb.HostnamePath(), "/etc/hostname", options)
 	}
 
 	// Bind mount /etc/hosts for host networking containers
 	if hostNetwork(containerConfig) {
-		mnt = rspec.Mount{
-			Type:        "bind",
-			Source:      "/etc/hosts",
-			Destination: "/etc/hosts",
-			Options:     append(options, "bind"),
-		}
-		specgen.AddMount(mnt)
+		specgen.AddBindMount("/etc/hosts", "/etc/hosts", options)
 	}
 
 	// Set hostname and add env for hostname
@@ -1103,6 +1043,7 @@ func (s *Server) createSandboxContainer(ctx context.Context, containerID string,
 	specgen.AddAnnotation(annotations.TTY, fmt.Sprintf("%v", containerConfig.Tty))
 	specgen.AddAnnotation(annotations.Stdin, fmt.Sprintf("%v", containerConfig.Stdin))
 	specgen.AddAnnotation(annotations.StdinOnce, fmt.Sprintf("%v", containerConfig.StdinOnce))
+	specgen.AddAnnotation(annotations.Image, image)
 	specgen.AddAnnotation(annotations.ResolvPath, sb.InfraContainer().CrioAnnotations()[annotations.ResolvPath])
 
 	created := time.Now()
@@ -1138,7 +1079,7 @@ func (s *Server) createSandboxContainer(ctx context.Context, containerID string,
 	attempt := metadata.Attempt
 	containerInfo, err := s.StorageRuntimeServer().CreateContainer(s.ImageContext(),
 		sb.Name(), sb.ID(),
-		image, status.ID,
+		image, image,
 		containerName, containerID,
 		metaname,
 		attempt,
@@ -1147,14 +1088,6 @@ func (s *Server) createSandboxContainer(ctx context.Context, containerID string,
 	if err != nil {
 		return nil, err
 	}
-	defer func() {
-		if err != nil {
-			err2 := s.StorageRuntimeServer().DeleteContainer(containerInfo.ID)
-			if err2 != nil {
-				logrus.Warnf("Failed to cleanup container directory: %v", err2)
-			}
-		}
-	}()
 
 	mountPoint, err := s.StorageRuntimeServer().StartContainer(containerID)
 	if err != nil {
@@ -1164,8 +1097,7 @@ func (s *Server) createSandboxContainer(ctx context.Context, containerID string,
 
 	containerImageConfig := containerInfo.Config
 	if containerImageConfig == nil {
-		err = fmt.Errorf("empty image config for %s", image)
-		return nil, err
+		return nil, fmt.Errorf("empty image config for %s", image)
 	}
 
 	if containerImageConfig.Config.StopSignal != "" {
@@ -1229,13 +1161,7 @@ func (s *Server) createSandboxContainer(ctx context.Context, containerID string,
 	sort.Sort(orderedMounts(mounts))
 
 	for _, m := range mounts {
-		mnt = rspec.Mount{
-			Type:        "bind",
-			Source:      m.Source,
-			Destination: m.Destination,
-			Options:     append(m.Options, "bind"),
-		}
-		specgen.AddMount(mnt)
+		specgen.AddBindMount(m.Source, m.Destination, m.Options)
 	}
 
 	if err := s.setupOCIHooks(&specgen, sb, containerConfig, processArgs[0]); err != nil {

server/container_list.go

@@ -97,7 +97,6 @@ func (s *Server) ListContainers(ctx context.Context, req *pb.ListContainersReque
 			Metadata:     ctr.Metadata(),
 			Annotations:  ctr.Annotations(),
 			Image:        img,
-			ImageRef:     ctr.ImageRef(),
 		}
 
 		switch cState.Status {

server/container_status.go

@@ -3,7 +3,6 @@ package server
 import (
 	"time"
 
-	"github.com/containers/image/types"
 	"github.com/kubernetes-incubator/cri-o/oci"
 	"github.com/sirupsen/logrus"
 	"golang.org/x/net/context"
@@ -39,10 +38,7 @@ func (s *Server) ContainerStatus(ctx context.Context, req *pb.ContainerStatusReq
 			ImageRef:    c.ImageRef(),
 		},
 	}
-	resp.Status.Image = &pb.ImageSpec{Image: c.Image()}
-	if status, err := s.StorageImageServer().ImageStatus(&types.SystemContext{}, c.ImageRef()); err == nil {
-		resp.Status.Image.Image = status.Name
-	}
+	resp.Status.Image = &pb.ImageSpec{Image: c.ImageName()}
 
 	mounts := []*pb.Mount{}
 	for _, cv := range c.Volumes() {

server/image_list.go

@@ -33,16 +33,14 @@ func (s *Server) ListImages(ctx context.Context, req *pb.ListImagesRequest) (res
 	for _, result := range results {
 		if result.Size != nil {
 			resp.Images = append(resp.Images, &pb.Image{
-				Id:          result.ID,
-				RepoTags:    result.RepoTags,
-				RepoDigests: result.RepoDigests,
-				Size_:       *result.Size,
+				Id:       result.ID,
+				RepoTags: result.Names,
+				Size_:    *result.Size,
 			})
 		} else {
 			resp.Images = append(resp.Images, &pb.Image{
-				Id:          result.ID,
-				RepoTags:    result.RepoTags,
-				RepoDigests: result.RepoDigests,
+				Id:       result.ID,
+				RepoTags: result.Names,
 			})
 		}
 	}

server/image_pull.go

@@ -104,16 +104,8 @@ func (s *Server) PullImage(ctx context.Context, req *pb.PullImageRequest) (resp
 	if pulled == "" && err != nil {
 		return nil, err
 	}
-	status, err := s.StorageImageServer().ImageStatus(s.ImageContext(), pulled)
-	if err != nil {
-		return nil, err
-	}
-	imageRef := status.ID
-	if len(status.RepoDigests) > 0 {
-		imageRef = status.RepoDigests[0]
-	}
 	resp = &pb.PullImageResponse{
-		ImageRef: imageRef,
+		ImageRef: pulled,
 	}
 	logrus.Debugf("PullImageResponse: %+v", resp)
 	return resp, nil

server/image_remove.go

@@ -40,7 +40,7 @@ func (s *Server) RemoveImage(ctx context.Context, req *pb.RemoveImageRequest) (r
 		}
 	}
 	for _, img := range images {
-		err = s.StorageImageServer().UntagImage(s.ImageContext(), img)
+		err = s.StorageImageServer().RemoveImage(s.ImageContext(), img)
 		if err != nil {
 			logrus.Debugf("error deleting image %s: %v", img, err)
 			continue

server/image_status.go

@@ -48,10 +48,10 @@ func (s *Server) ImageStatus(ctx context.Context, req *pb.ImageStatusRequest) (r
 	}
 	resp = &pb.ImageStatusResponse{
 		Image: &pb.Image{
-			Id:          status.ID,
-			RepoTags:    status.RepoTags,
-			RepoDigests: status.RepoDigests,
-			Size_:       *status.Size,
+			Id:       status.ID,
+			RepoTags: status.Names,
+			Size_:    *status.Size,
+			// TODO: https://github.com/kubernetes-incubator/cri-o/issues/531
 		},
 	}
 	logrus.Debugf("ImageStatusResponse: %+v", resp)

server/inspect.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"net/http"
 
-	cimage "github.com/containers/image/types"
 	"github.com/go-zoo/bone"
 	"github.com/kubernetes-incubator/cri-o/lib/sandbox"
 	"github.com/kubernetes-incubator/cri-o/oci"
@@ -46,17 +45,10 @@ func (s *Server) getContainerInfo(id string, getContainerFunc func(id string) *o
 		logrus.Debugf("can't find sandbox %s for container %s", ctr.Sandbox(), id)
 		return types.ContainerInfo{}, errSandboxNotFound
 	}
-	image := ctr.Image()
-	if s.ContainerServer != nil && s.ContainerServer.StorageImageServer() != nil {
-		if status, err := s.ContainerServer.StorageImageServer().ImageStatus(&cimage.SystemContext{}, ctr.ImageRef()); err == nil {
-			image = status.Name
-		}
-	}
 	return types.ContainerInfo{
 		Name:            ctr.Name(),
 		Pid:             ctrState.Pid,
-		Image:           image,
-		ImageRef:        ctr.ImageRef(),
+		Image:           ctr.ImageName(),
 		CreatedTime:     ctrState.Created.UnixNano(),
 		Labels:          ctr.Labels(),
 		Annotations:     ctr.Annotations(),

server/inspect_test.go

@@ -67,7 +67,7 @@ func TestGetContainerInfo(t *testing.T) {
 		"io.kubernetes.test1": "value1",
 	}
 	getContainerFunc := func(id string) *oci.Container {
-		container, err := oci.NewContainer("testid", "testname", "", "/container/logs", mockNetNS{}, labels, annotations, annotations, "image", "imageName", "imageRef", &runtime.ContainerMetadata{}, "testsandboxid", false, false, false, false, false, "/root/for/container", created, "SIGKILL")
+		container, err := oci.NewContainer("testid", "testname", "", "/container/logs", mockNetNS{}, labels, annotations, annotations, "imageName", "imageName", "imageRef", &runtime.ContainerMetadata{}, "testsandboxid", false, false, false, false, false, "/root/for/container", created, "SIGKILL")
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -101,11 +101,8 @@ func TestGetContainerInfo(t *testing.T) {
 	if ci.Name != "testname" {
 		t.Fatalf("expected name testname, got %s", ci.Name)
 	}
-	if ci.Image != "image" {
-		t.Fatalf("expected image name image, got %s", ci.Image)
-	}
-	if ci.ImageRef != "imageRef" {
-		t.Fatalf("expected image ref imageRef, got %s", ci.ImageRef)
+	if ci.Image != "imageName" {
+		t.Fatalf("expected image name imageName, got %s", ci.Image)
 	}
 	if ci.Root != "/var/foo/container" {
 		t.Fatalf("expected root to be /var/foo/container, got %s", ci.Root)

server/sandbox_run.go

@@ -101,20 +101,16 @@ func (s *Server) RunPodSandbox(ctx context.Context, req *pb.RunPodSandboxRequest
 	s.updateLock.RLock()
 	defer s.updateLock.RUnlock()
 
-	if req.GetConfig().GetMetadata() == nil {
-		return nil, fmt.Errorf("CreateContainerRequest.ContainerConfig.Metadata is nil")
-	}
-
 	logrus.Debugf("RunPodSandboxRequest %+v", req)
 	var processLabel, mountLabel, resolvPath string
 	// process req.Name
-	kubeName := req.GetConfig().GetMetadata().GetName()
+	kubeName := req.GetConfig().GetMetadata().Name
 	if kubeName == "" {
 		return nil, fmt.Errorf("PodSandboxConfig.Name should not be empty")
 	}
 
-	namespace := req.GetConfig().GetMetadata().GetNamespace()
-	attempt := req.GetConfig().GetMetadata().GetAttempt()
+	namespace := req.GetConfig().GetMetadata().Namespace
+	attempt := req.GetConfig().GetMetadata().Attempt
 
 	id, name, err := s.generatePodIDandName(req.GetConfig())
 	if err != nil {
@@ -160,8 +156,8 @@ func (s *Server) RunPodSandbox(ctx context.Context, req *pb.RunPodSandboxRequest
 		name, id,
 		s.config.PauseImage, "",
 		containerName,
-		req.GetConfig().GetMetadata().GetName(),
-		req.GetConfig().GetMetadata().GetUid(),
+		req.GetConfig().GetMetadata().Name,
+		req.GetConfig().GetMetadata().Uid,
 		namespace,
 		attempt,
 		nil)
@@ -214,13 +210,8 @@ func (s *Server) RunPodSandbox(ctx context.Context, req *pb.RunPodSandboxRequest
 		if err := label.Relabel(resolvPath, mountLabel, true); err != nil && err != unix.ENOTSUP {
 			return nil, err
 		}
-		mnt := runtimespec.Mount{
-			Type:        "bind",
-			Source:      resolvPath,
-			Destination: "/etc/resolv.conf",
-			Options:     []string{"ro", "bind"},
-		}
-		g.AddMount(mnt)
+
+		g.AddBindMount(resolvPath, "/etc/resolv.conf", []string{"ro"})
 	}
 
 	// add metadata
@@ -489,13 +480,7 @@ func (s *Server) RunPodSandbox(ctx context.Context, req *pb.RunPodSandboxRequest
 	if err := label.Relabel(hostnamePath, mountLabel, true); err != nil && err != unix.ENOTSUP {
 		return nil, err
 	}
-	mnt := runtimespec.Mount{
-		Type:        "bind",
-		Source:      hostnamePath,
-		Destination: "/etc/hostname",
-		Options:     []string{"ro", "bind"},
-	}
-	g.AddMount(mnt)
+	g.AddBindMount(hostnamePath, "/etc/hostname", []string{"ro"})
 	g.AddAnnotation(annotations.HostnamePath, hostnamePath)
 	sb.AddHostnamePath(hostnamePath)
 

test/README.md

@@ -41,12 +41,11 @@ You will also need to install the [CNI](https://github.com/containernetworking/c
 the the default pod test template runs without host networking:
 
 ```
-$ cd "$GOPATH/src/github.com/containernetworking"
-$ git clone https://github.com/containernetworking/plugins.git
-$ cd plugins
-$ git checkout -q dcf7368eeab15e2affc6256f0bb1e84dd46a34de
-$ ./build.sh
-$ mkdir -p /opt/cni/bin
+$ go get github.com/containernetworking/cni
+$ cd "$GOPATH/src/github.com/containernetworking/cni"
+$ git checkout -q d4bbce1865270cd2d2be558d6a23e63d314fe769
+$ ./build.sh \
+$ mkdir -p /opt/cni/bin \
 $ cp bin/* /opt/cni/bin/
 ```
 
@@ -70,11 +69,11 @@ Tests on the host will run with `runc` as the default runtime.
 However you can select other OCI compatible runtimes by setting
 the `RUNTIME` environment variable.
 
-For example one could use the [Clear Containers](https://github.com/clearcontainers/runtime)
+For example one could use the [Clear Containers](https://github.com/01org/cc-oci-runtime/wiki/Installation)
 runtime instead of `runc`:
 
 ```
-make localintegration RUNTIME=cc-runtime
+make localintegration RUNTIME=cc-oci-runtime
 ```
 
 ## Writing integration tests

test/ctr.bats

@@ -1061,31 +1061,3 @@ function teardown() {
 	cleanup_pods
 	stop_crio
 }
-
-@test "ctr resources" {
-	start_crio
-	run crictl runs "$TESTDATA"/sandbox_config.json
-	echo "$output"
-	[ "$status" -eq 0 ]
-	pod_id="$output"
-	run crictl create "$pod_id" "$TESTDATA"/container_redis.json "$TESTDATA"/sandbox_config.json
-	echo "$output"
-	[ "$status" -eq 0 ]
-	ctr_id="$output"
-	run crictl start "$ctr_id"
-	echo "$output"
-	[ "$status" -eq 0 ]
-
-	run crictl exec --sync "$ctr_id" sh -c "cat /sys/fs/cgroup/cpuset/cpuset.cpus"
-	echo "$output"
-	[ "$status" -eq 0 ]
-	[[ "$output" =~ "0-1" ]]
-	run crictl exec --sync "$ctr_id" sh -c "cat /sys/fs/cgroup/cpuset/cpuset.mems"
-	echo "$output"
-	[ "$status" -eq 0 ]
-	[[ "$output" =~ "0" ]]
-
-	cleanup_ctrs
-	cleanup_pods
-	stop_crio
-}

test/helpers.bash

@@ -103,7 +103,7 @@ cp "$CONMON_BINARY" "$TESTDIR/conmon"
 
 PATH=$PATH:$TESTDIR
 
-# Make sure we have a copy of the redis:alpine image.
+# Make sure we have a copy of the redis:latest image.
 if ! [ -d "$ARTIFACTS_PATH"/redis-image ]; then
     mkdir -p "$ARTIFACTS_PATH"/redis-image
     if ! "$COPYIMG_BINARY" --import-from=docker://redis:alpine --export-to=dir:"$ARTIFACTS_PATH"/redis-image --signature-policy="$INTEGRATION_ROOT"/policy.json ; then
@@ -113,6 +113,19 @@ if ! [ -d "$ARTIFACTS_PATH"/redis-image ]; then
     fi
 fi
 
+# TODO: remove the code below for redis digested image id when
+#       https://github.com/kubernetes-incubator/cri-o/issues/531 is complete
+#       as the digested reference will be auto-stored when pulling the tag
+#       above
+if ! [ -d "$ARTIFACTS_PATH"/redis-image-digest ]; then
+    mkdir -p "$ARTIFACTS_PATH"/redis-image-digest
+    if ! "$COPYIMG_BINARY" --import-from=docker://redis@sha256:03789f402b2ecfb98184bf128d180f398f81c63364948ff1454583b02442f73b --export-to=dir:"$ARTIFACTS_PATH"/redis-image-digest --signature-policy="$INTEGRATION_ROOT"/policy.json ; then
+        echo "Error pulling docker://redis@sha256:03789f402b2ecfb98184bf128d180f398f81c63364948ff1454583b02442f73b"
+        rm -fr "$ARTIFACTS_PATH"/redis-image-digest
+        exit 1
+    fi
+fi
+
 # Make sure we have a copy of the runcom/stderr-test image.
 if ! [ -d "$ARTIFACTS_PATH"/stderr-test ]; then
     mkdir -p "$ARTIFACTS_PATH"/stderr-test
@@ -212,11 +225,16 @@ function start_crio() {
 	if ! [ "$3" = "--no-pause-image" ] ; then
 		"$BIN2IMG_BINARY" --root "$TESTDIR/crio" $STORAGE_OPTIONS --runroot "$TESTDIR/crio-run" --source-binary "$PAUSE_BINARY"
 	fi
-	"$COPYIMG_BINARY" --root "$TESTDIR/crio" $STORAGE_OPTIONS --runroot "$TESTDIR/crio-run" --image-name=docker.io/library/redis:alpine --import-from=dir:"$ARTIFACTS_PATH"/redis-image --signature-policy="$INTEGRATION_ROOT"/policy.json
-	"$COPYIMG_BINARY" --root "$TESTDIR/crio" $STORAGE_OPTIONS --runroot "$TESTDIR/crio-run" --image-name=docker.io/mrunalp/oom:latest --import-from=dir:"$ARTIFACTS_PATH"/oom-image --signature-policy="$INTEGRATION_ROOT"/policy.json
-	"$COPYIMG_BINARY" --root "$TESTDIR/crio" $STORAGE_OPTIONS --runroot "$TESTDIR/crio-run" --image-name=docker.io/mrunalp/image-volume-test:latest --import-from=dir:"$ARTIFACTS_PATH"/image-volume-test-image --signature-policy="$INTEGRATION_ROOT"/policy.json
-	"$COPYIMG_BINARY" --root "$TESTDIR/crio" $STORAGE_OPTIONS --runroot "$TESTDIR/crio-run" --image-name=docker.io/library/busybox:latest --import-from=dir:"$ARTIFACTS_PATH"/busybox-image --signature-policy="$INTEGRATION_ROOT"/policy.json
-	"$COPYIMG_BINARY" --root "$TESTDIR/crio" $STORAGE_OPTIONS --runroot "$TESTDIR/crio-run" --image-name=docker.io/runcom/stderr-test:latest --import-from=dir:"$ARTIFACTS_PATH"/stderr-test --signature-policy="$INTEGRATION_ROOT"/policy.json
+	"$COPYIMG_BINARY" --root "$TESTDIR/crio" $STORAGE_OPTIONS --runroot "$TESTDIR/crio-run" --image-name=redis:alpine --import-from=dir:"$ARTIFACTS_PATH"/redis-image --add-name=docker.io/library/redis:alpine --signature-policy="$INTEGRATION_ROOT"/policy.json
+# TODO: remove the code below for redis:alpine digested image id when
+#       https://github.com/kubernetes-incubator/cri-o/issues/531 is complete
+#       as the digested reference will be auto-stored when pulling the tag
+#       above
+	"$COPYIMG_BINARY" --root "$TESTDIR/crio" $STORAGE_OPTIONS --runroot "$TESTDIR/crio-run" --image-name=redis@sha256:03789f402b2ecfb98184bf128d180f398f81c63364948ff1454583b02442f73b --import-from=dir:"$ARTIFACTS_PATH"/redis-image-digest --add-name=docker.io/library/redis@sha256:03789f402b2ecfb98184bf128d180f398f81c63364948ff1454583b02442f73b --signature-policy="$INTEGRATION_ROOT"/policy.json
+	"$COPYIMG_BINARY" --root "$TESTDIR/crio" $STORAGE_OPTIONS --runroot "$TESTDIR/crio-run" --image-name=mrunalp/oom --import-from=dir:"$ARTIFACTS_PATH"/oom-image --add-name=docker.io/library/mrunalp/oom --signature-policy="$INTEGRATION_ROOT"/policy.json
+	"$COPYIMG_BINARY" --root "$TESTDIR/crio" $STORAGE_OPTIONS --runroot "$TESTDIR/crio-run" --image-name=mrunalp/image-volume-test --import-from=dir:"$ARTIFACTS_PATH"/image-volume-test-image --add-name=docker.io/library/mrunalp/image-volume-test --signature-policy="$INTEGRATION_ROOT"/policy.json
+	"$COPYIMG_BINARY" --root "$TESTDIR/crio" $STORAGE_OPTIONS --runroot "$TESTDIR/crio-run" --image-name=busybox:latest --import-from=dir:"$ARTIFACTS_PATH"/busybox-image --add-name=docker.io/library/busybox:latest --signature-policy="$INTEGRATION_ROOT"/policy.json
+	"$COPYIMG_BINARY" --root "$TESTDIR/crio" $STORAGE_OPTIONS --runroot "$TESTDIR/crio-run" --image-name=runcom/stderr-test:latest --import-from=dir:"$ARTIFACTS_PATH"/stderr-test --add-name=docker.io/runcom/stderr-test:latest --signature-policy="$INTEGRATION_ROOT"/policy.json
 	"$CRIO_BINARY" ${DEFAULT_MOUNTS_OPTS} ${HOOKS_OPTS} --conmon "$CONMON_BINARY" --listen "$CRIO_SOCKET" --cgroup-manager "$CGROUP_MANAGER" --registry "docker.io" --runtime "$RUNTIME_BINARY" --root "$TESTDIR/crio" --runroot "$TESTDIR/crio-run" $STORAGE_OPTIONS --seccomp-profile "$seccomp" --apparmor-profile "$apparmor" --cni-config-dir "$CRIO_CNI_CONFIG" --cni-plugin-dir "$CRIO_CNI_PLUGIN" --signature-policy "$INTEGRATION_ROOT"/policy.json --image-volumes "$IMAGE_VOLUMES" --pids-limit "$PIDS_LIMIT" --enable-shared-pid-namespace=${ENABLE_SHARED_PID_NAMESPACE} --log-size-max "$LOG_SIZE_MAX_LIMIT" --config /dev/null config >$CRIO_CONFIG
 
 	# Prepare the CNI configuration files, we're running with non host networking by default
@@ -234,28 +252,44 @@ function start_crio() {
 	if [ "$status" -ne 0 ] ; then
 		crictl pull redis:alpine
 	fi
-	REDIS_IMAGEID=$(crictl inspecti redis:alpine | grep ^ID: | head -n 1 | sed -e "s/ID: //g")
-	REDIS_IMAGEREF=$(crictl inspecti redis:alpine | grep ^Digest: | head -n 1 | sed -e "s/Digest: //g")
+	REDIS_IMAGEID=$(crictl inspecti redis:alpine | head -1 | sed -e "s/ID: //g")
 	run crictl inspecti mrunalp/oom
 	if [ "$status" -ne 0 ] ; then
 		  crictl pull mrunalp/oom
 	fi
-	OOM_IMAGEID=$(crictl inspecti mrunalp/oom | grep ^ID: | head -n 1 | sed -e "s/ID: //g")
-	run crioctl image status --id=runcom/stderr-test
+	#
+	#
+	#
+	# TODO: remove the code below for redis digested image id when
+	#       https://github.com/kubernetes-incubator/cri-o/issues/531 is complete
+	#       as the digested reference will be auto-stored when pulling the tag
+	#       above
+	#
+	#
+	#
+	REDIS_IMAGEID_DIGESTED="redis@sha256:03789f402b2ecfb98184bf128d180f398f81c63364948ff1454583b02442f73b"
+	run crictl inspecti $REDIS_IMAGEID_DIGESTED
+	if [ "$status" -ne 0 ]; then
+		crictl pull $REDIS_IMAGEID_DIGESTED
+	fi
+	#
+	#
+	#
+	run crictl inspecti runcom/stderr-test
 	if [ "$status" -ne 0 ] ; then
 		crictl pull runcom/stderr-test:latest
 	fi
-	STDERR_IMAGEID=$(crictl inspecti runcom/stderr-test | grep ^ID: | head -n 1 | sed -e "s/ID: //g")
+	STDERR_IMAGEID=$(crictl inspecti runcom/stderr-test | head -1 | sed -e "s/ID: //g")
 	run crictl inspecti busybox
 	if [ "$status" -ne 0 ] ; then
 		crictl pull busybox:latest
 	fi
-	BUSYBOX_IMAGEID=$(crictl inspecti busybox | grep ^ID: | head -n 1 | sed -e "s/ID: //g")
+	BUSYBOX_IMAGEID=$(crictl inspecti busybox | head -1 | sed -e "s/ID: //g")
 	run crictl inspecti mrunalp/image-volume-test
 	if [ "$status" -ne 0 ] ; then
 		  crictl pull mrunalp/image-volume-test:latest
 	fi
-	VOLUME_IMAGEID=$(crictl inspecti mrunalp/image-volume-test | grep ^ID: | head -n 1 | sed -e "s/ID: //g")
+	VOLUME_IMAGEID=$(crictl inspecti mrunalp/image-volume-test | head -1 | sed -e "s/ID: //g")
 }
 
 function cleanup_ctrs() {

test/image.bats

@@ -20,16 +20,12 @@ function teardown() {
 	run crictl create "$pod_id" "$TESTDIR"/ctr_by_imageid.json "$TESTDATA"/sandbox_config.json
 	echo "$output"
 	[ "$status" -eq 0 ]
-	ctr_id="$output"
-	run crictl start "$ctr_id"
-	echo "$output"
-	[ "$status" -eq 0 ]
 	cleanup_ctrs
 	cleanup_pods
 	stop_crio
 }
 
-@test "container status when created by image ID" {
+@test "container status return image:tag if created by image ID" {
 	start_crio
 
 	run crictl runs "$TESTDATA"/sandbox_config.json
@@ -47,15 +43,16 @@ function teardown() {
 	run crictl inspect "$ctr_id" --output yaml
 	echo "$output"
 	[ "$status" -eq 0 ]
-	[[ "$output" =~ "image: docker.io/library/redis:alpine" ]]
-	[[ "$output" =~ "imageRef: $REDIS_IMAGEREF" ]]
+	[[ "$output" =~ "image: redis:alpine" ]]
 
 	cleanup_ctrs
 	cleanup_pods
 	stop_crio
 }
 
-@test "container status when created by image tagged reference" {
+@test "container status return image@digest if created by image ID and digest available" {
+	skip "depends on https://github.com/kubernetes-incubator/cri-o/issues/531"
+
 	start_crio
 
 	run crictl runs "$TESTDATA"/sandbox_config.json
@@ -63,9 +60,9 @@ function teardown() {
 	[ "$status" -eq 0 ]
 	pod_id="$output"
 
-	sed -e "s/%VALUE%/redis:alpine/g" "$TESTDATA"/container_config_by_imageid.json > "$TESTDIR"/ctr_by_imagetag.json
+	sed -e "s/%VALUE%/$REDIS_IMAGEID_DIGESTED/g" "$TESTDATA"/container_config_by_imageid.json > "$TESTDIR"/ctr_by_imageid.json
 
-	run crictl create "$pod_id" "$TESTDIR"/ctr_by_imagetag.json "$TESTDATA"/sandbox_config.json
+	run crictl create "$pod_id" "$TESTDIR"/ctr_by_imageid.json "$TESTDATA"/sandbox_config.json
 	echo "$output"
 	[ "$status" -eq 0 ]
 	ctr_id="$output"
@@ -73,64 +70,22 @@ function teardown() {
 	run crictl inspect "$ctr_id" --output yaml
 	echo "$output"
 	[ "$status" -eq 0 ]
-	[[ "$output" =~ "image: docker.io/library/redis:alpine" ]]
-	[[ "$output" =~ "imageRef: $REDIS_IMAGEREF" ]]
+	[[ "$output" =~ "image_ref: redis@sha256:03789f402b2ecfb98184bf128d180f398f81c63364948ff1454583b02442f73b" ]]
 
 	cleanup_ctrs
 	cleanup_pods
 	stop_crio
 }
 
-@test "container status when created by image canonical reference" {
-	start_crio
-
-	run crictl runs "$TESTDATA"/sandbox_config.json
-	echo "$output"
-	[ "$status" -eq 0 ]
-	pod_id="$output"
-
-	sed -e "s|%VALUE%|$REDIS_IMAGEREF|g" "$TESTDATA"/container_config_by_imageid.json > "$TESTDIR"/ctr_by_imageref.json
-
-	run crictl create "$pod_id" "$TESTDIR"/ctr_by_imageref.json "$TESTDATA"/sandbox_config.json
-	echo "$output"
-	[ "$status" -eq 0 ]
-	ctr_id="$output"
-
-	run crictl start "$ctr_id"
-	echo "$output"
-	[ "$status" -eq 0 ]
-
-	run crictl inspect "$ctr_id" --output yaml
-	echo "$output"
-	[ "$status" -eq 0 ]
-	[[ "$output" =~ "image: docker.io/library/redis:alpine" ]]
-	[[ "$output" =~ "imageRef: $REDIS_IMAGEREF" ]]
-
-	cleanup_ctrs
-	cleanup_pods
-	stop_crio
-}
-
-@test "image pull and list" {
+@test "image pull" {
 	start_crio "" "" --no-pause-image
 	run crictl pull "$IMAGE"
 	echo "$output"
 	[ "$status" -eq 0 ]
-
-	run crictl images --quiet "$IMAGE"
-	[ "$status" -eq 0 ]
+	run crictl inspecti "$IMAGE"
 	echo "$output"
-	[ "$output" != "" ]
-	imageid="$output"
-
-	run crictl images @"$imageid"
 	[ "$status" -eq 0 ]
 	[[ "$output" =~ "$IMAGE" ]]
-
-	run crictl images --quiet "$imageid"
-	[ "$status" -eq 0 ]
-	echo "$output"
-	[ "$output" != "" ]
 	cleanup_images
 	stop_crio
 }
@@ -153,33 +108,7 @@ function teardown() {
 	stop_crio
 }
 
-@test "image pull and list by tag and ID" {
-	start_crio "" "" --no-pause-image
-	run crictl pull "$IMAGE:go"
-	echo "$output"
-	[ "$status" -eq 0 ]
-
-	run crictl images --quiet "$IMAGE:go"
-	[ "$status" -eq 0 ]
-	echo "$output"
-	[ "$output" != "" ]
-	imageid="$output"
-
-	run crictl images --quiet @"$imageid"
-	[ "$status" -eq 0 ]
-	echo "$output"
-	[ "$output" != "" ]
-
-	run crictl images --quiet "$imageid"
-	[ "$status" -eq 0 ]
-	echo "$output"
-	[ "$output" != "" ]
-
-	cleanup_images
-	stop_crio
-}
-
-@test "image pull and list by digest and ID" {
+@test "image pull and list by digest" {
 	start_crio "" "" --no-pause-image
 	run crictl pull nginx@sha256:33eb1ed1e802d4f71e52421f56af028cdf12bb3bfff5affeaf5bf0e328ffa1bc
 	echo "$output"
@@ -189,14 +118,18 @@ function teardown() {
 	[ "$status" -eq 0 ]
 	echo "$output"
 	[ "$output" != "" ]
-	imageid="$output"
 
-	run crictl images --quiet @"$imageid"
+	run crictl images --quiet nginx@33eb1ed1e802d4f71e52421f56af028cdf12bb3bfff5affeaf5bf0e328ffa1bc
 	[ "$status" -eq 0 ]
 	echo "$output"
 	[ "$output" != "" ]
 
-	run crictl images --quiet "$imageid"
+	run crictl images --quiet @33eb1ed1e802d4f71e52421f56af028cdf12bb3bfff5affeaf5bf0e328ffa1bc
+	[ "$status" -eq 0 ]
+	echo "$output"
+	[ "$output" != "" ]
+
+	run crictl images --quiet 33eb1ed1e802d4f71e52421f56af028cdf12bb3bfff5affeaf5bf0e328ffa1bc
 	[ "$status" -eq 0 ]
 	echo "$output"
 	[ "$output" != "" ]
@@ -265,7 +198,7 @@ function teardown() {
 	[ "$status" -eq 0 ]
 	[ "$output" != "" ]
 	printf '%s\n' "$output" | while IFS= read -r id; do
-		run crictl images -v "$id"
+		run crictl inspecti "$id"
 		echo "$output"
 		[ "$status" -eq 0 ]
 		[ "$output" != "" ]

test/image_remove.bats

@@ -1,75 +0,0 @@
-#!/usr/bin/env bats
-
-load helpers
-
-IMAGE=docker.io/kubernetes/pause
-
-function teardown() {
-	cleanup_test
-}
-
-@test "image remove with multiple names, by name" {
-	start_crio "" "" --no-pause-image
-	# Pull the image, giving it one name.
-	run crictl pull "$IMAGE"
-	echo "$output"
-	[ "$status" -eq 0 ]
-	# Add a second name to the image.
-	run "$COPYIMG_BINARY" --root "$TESTDIR/crio" $STORAGE_OPTIONS --runroot "$TESTDIR/crio-run" --image-name="$IMAGE":latest --add-name="$IMAGE":othertag --signature-policy="$INTEGRATION_ROOT"/policy.json
-	echo "$output"
-	[ "$status" -eq 0 ]
-	# Get the list of image names and IDs.
-	run crictl images -v
-	echo "$output"
-	[ "$status" -eq 0 ]
-	[ "$output" != "" ]
-	# Cycle through each name, removing it by name.  The image that we assigned a second
-	# name to should still be around when we get to removing its second name.
-	grep ^RepoTags: <<< "$output" | while read -r header tag ignored ; do
-		run crictl rmi "$tag"
-		echo "$output"
-		[ "$status" -eq 0 ]
-	done
-	# List all images and their names.  There should be none now.
-	run crictl images --quiet
-	echo "$output"
-	[ "$status" -eq 0 ]
-	[ "$output" = "" ]
-	printf '%s\n' "$output" | while IFS= read -r id; do
-		echo "$id"
-	done
-	# All done.
-	cleanup_images
-	stop_crio
-}
-
-@test "image remove with multiple names, by ID" {
-	start_crio "" "" --no-pause-image
-	# Pull the image, giving it one name.
-	run crictl pull "$IMAGE"
-	echo "$output"
-	[ "$status" -eq 0 ]
-	# Add a second name to the image.
-	run "$COPYIMG_BINARY" --root "$TESTDIR/crio" $STORAGE_OPTIONS --runroot "$TESTDIR/crio-run" --image-name="$IMAGE":latest --add-name="$IMAGE":othertag --signature-policy="$INTEGRATION_ROOT"/policy.json
-	echo "$output"
-	[ "$status" -eq 0 ]
-	# Get the list of the image's names and its ID.
-	run crictl images -v "$IMAGE":latest
-	echo "$output"
-	[ "$status" -eq 0 ]
-	[ "$output" != "" ]
-	# Try to remove the image using its ID.  That should succeed.
-	grep ^ID: <<< "$output" | while read -r header id ; do
-		run crictl rmi "$id"
-		echo "$output"
-		[ "$status" -eq 0 ]
-	done
-	# The image should be gone now.
-	run crictl images -v "$IMAGE"
-	echo "$output"
-	[ "$status" -eq 0 ]
-	[ "$output" = "" ]
-	# All done.
-	cleanup_images
-	stop_crio
-}

test/image_volume.bats

@@ -55,7 +55,7 @@ function teardown() {
 	run crictl exec --sync "$ctr_id" touch /imagevolume/test_file
 	echo "$output"
 	[ "$status" -eq 0 ]
-	[ "$output" = "" ]
+
 	run crictl stops "$pod_id"
 	echo "$output"
 	[ "$status" -eq 0 ]

test/inspect.bats

@@ -30,15 +30,13 @@ function teardown() {
 	out=`echo -e "GET /containers/$ctr_id HTTP/1.1\r\nHost: crio\r\n" | socat - UNIX-CONNECT:$CRIO_SOCKET`
 	echo "$out"
 	[[ "$out" =~ "\"sandbox\":\"$pod_id\"" ]]
-	[[ "$out" =~ "\"image\":\"docker.io/library/redis:alpine\"" ]]
-	[[ "$out" =~ "\"image_ref\":\"$REDIS_IMAGEREF\"" ]]
+	[[ "$out" =~ "\"image\":\"redis:alpine\"" ]]
 
 	run crictl inspect --output json "$ctr_id"
 	echo "$output"
 	[ "$status" -eq 0 ]
 	[[ "$output" =~ "\"id\": \"$ctr_id\"" ]]
-	[[ "$output" =~ "\"image\": \"docker.io/library/redis:alpine\"" ]]
-	[[ "$output" =~ "\"imageRef\": \"$REDIS_IMAGEREF\"" ]]
+	[[ "$output" =~ "\"image\": \"redis:alpine\"" ]]
 
 	run crictl inspects --output json "$pod_id"
 	echo "$output"

test/namespaces.bats

@@ -6,8 +6,8 @@ function teardown() {
 	cleanup_test
 }
 
-function pid_namespace_test() {
-	start_crio
+@test "pod disable shared pid namespace" {
+	ENABLE_SHARED_PID_NAMESPACE="false" start_crio
 
 	run crictl runs "$TESTDATA"/sandbox_config.json
 	echo "$output"
@@ -23,7 +23,7 @@ function pid_namespace_test() {
 	run crictl exec --sync "$ctr_id" cat /proc/1/cmdline
 	echo "$output"
 	[ "$status" -eq 0 ]
-	[[ "$output" =~ "${EXPECTED_INIT:-redis}" ]]
+	[[ "$output" =~ "redis" ]]
 
 	run crictl stops "$pod_id"
 	echo "$output"
@@ -36,10 +36,32 @@ function pid_namespace_test() {
 	stop_crio
 }
 
-@test "pod disable shared pid namespace" {
-	ENABLE_SHARED_PID_NAMESPACE=false pid_namespace_test
-}
-
 @test "pod enable shared pid namespace" {
-	ENABLE_SHARED_PID_NAMESPACE=true EXPECTED_INIT=pause pid_namespace_test
+	ENABLE_SHARED_PID_NAMESPACE="true" start_crio
+
+	run crictl runs "$TESTDATA"/sandbox_config.json
+	echo "$output"
+	[ "$status" -eq 0 ]
+	pod_id="$output"
+	run crictl create "$pod_id" "$TESTDATA"/container_redis.json "$TESTDATA"/sandbox_config.json
+	echo "$output"
+	[ "$status" -eq 0 ]
+	ctr_id="$output"
+	run crictl start "$ctr_id"
+	[ "$status" -eq 0 ]
+
+	run crictl exec --sync "$ctr_id" cat /proc/1/cmdline
+	echo "$output"
+	[ "$status" -eq 0 ]
+	[[ "$output" =~ "pause" ]]
+
+	run crictl stops "$pod_id"
+	echo "$output"
+	[ "$status" -eq 0 ]
+	run crictl rms "$pod_id"
+	echo "$output"
+	[ "$status" -eq 0 ]
+	cleanup_ctrs
+	cleanup_pods
+	stop_crio
 }

test/testdata/container_redis.json

@@ -49,9 +49,7 @@
 			"cpu_period": 10000,
 			"cpu_quota": 20000,
 			"cpu_shares": 512,
-			"oom_score_adj": 30,
-			"cpuset_cpus": "0-1",
-			"cpuset_mems": "0"
+			"oom_score_adj": 30
 		},
 		"security_context": {
 			"capabilities": {

tutorial.md

@@ -138,12 +138,32 @@ make
 sudo make install
 ```
 
-If you are installing for the first time, generate and install configuration files with:
+Output:
+
+```
+install -D -m 755 crio /usr/local/bin/crio
+install -D -m 755 conmon/conmon /usr/local/libexec/crio/conmon
+install -D -m 755 pause/pause /usr/local/libexec/crio/pause
+install -d -m 755 /usr/local/share/man/man{1,5,8}
+install -m 644 docs/crio.conf.5 -t /usr/local/share/man/man5
+install -m 644 docs/crio.8 -t /usr/local/share/man/man8
+install -D -m 644 crio.conf /etc/crio/crio.conf
+install -D -m 644 seccomp.json /etc/crio/seccomp.json
+```
+
+If you are installing for the first time, generate config as follows:
 
 ```
 sudo make install.config
 ```
 
+Output:
+
+```
+install -D -m 644 crio.conf /etc/crio/crio.conf
+install -D -m 644 seccomp.json /etc/crio/seccomp.json
+```
+
 #### Start the crio system daemon
 
 ```
@@ -300,15 +320,15 @@ cd $GOPATH/src/github.com/kubernetes-incubator/cri-o
 Next create the Pod and capture the Pod ID for later use:
 
 ```
-POD_ID=$(sudo crictl runp test/testdata/sandbox_config.json)
+POD_ID=$(sudo crictl runs test/testdata/sandbox_config.json)
 ```
 
-> sudo crictl runp test/testdata/sandbox_config.json
+> sudo crictl runs test/testdata/sandbox_config.json
 
 Use the `crictl` command to get the status of the Pod:
 
 ```
-sudo crictl inspectp --output table $POD_ID
+sudo crictl inspects --output table $POD_ID
 ```
 
 Output:

types/types.go

@@ -5,7 +5,6 @@ type ContainerInfo struct {
 	Name            string            `json:"name"`
 	Pid             int               `json:"pid"`
 	Image           string            `json:"image"`
-	ImageRef        string            `json:"image_ref"`
 	CreatedTime     int64             `json:"created_time"`
 	Labels          map[string]string `json:"labels"`
 	Annotations     map[string]string `json:"annotations"`

vendor.conf

@@ -1,26 +1,26 @@
-k8s.io/kubernetes a48f11c2257d84b0bec89864025508b0ef626b4f https://github.com/kubernetes/kubernetes
-k8s.io/client-go master https://github.com/kubernetes/client-go
-k8s.io/apimachinery master https://github.com/kubernetes/apimachinery
-k8s.io/apiserver master https://github.com/kubernetes/apiserver
+k8s.io/kubernetes release-1.9 https://github.com/kubernetes/kubernetes
+k8s.io/client-go release-6.0 https://github.com/kubernetes/client-go
+k8s.io/apimachinery release-1.9 https://github.com/kubernetes/apimachinery
+k8s.io/apiserver release-1.9 https://github.com/kubernetes/apiserver
 k8s.io/utils 4fe312863be2155a7b68acd2aff1c9221b24e68c https://github.com/kubernetes/utils
-k8s.io/api master https://github.com/kubernetes/api
+k8s.io/api release-1.9 https://github.com/kubernetes/api
 k8s.io/kube-openapi 39a7bf85c140f972372c2a0d1ee40adbf0c8bfe1 https://github.com/kubernetes/kube-openapi
-k8s.io/apiextensions-apiserver master https://github.com/kubernetes/apiextensions-apiserver
+k8s.io/apiextensions-apiserver release-1.9 https://github.com/kubernetes/apiextensions-apiserver
 #
 github.com/googleapis/gnostic 0c5108395e2debce0d731cf0287ddf7242066aba
 github.com/gregjones/httpcache 787624de3eb7bd915c329cba748687a3b22666a6
 github.com/json-iterator/go 1.0.0
 github.com/peterbourgon/diskv v2.0.1
 github.com/sirupsen/logrus v1.0.0
-github.com/containers/image 3d0304a02154dddc8f97cc833aa0861cea5e9ade
+github.com/containers/image 57b257d128d6075ea3287991ee408d24c7bd2758
 github.com/docker/docker-credential-helpers d68f9aeca33f5fd3f08eeae5e9d175edf4e731d1
 github.com/ostreedev/ostree-go master
-github.com/containers/storage 0d32dfce498e06c132c60dac945081bf44c22464
+github.com/containers/storage d7921c6facc516358070a1306689eda18adaa20a
 github.com/containernetworking/cni v0.4.0
 google.golang.org/grpc v1.0.4 https://github.com/grpc/grpc-go
 github.com/opencontainers/selinux b29023b86e4a69d1b46b7e7b4e2b6fda03f0b9cd
 github.com/opencontainers/go-digest v1.0.0-rc0
-github.com/opencontainers/runtime-tools 625e2322645b151a7cbb93a8b42920933e72167f
+github.com/opencontainers/runtime-tools d3f7e9e9e631c7e87552d67dc7c86de33c3fb68a
 github.com/opencontainers/runc 45bde006ca8c90e089894508708bcf0e2cdf9e13
 github.com/mrunalp/fileutils master
 github.com/vishvananda/netlink master
@@ -113,6 +113,3 @@ github.com/hashicorp/errwrap 7554cd9344cec97297fa6649b055a8c98c2a1e55
 github.com/pquerna/ffjson d49c2bc1aa135aad0c6f4fc2056623ec78f5d5ac
 github.com/stretchr/testify 4d4bfba8f1d1027c4fdbe371823030df51419987
 github.com/pmezard/go-difflib v1.0.0
-github.com/xeipuuv/gojsonreference master
-github.com/xeipuuv/gojsonschema master
-github.com/xeipuuv/gojsonpointer master

vendor/github.com/containers/image/copy/copy.go

@@ -12,6 +12,8 @@ import (
 	"strings"
 	"time"
 
+	pb "gopkg.in/cheggaaa/pb.v1"
+
 	"github.com/containers/image/image"
 	"github.com/containers/image/pkg/compression"
 	"github.com/containers/image/signature"
@@ -20,7 +22,6 @@ import (
 	"github.com/opencontainers/go-digest"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
-	pb "gopkg.in/cheggaaa/pb.v1"
 )
 
 type digestingReader struct {
@@ -30,6 +31,23 @@ type digestingReader struct {
 	validationFailed bool
 }
 
+// imageCopier allows us to keep track of diffID values for blobs, and other
+// data, that we're copying between images, and cache other information that
+// might allow us to take some shortcuts
+type imageCopier struct {
+	copiedBlobs       map[digest.Digest]digest.Digest
+	cachedDiffIDs     map[digest.Digest]digest.Digest
+	manifestUpdates   *types.ManifestUpdateOptions
+	dest              types.ImageDestination
+	src               types.Image
+	rawSource         types.ImageSource
+	diffIDsAreNeeded  bool
+	canModifyManifest bool
+	reportWriter      io.Writer
+	progressInterval  time.Duration
+	progress          chan types.ProgressProperties
+}
+
 // newDigestingReader returns an io.Reader implementation with contents of source, which will eventually return a non-EOF error
 // and set validationFailed to true if the source stream does not match expectedDigest.
 func newDigestingReader(source io.Reader, expectedDigest digest.Digest) (*digestingReader, error) {
@@ -68,27 +86,6 @@ func (d *digestingReader) Read(p []byte) (int, error) {
 	return n, err
 }
 
-// copier allows us to keep track of diffID values for blobs, and other
-// data shared across one or more images in a possible manifest list.
-type copier struct {
-	copiedBlobs      map[digest.Digest]digest.Digest
-	cachedDiffIDs    map[digest.Digest]digest.Digest
-	dest             types.ImageDestination
-	rawSource        types.ImageSource
-	reportWriter     io.Writer
-	progressInterval time.Duration
-	progress         chan types.ProgressProperties
-}
-
-// imageCopier tracks state specific to a single image (possibly an item of a manifest list)
-type imageCopier struct {
-	c                 *copier
-	manifestUpdates   *types.ManifestUpdateOptions
-	src               types.Image
-	diffIDsAreNeeded  bool
-	canModifyManifest bool
-}
-
 // Options allows supplying non-default configuration modifying the behavior of CopyImage.
 type Options struct {
 	RemoveSignatures bool   // Remove any pre-existing signatures. SignBy will still add a new signature.
@@ -98,8 +95,6 @@ type Options struct {
 	DestinationCtx   *types.SystemContext
 	ProgressInterval time.Duration                 // time to wait between reports to signal the progress channel
 	Progress         chan types.ProgressProperties // Reported to when ProgressInterval has arrived for a single artifact+offset.
-	// manifest MIME type of image set by user. "" is default and means use the autodetection to the the manifest MIME type
-	ForceManifestMIMEType string
 }
 
 // Image copies image from srcRef to destRef, using policyContext to validate
@@ -120,6 +115,10 @@ func Image(policyContext *signature.PolicyContext, destRef, srcRef types.ImageRe
 		reportWriter = options.ReportWriter
 	}
 
+	writeReport := func(f string, a ...interface{}) {
+		fmt.Fprintf(reportWriter, f, a...)
+	}
+
 	dest, err := destRef.NewImageDestination(options.DestinationCtx)
 	if err != nil {
 		return errors.Wrapf(err, "Error initializing destination %s", transports.ImageName(destRef))
@@ -134,89 +133,43 @@ func Image(policyContext *signature.PolicyContext, destRef, srcRef types.ImageRe
 	if err != nil {
 		return errors.Wrapf(err, "Error initializing source %s", transports.ImageName(srcRef))
 	}
+	unparsedImage := image.UnparsedFromSource(rawSource)
 	defer func() {
-		if err := rawSource.Close(); err != nil {
-			retErr = errors.Wrapf(retErr, " (src: %v)", err)
+		if unparsedImage != nil {
+			if err := unparsedImage.Close(); err != nil {
+				retErr = errors.Wrapf(retErr, " (unparsed: %v)", err)
+			}
 		}
 	}()
 
-	c := &copier{
-		copiedBlobs:      make(map[digest.Digest]digest.Digest),
-		cachedDiffIDs:    make(map[digest.Digest]digest.Digest),
-		dest:             dest,
-		rawSource:        rawSource,
-		reportWriter:     reportWriter,
-		progressInterval: options.ProgressInterval,
-		progress:         options.Progress,
-	}
-
-	unparsedToplevel := image.UnparsedInstance(rawSource, nil)
-	multiImage, err := isMultiImage(unparsedToplevel)
-	if err != nil {
-		return errors.Wrapf(err, "Error determining manifest MIME type for %s", transports.ImageName(srcRef))
-	}
-
-	if !multiImage {
-		// The simple case: Just copy a single image.
-		if err := c.copyOneImage(policyContext, options, unparsedToplevel); err != nil {
-			return err
-		}
-	} else {
-		// This is a manifest list. Choose a single image and copy it.
-		// FIXME: Copy to destinations which support manifest lists, one image at a time.
-		instanceDigest, err := image.ChooseManifestInstanceFromManifestList(options.SourceCtx, unparsedToplevel)
-		if err != nil {
-			return errors.Wrapf(err, "Error choosing an image from manifest list %s", transports.ImageName(srcRef))
-		}
-		logrus.Debugf("Source is a manifest list; copying (only) instance %s", instanceDigest)
-		unparsedInstance := image.UnparsedInstance(rawSource, &instanceDigest)
-
-		if err := c.copyOneImage(policyContext, options, unparsedInstance); err != nil {
-			return err
-		}
-	}
-
-	if err := c.dest.Commit(); err != nil {
-		return errors.Wrap(err, "Error committing the finished image")
-	}
-
-	return nil
-}
-
-// Image copies a single (on-manifest-list) image unparsedImage, using policyContext to validate
-// source image admissibility.
-func (c *copier) copyOneImage(policyContext *signature.PolicyContext, options *Options, unparsedImage *image.UnparsedImage) (retErr error) {
-	// The caller is handling manifest lists; this could happen only if a manifest list contains a manifest list.
-	// Make sure we fail cleanly in such cases.
-	multiImage, err := isMultiImage(unparsedImage)
-	if err != nil {
-		// FIXME FIXME: How to name a reference for the sub-image?
-		return errors.Wrapf(err, "Error determining manifest MIME type for %s", transports.ImageName(unparsedImage.Reference()))
-	}
-	if multiImage {
-		return fmt.Errorf("Unexpectedly received a manifest list instead of a manifest for a single image")
-	}
-
 	// Please keep this policy check BEFORE reading any other information about the image.
-	// (the multiImage check above only matches the MIME type, which we have received anyway.
-	// Actual parsing of anything should be deferred.)
 	if allowed, err := policyContext.IsRunningImageAllowed(unparsedImage); !allowed || err != nil { // Be paranoid and fail if either return value indicates so.
 		return errors.Wrap(err, "Source image rejected")
 	}
-	src, err := image.FromUnparsedImage(options.SourceCtx, unparsedImage)
+	src, err := image.FromUnparsedImage(unparsedImage)
 	if err != nil {
-		return errors.Wrapf(err, "Error initializing image from source %s", transports.ImageName(c.rawSource.Reference()))
+		return errors.Wrapf(err, "Error initializing image from source %s", transports.ImageName(srcRef))
+	}
+	unparsedImage = nil
+	defer func() {
+		if err := src.Close(); err != nil {
+			retErr = errors.Wrapf(retErr, " (source: %v)", err)
+		}
+	}()
+
+	if err := checkImageDestinationForCurrentRuntimeOS(src, dest); err != nil {
+		return err
 	}
 
-	if err := checkImageDestinationForCurrentRuntimeOS(options.DestinationCtx, src, c.dest); err != nil {
-		return err
+	if src.IsMultiImage() {
+		return errors.Errorf("can not copy %s: manifest contains multiple images", transports.ImageName(srcRef))
 	}
 
 	var sigs [][]byte
 	if options.RemoveSignatures {
 		sigs = [][]byte{}
 	} else {
-		c.Printf("Getting image source signatures\n")
+		writeReport("Getting image source signatures\n")
 		s, err := src.Signatures(context.TODO())
 		if err != nil {
 			return errors.Wrap(err, "Error reading signatures")
@@ -224,33 +177,41 @@ func (c *copier) copyOneImage(policyContext *signature.PolicyContext, options *O
 		sigs = s
 	}
 	if len(sigs) != 0 {
-		c.Printf("Checking if image destination supports signatures\n")
-		if err := c.dest.SupportsSignatures(); err != nil {
+		writeReport("Checking if image destination supports signatures\n")
+		if err := dest.SupportsSignatures(); err != nil {
 			return errors.Wrap(err, "Can not copy signatures")
 		}
 	}
 
-	ic := imageCopier{
-		c:               c,
-		manifestUpdates: &types.ManifestUpdateOptions{InformationOnly: types.ManifestUpdateInformation{Destination: c.dest}},
-		src:             src,
-		// diffIDsAreNeeded is computed later
-		canModifyManifest: len(sigs) == 0,
-	}
+	canModifyManifest := len(sigs) == 0
+	manifestUpdates := types.ManifestUpdateOptions{}
+	manifestUpdates.InformationOnly.Destination = dest
 
-	if err := ic.updateEmbeddedDockerReference(); err != nil {
+	if err := updateEmbeddedDockerReference(&manifestUpdates, dest, src, canModifyManifest); err != nil {
 		return err
 	}
 
 	// We compute preferredManifestMIMEType only to show it in error messages.
 	// Without having to add this context in an error message, we would be happy enough to know only that no conversion is needed.
-	preferredManifestMIMEType, otherManifestMIMETypeCandidates, err := ic.determineManifestConversion(c.dest.SupportedManifestMIMETypes(), options.ForceManifestMIMEType)
+	preferredManifestMIMEType, otherManifestMIMETypeCandidates, err := determineManifestConversion(&manifestUpdates, src, dest.SupportedManifestMIMETypes(), canModifyManifest)
 	if err != nil {
 		return err
 	}
 
-	// If src.UpdatedImageNeedsLayerDiffIDs(ic.manifestUpdates) will be true, it needs to be true by the time we get here.
-	ic.diffIDsAreNeeded = src.UpdatedImageNeedsLayerDiffIDs(*ic.manifestUpdates)
+	// If src.UpdatedImageNeedsLayerDiffIDs(manifestUpdates) will be true, it needs to be true by the time we get here.
+	ic := imageCopier{
+		copiedBlobs:       make(map[digest.Digest]digest.Digest),
+		cachedDiffIDs:     make(map[digest.Digest]digest.Digest),
+		manifestUpdates:   &manifestUpdates,
+		dest:              dest,
+		src:               src,
+		rawSource:         rawSource,
+		diffIDsAreNeeded:  src.UpdatedImageNeedsLayerDiffIDs(manifestUpdates),
+		canModifyManifest: canModifyManifest,
+		reportWriter:      reportWriter,
+		progressInterval:  options.ProgressInterval,
+		progress:          options.Progress,
+	}
 
 	if err := ic.copyLayers(); err != nil {
 		return err
@@ -272,9 +233,9 @@ func (c *copier) copyOneImage(policyContext *signature.PolicyContext, options *O
 		}
 		// If the original MIME type is acceptable, determineManifestConversion always uses it as preferredManifestMIMEType.
 		// So if we are here, we will definitely be trying to convert the manifest.
-		// With !ic.canModifyManifest, that would just be a string of repeated failures for the same reason,
+		// With !canModifyManifest, that would just be a string of repeated failures for the same reason,
 		// so let’s bail out early and with a better error message.
-		if !ic.canModifyManifest {
+		if !canModifyManifest {
 			return errors.Wrap(err, "Writing manifest failed (and converting it is not possible)")
 		}
 
@@ -282,7 +243,7 @@ func (c *copier) copyOneImage(policyContext *signature.PolicyContext, options *O
 		errs := []string{fmt.Sprintf("%s(%v)", preferredManifestMIMEType, err)}
 		for _, manifestMIMEType := range otherManifestMIMETypeCandidates {
 			logrus.Debugf("Trying to use manifest type %s…", manifestMIMEType)
-			ic.manifestUpdates.ManifestMIMEType = manifestMIMEType
+			manifestUpdates.ManifestMIMEType = manifestMIMEType
 			attemptedManifest, err := ic.copyUpdatedConfigAndManifest()
 			if err != nil {
 				logrus.Debugf("Upload of manifest type %s failed: %v", manifestMIMEType, err)
@@ -301,44 +262,35 @@ func (c *copier) copyOneImage(policyContext *signature.PolicyContext, options *O
 	}
 
 	if options.SignBy != "" {
-		newSig, err := c.createSignature(manifest, options.SignBy)
+		newSig, err := createSignature(dest, manifest, options.SignBy, reportWriter)
 		if err != nil {
 			return err
 		}
 		sigs = append(sigs, newSig)
 	}
 
-	c.Printf("Storing signatures\n")
-	if err := c.dest.PutSignatures(sigs); err != nil {
+	writeReport("Storing signatures\n")
+	if err := dest.PutSignatures(sigs); err != nil {
 		return errors.Wrap(err, "Error writing signatures")
 	}
 
+	if err := dest.Commit(); err != nil {
+		return errors.Wrap(err, "Error committing the finished image")
+	}
+
 	return nil
 }
 
-// Printf writes a formatted string to c.reportWriter.
-// Note that the method name Printf is not entirely arbitrary: (go tool vet)
-// has a built-in list of functions/methods (whatever object they are for)
-// which have their format strings checked; for other names we would have
-// to pass a parameter to every (go tool vet) invocation.
-func (c *copier) Printf(format string, a ...interface{}) {
-	fmt.Fprintf(c.reportWriter, format, a...)
-}
-
-func checkImageDestinationForCurrentRuntimeOS(ctx *types.SystemContext, src types.Image, dest types.ImageDestination) error {
+func checkImageDestinationForCurrentRuntimeOS(src types.Image, dest types.ImageDestination) error {
 	if dest.MustMatchRuntimeOS() {
-		wantedOS := runtime.GOOS
-		if ctx != nil && ctx.OSChoice != "" {
-			wantedOS = ctx.OSChoice
-		}
 		c, err := src.OCIConfig()
 		if err != nil {
 			return errors.Wrapf(err, "Error parsing image configuration")
 		}
-		osErr := fmt.Errorf("image operating system %q cannot be used on %q", c.OS, wantedOS)
-		if wantedOS == "windows" && c.OS == "linux" {
+		osErr := fmt.Errorf("image operating system %q cannot be used on %q", c.OS, runtime.GOOS)
+		if runtime.GOOS == "windows" && c.OS == "linux" {
 			return osErr
-		} else if wantedOS != "windows" && c.OS == "windows" {
+		} else if runtime.GOOS != "windows" && c.OS == "windows" {
 			return osErr
 		}
 	}
@@ -346,44 +298,35 @@ func checkImageDestinationForCurrentRuntimeOS(ctx *types.SystemContext, src type
 }
 
 // updateEmbeddedDockerReference handles the Docker reference embedded in Docker schema1 manifests.
-func (ic *imageCopier) updateEmbeddedDockerReference() error {
-	destRef := ic.c.dest.Reference().DockerReference()
+func updateEmbeddedDockerReference(manifestUpdates *types.ManifestUpdateOptions, dest types.ImageDestination, src types.Image, canModifyManifest bool) error {
+	destRef := dest.Reference().DockerReference()
 	if destRef == nil {
 		return nil // Destination does not care about Docker references
 	}
-	if !ic.src.EmbeddedDockerReferenceConflicts(destRef) {
+	if !src.EmbeddedDockerReferenceConflicts(destRef) {
 		return nil // No reference embedded in the manifest, or it matches destRef already.
 	}
 
-	if !ic.canModifyManifest {
+	if !canModifyManifest {
 		return errors.Errorf("Copying a schema1 image with an embedded Docker reference to %s (Docker reference %s) would invalidate existing signatures. Explicitly enable signature removal to proceed anyway",
-			transports.ImageName(ic.c.dest.Reference()), destRef.String())
+			transports.ImageName(dest.Reference()), destRef.String())
 	}
-	ic.manifestUpdates.EmbeddedDockerReference = destRef
+	manifestUpdates.EmbeddedDockerReference = destRef
 	return nil
 }
 
-// copyLayers copies layers from ic.src/ic.c.rawSource to dest, using and updating ic.manifestUpdates if necessary and ic.canModifyManifest.
+// copyLayers copies layers from src/rawSource to dest, using and updating ic.manifestUpdates if necessary and ic.canModifyManifest.
 func (ic *imageCopier) copyLayers() error {
 	srcInfos := ic.src.LayerInfos()
 	destInfos := []types.BlobInfo{}
 	diffIDs := []digest.Digest{}
-	updatedSrcInfos := ic.src.LayerInfosForCopy()
-	srcInfosUpdated := false
-	if updatedSrcInfos != nil && !reflect.DeepEqual(srcInfos, updatedSrcInfos) {
-		if !ic.canModifyManifest {
-			return errors.Errorf("Internal error: copyLayers() needs to use an updated manifest but that was known to be forbidden")
-		}
-		srcInfos = updatedSrcInfos
-		srcInfosUpdated = true
-	}
 	for _, srcLayer := range srcInfos {
 		var (
 			destInfo types.BlobInfo
 			diffID   digest.Digest
 			err      error
 		)
-		if ic.c.dest.AcceptsForeignLayerURLs() && len(srcLayer.URLs) != 0 {
+		if ic.dest.AcceptsForeignLayerURLs() && len(srcLayer.URLs) != 0 {
 			// DiffIDs are, currently, needed only when converting from schema1.
 			// In which case src.LayerInfos will not have URLs because schema1
 			// does not support them.
@@ -391,7 +334,7 @@ func (ic *imageCopier) copyLayers() error {
 				return errors.New("getting DiffID for foreign layers is unimplemented")
 			}
 			destInfo = srcLayer
-			ic.c.Printf("Skipping foreign layer %q copy to %s\n", destInfo.Digest, ic.c.dest.Reference().Transport().Name())
+			fmt.Fprintf(ic.reportWriter, "Skipping foreign layer %q copy to %s\n", destInfo.Digest, ic.dest.Reference().Transport().Name())
 		} else {
 			destInfo, diffID, err = ic.copyLayer(srcLayer)
 			if err != nil {
@@ -405,7 +348,7 @@ func (ic *imageCopier) copyLayers() error {
 	if ic.diffIDsAreNeeded {
 		ic.manifestUpdates.InformationOnly.LayerDiffIDs = diffIDs
 	}
-	if srcInfosUpdated || layerDigestsDiffer(srcInfos, destInfos) {
+	if layerDigestsDiffer(srcInfos, destInfos) {
 		ic.manifestUpdates.LayerInfos = destInfos
 	}
 	return nil
@@ -436,7 +379,7 @@ func (ic *imageCopier) copyUpdatedConfigAndManifest() ([]byte, error) {
 			// We have set ic.diffIDsAreNeeded based on the preferred MIME type returned by determineManifestConversion.
 			// So, this can only happen if we are trying to upload using one of the other MIME type candidates.
 			// Because UpdatedImageNeedsLayerDiffIDs is true only when converting from s1 to s2, this case should only arise
-			// when ic.c.dest.SupportedManifestMIMETypes() includes both s1 and s2, the upload using s1 failed, and we are now trying s2.
+			// when ic.dest.SupportedManifestMIMETypes() includes both s1 and s2, the upload using s1 failed, and we are now trying s2.
 			// Supposedly s2-only registries do not exist or are extremely rare, so failing with this error message is good enough for now.
 			// If handling such registries turns out to be necessary, we could compute ic.diffIDsAreNeeded based on the full list of manifest MIME type candidates.
 			return nil, errors.Errorf("Can not convert image to %s, preparing DiffIDs for this case is not supported", ic.manifestUpdates.ManifestMIMEType)
@@ -452,27 +395,27 @@ func (ic *imageCopier) copyUpdatedConfigAndManifest() ([]byte, error) {
 		return nil, errors.Wrap(err, "Error reading manifest")
 	}
 
-	if err := ic.c.copyConfig(pendingImage); err != nil {
+	if err := ic.copyConfig(pendingImage); err != nil {
 		return nil, err
 	}
 
-	ic.c.Printf("Writing manifest to image destination\n")
-	if err := ic.c.dest.PutManifest(manifest); err != nil {
+	fmt.Fprintf(ic.reportWriter, "Writing manifest to image destination\n")
+	if err := ic.dest.PutManifest(manifest); err != nil {
 		return nil, errors.Wrap(err, "Error writing manifest")
 	}
 	return manifest, nil
 }
 
 // copyConfig copies config.json, if any, from src to dest.
-func (c *copier) copyConfig(src types.Image) error {
+func (ic *imageCopier) copyConfig(src types.Image) error {
 	srcInfo := src.ConfigInfo()
 	if srcInfo.Digest != "" {
-		c.Printf("Copying config %s\n", srcInfo.Digest)
+		fmt.Fprintf(ic.reportWriter, "Copying config %s\n", srcInfo.Digest)
 		configBlob, err := src.ConfigBlob()
 		if err != nil {
 			return errors.Wrapf(err, "Error reading config blob %s", srcInfo.Digest)
 		}
-		destInfo, err := c.copyBlobFromStream(bytes.NewReader(configBlob), srcInfo, nil, false)
+		destInfo, err := ic.copyBlobFromStream(bytes.NewReader(configBlob), srcInfo, nil, false)
 		if err != nil {
 			return err
 		}
@@ -494,12 +437,12 @@ type diffIDResult struct {
 // and returns a complete blobInfo of the copied layer, and a value for LayerDiffIDs if diffIDIsNeeded
 func (ic *imageCopier) copyLayer(srcInfo types.BlobInfo) (types.BlobInfo, digest.Digest, error) {
 	// Check if we already have a blob with this digest
-	haveBlob, extantBlobSize, err := ic.c.dest.HasBlob(srcInfo)
+	haveBlob, extantBlobSize, err := ic.dest.HasBlob(srcInfo)
 	if err != nil {
 		return types.BlobInfo{}, "", errors.Wrapf(err, "Error checking for blob %s at destination", srcInfo.Digest)
 	}
 	// If we already have a cached diffID for this blob, we don't need to compute it
-	diffIDIsNeeded := ic.diffIDsAreNeeded && (ic.c.cachedDiffIDs[srcInfo.Digest] == "")
+	diffIDIsNeeded := ic.diffIDsAreNeeded && (ic.cachedDiffIDs[srcInfo.Digest] == "")
 	// If we already have the blob, and we don't need to recompute the diffID, then we might be able to avoid reading it again
 	if haveBlob && !diffIDIsNeeded {
 		// Check the blob sizes match, if we were given a size this time
@@ -508,17 +451,17 @@ func (ic *imageCopier) copyLayer(srcInfo types.BlobInfo) (types.BlobInfo, digest
 		}
 		srcInfo.Size = extantBlobSize
 		// Tell the image destination that this blob's delta is being applied again.  For some image destinations, this can be faster than using GetBlob/PutBlob
-		blobinfo, err := ic.c.dest.ReapplyBlob(srcInfo)
+		blobinfo, err := ic.dest.ReapplyBlob(srcInfo)
 		if err != nil {
 			return types.BlobInfo{}, "", errors.Wrapf(err, "Error reapplying blob %s at destination", srcInfo.Digest)
 		}
-		ic.c.Printf("Skipping fetch of repeat blob %s\n", srcInfo.Digest)
-		return blobinfo, ic.c.cachedDiffIDs[srcInfo.Digest], err
+		fmt.Fprintf(ic.reportWriter, "Skipping fetch of repeat blob %s\n", srcInfo.Digest)
+		return blobinfo, ic.cachedDiffIDs[srcInfo.Digest], err
 	}
 
 	// Fallback: copy the layer, computing the diffID if we need to do so
-	ic.c.Printf("Copying blob %s\n", srcInfo.Digest)
-	srcStream, srcBlobSize, err := ic.c.rawSource.GetBlob(srcInfo)
+	fmt.Fprintf(ic.reportWriter, "Copying blob %s\n", srcInfo.Digest)
+	srcStream, srcBlobSize, err := ic.rawSource.GetBlob(srcInfo)
 	if err != nil {
 		return types.BlobInfo{}, "", errors.Wrapf(err, "Error reading blob %s", srcInfo.Digest)
 	}
@@ -536,7 +479,7 @@ func (ic *imageCopier) copyLayer(srcInfo types.BlobInfo) (types.BlobInfo, digest
 			return types.BlobInfo{}, "", errors.Wrap(diffIDResult.err, "Error computing layer DiffID")
 		}
 		logrus.Debugf("Computed DiffID %s for layer %s", diffIDResult.digest, srcInfo.Digest)
-		ic.c.cachedDiffIDs[srcInfo.Digest] = diffIDResult.digest
+		ic.cachedDiffIDs[srcInfo.Digest] = diffIDResult.digest
 	}
 	return blobInfo, diffIDResult.digest, nil
 }
@@ -570,7 +513,7 @@ func (ic *imageCopier) copyLayerFromStream(srcStream io.Reader, srcInfo types.Bl
 			return pipeWriter
 		}
 	}
-	blobInfo, err := ic.c.copyBlobFromStream(srcStream, srcInfo, getDiffIDRecorder, ic.canModifyManifest) // Sets err to nil on success
+	blobInfo, err := ic.copyBlobFromStream(srcStream, srcInfo, getDiffIDRecorder, ic.canModifyManifest) // Sets err to nil on success
 	return blobInfo, diffIDChan, err
 	// We need the defer … pipeWriter.CloseWithError() to happen HERE so that the caller can block on reading from diffIDChan
 }
@@ -604,7 +547,7 @@ func computeDiffID(stream io.Reader, decompressor compression.DecompressorFunc)
 // perhaps sending a copy to an io.Writer if getOriginalLayerCopyWriter != nil,
 // perhaps compressing it if canCompress,
 // and returns a complete blobInfo of the copied blob.
-func (c *copier) copyBlobFromStream(srcStream io.Reader, srcInfo types.BlobInfo,
+func (ic *imageCopier) copyBlobFromStream(srcStream io.Reader, srcInfo types.BlobInfo,
 	getOriginalLayerCopyWriter func(decompressor compression.DecompressorFunc) io.Writer,
 	canCompress bool) (types.BlobInfo, error) {
 	// The copying happens through a pipeline of connected io.Readers.
@@ -632,7 +575,7 @@ func (c *copier) copyBlobFromStream(srcStream io.Reader, srcInfo types.BlobInfo,
 
 	// === Report progress using a pb.Reader.
 	bar := pb.New(int(srcInfo.Size)).SetUnits(pb.U_BYTES)
-	bar.Output = c.reportWriter
+	bar.Output = ic.reportWriter
 	bar.SetMaxWidth(80)
 	bar.ShowTimeLeft = false
 	bar.ShowPercent = false
@@ -649,7 +592,7 @@ func (c *copier) copyBlobFromStream(srcStream io.Reader, srcInfo types.BlobInfo,
 
 	// === Compress the layer if it is uncompressed and compression is desired
 	var inputInfo types.BlobInfo
-	if !canCompress || isCompressed || !c.dest.ShouldCompressLayers() {
+	if !canCompress || isCompressed || !ic.dest.ShouldCompressLayers() {
 		logrus.Debugf("Using original blob without modification")
 		inputInfo = srcInfo
 	} else {
@@ -666,19 +609,19 @@ func (c *copier) copyBlobFromStream(srcStream io.Reader, srcInfo types.BlobInfo,
 		inputInfo.Size = -1
 	}
 
-	// === Report progress using the c.progress channel, if required.
-	if c.progress != nil && c.progressInterval > 0 {
+	// === Report progress using the ic.progress channel, if required.
+	if ic.progress != nil && ic.progressInterval > 0 {
 		destStream = &progressReader{
 			source:   destStream,
-			channel:  c.progress,
-			interval: c.progressInterval,
+			channel:  ic.progress,
+			interval: ic.progressInterval,
 			artifact: srcInfo,
 			lastTime: time.Now(),
 		}
 	}
 
 	// === Finally, send the layer stream to dest.
-	uploadedInfo, err := c.dest.PutBlob(destStream, inputInfo)
+	uploadedInfo, err := ic.dest.PutBlob(destStream, inputInfo)
 	if err != nil {
 		return types.BlobInfo{}, errors.Wrap(err, "Error writing blob")
 	}

vendor/github.com/containers/image/copy/manifest.go

@@ -37,20 +37,16 @@ func (os *orderedSet) append(s string) {
 	}
 }
 
-// determineManifestConversion updates ic.manifestUpdates to convert manifest to a supported MIME type, if necessary and ic.canModifyManifest.
-// Note that the conversion will only happen later, through ic.src.UpdatedImage
+// determineManifestConversion updates manifestUpdates to convert manifest to a supported MIME type, if necessary and canModifyManifest.
+// Note that the conversion will only happen later, through src.UpdatedImage
 // Returns the preferred manifest MIME type (whether we are converting to it or using it unmodified),
 // and a list of other possible alternatives, in order.
-func (ic *imageCopier) determineManifestConversion(destSupportedManifestMIMETypes []string, forceManifestMIMEType string) (string, []string, error) {
-	_, srcType, err := ic.src.Manifest()
+func determineManifestConversion(manifestUpdates *types.ManifestUpdateOptions, src types.Image, destSupportedManifestMIMETypes []string, canModifyManifest bool) (string, []string, error) {
+	_, srcType, err := src.Manifest()
 	if err != nil { // This should have been cached?!
 		return "", nil, errors.Wrap(err, "Error reading manifest")
 	}
 
-	if forceManifestMIMEType != "" {
-		destSupportedManifestMIMETypes = []string{forceManifestMIMEType}
-	}
-
 	if len(destSupportedManifestMIMETypes) == 0 {
 		return srcType, []string{}, nil // Anything goes; just use the original as is, do not try any conversions.
 	}
@@ -71,10 +67,10 @@ func (ic *imageCopier) determineManifestConversion(destSupportedManifestMIMEType
 	if _, ok := supportedByDest[srcType]; ok {
 		prioritizedTypes.append(srcType)
 	}
-	if !ic.canModifyManifest {
-		// We could also drop the !ic.canModifyManifest check and have the caller
+	if !canModifyManifest {
+		// We could also drop the !canModifyManifest parameter and have the caller
 		// make the choice; it is already doing that to an extent, to improve error
-		// messages.  But it is nice to hide the “if !ic.canModifyManifest, do no conversion”
+		// messages.  But it is nice to hide the “if !canModifyManifest, do no conversion”
 		// special case in here; the caller can then worry (or not) only about a good UI.
 		logrus.Debugf("We can't modify the manifest, hoping for the best...")
 		return srcType, []string{}, nil // Take our chances - FIXME? Or should we fail without trying?
@@ -98,18 +94,9 @@ func (ic *imageCopier) determineManifestConversion(destSupportedManifestMIMEType
 	}
 	preferredType := prioritizedTypes.list[0]
 	if preferredType != srcType {
-		ic.manifestUpdates.ManifestMIMEType = preferredType
+		manifestUpdates.ManifestMIMEType = preferredType
 	} else {
 		logrus.Debugf("... will first try using the original manifest unmodified")
 	}
 	return preferredType, prioritizedTypes.list[1:], nil
 }
-
-// isMultiImage returns true if img is a list of images
-func isMultiImage(img types.UnparsedImage) (bool, error) {
-	_, mt, err := img.Manifest()
-	if err != nil {
-		return false, err
-	}
-	return manifest.MIMETypeIsMultiImage(mt), nil
-}

vendor/github.com/containers/image/copy/sign.go

@@ -1,13 +1,17 @@
 package copy
 
 import (
+	"fmt"
+	"io"
+
 	"github.com/containers/image/signature"
 	"github.com/containers/image/transports"
+	"github.com/containers/image/types"
 	"github.com/pkg/errors"
 )
 
-// createSignature creates a new signature of manifest using keyIdentity.
-func (c *copier) createSignature(manifest []byte, keyIdentity string) ([]byte, error) {
+// createSignature creates a new signature of manifest at (identified by) dest using keyIdentity.
+func createSignature(dest types.ImageDestination, manifest []byte, keyIdentity string, reportWriter io.Writer) ([]byte, error) {
 	mech, err := signature.NewGPGSigningMechanism()
 	if err != nil {
 		return nil, errors.Wrap(err, "Error initializing GPG")
@@ -17,12 +21,12 @@ func (c *copier) createSignature(manifest []byte, keyIdentity string) ([]byte, e
 		return nil, errors.Wrap(err, "Signing not supported")
 	}
 
-	dockerReference := c.dest.Reference().DockerReference()
+	dockerReference := dest.Reference().DockerReference()
 	if dockerReference == nil {
-		return nil, errors.Errorf("Cannot determine canonical Docker reference for destination %s", transports.ImageName(c.dest.Reference()))
+		return nil, errors.Errorf("Cannot determine canonical Docker reference for destination %s", transports.ImageName(dest.Reference()))
 	}
 
-	c.Printf("Signing manifest\n")
+	fmt.Fprintf(reportWriter, "Signing manifest\n")
 	newSig, err := signature.SignDockerManifest(manifest, dockerReference.String(), mech, keyIdentity)
 	if err != nil {
 		return nil, errors.Wrap(err, "Error creating signature")

vendor/github.com/containers/image/directory/directory_dest.go

@@ -4,77 +4,19 @@ import (
 	"io"
 	"io/ioutil"
 	"os"
-	"path/filepath"
 
 	"github.com/containers/image/types"
 	"github.com/opencontainers/go-digest"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
 )
 
-const version = "Directory Transport Version: 1.0\n"
-
-// ErrNotContainerImageDir indicates that the directory doesn't match the expected contents of a directory created
-// using the 'dir' transport
-var ErrNotContainerImageDir = errors.New("not a containers image directory, don't want to overwrite important data")
-
 type dirImageDestination struct {
-	ref      dirReference
-	compress bool
+	ref dirReference
 }
 
-// newImageDestination returns an ImageDestination for writing to a directory.
-func newImageDestination(ref dirReference, compress bool) (types.ImageDestination, error) {
-	d := &dirImageDestination{ref: ref, compress: compress}
-
-	// If directory exists check if it is empty
-	// if not empty, check whether the contents match that of a container image directory and overwrite the contents
-	// if the contents don't match throw an error
-	dirExists, err := pathExists(d.ref.resolvedPath)
-	if err != nil {
-		return nil, errors.Wrapf(err, "error checking for path %q", d.ref.resolvedPath)
-	}
-	if dirExists {
-		isEmpty, err := isDirEmpty(d.ref.resolvedPath)
-		if err != nil {
-			return nil, err
-		}
-
-		if !isEmpty {
-			versionExists, err := pathExists(d.ref.versionPath())
-			if err != nil {
-				return nil, errors.Wrapf(err, "error checking if path exists %q", d.ref.versionPath())
-			}
-			if versionExists {
-				contents, err := ioutil.ReadFile(d.ref.versionPath())
-				if err != nil {
-					return nil, err
-				}
-				// check if contents of version file is what we expect it to be
-				if string(contents) != version {
-					return nil, ErrNotContainerImageDir
-				}
-			} else {
-				return nil, ErrNotContainerImageDir
-			}
-			// delete directory contents so that only one image is in the directory at a time
-			if err = removeDirContents(d.ref.resolvedPath); err != nil {
-				return nil, errors.Wrapf(err, "error erasing contents in %q", d.ref.resolvedPath)
-			}
-			logrus.Debugf("overwriting existing container image directory %q", d.ref.resolvedPath)
-		}
-	} else {
-		// create directory if it doesn't exist
-		if err := os.MkdirAll(d.ref.resolvedPath, 0755); err != nil {
-			return nil, errors.Wrapf(err, "unable to create directory %q", d.ref.resolvedPath)
-		}
-	}
-	// create version file
-	err = ioutil.WriteFile(d.ref.versionPath(), []byte(version), 0755)
-	if err != nil {
-		return nil, errors.Wrapf(err, "error creating version file %q", d.ref.versionPath())
-	}
-	return d, nil
+// newImageDestination returns an ImageDestination for writing to an existing directory.
+func newImageDestination(ref dirReference) types.ImageDestination {
+	return &dirImageDestination{ref}
 }
 
 // Reference returns the reference used to set up this destination.  Note that this should directly correspond to user's intent,
@@ -100,7 +42,7 @@ func (d *dirImageDestination) SupportsSignatures() error {
 
 // ShouldCompressLayers returns true iff it is desirable to compress layer blobs written to this destination.
 func (d *dirImageDestination) ShouldCompressLayers() bool {
-	return d.compress
+	return false
 }
 
 // AcceptsForeignLayerURLs returns false iff foreign layers in manifest should be actually
@@ -205,39 +147,3 @@ func (d *dirImageDestination) PutSignatures(signatures [][]byte) error {
 func (d *dirImageDestination) Commit() error {
 	return nil
 }
-
-// returns true if path exists
-func pathExists(path string) (bool, error) {
-	_, err := os.Stat(path)
-	if err == nil {
-		return true, nil
-	}
-	if err != nil && os.IsNotExist(err) {
-		return false, nil
-	}
-	return false, err
-}
-
-// returns true if directory is empty
-func isDirEmpty(path string) (bool, error) {
-	files, err := ioutil.ReadDir(path)
-	if err != nil {
-		return false, err
-	}
-	return len(files) == 0, nil
-}
-
-// deletes the contents of a directory
-func removeDirContents(path string) error {
-	files, err := ioutil.ReadDir(path)
-	if err != nil {
-		return err
-	}
-
-	for _, file := range files {
-		if err := os.RemoveAll(filepath.Join(path, file.Name())); err != nil {
-			return err
-		}
-	}
-	return nil
-}

vendor/github.com/containers/image/directory/directory_src.go

@@ -35,12 +35,7 @@ func (s *dirImageSource) Close() error {
 
 // GetManifest returns the image's manifest along with its MIME type (which may be empty when it can't be determined but the manifest is available).
 // It may use a remote (= slow) service.
-// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve (when the primary manifest is a manifest list);
-// this never happens if the primary manifest is not a manifest list (e.g. if the source never returns manifest lists).
-func (s *dirImageSource) GetManifest(instanceDigest *digest.Digest) ([]byte, string, error) {
-	if instanceDigest != nil {
-		return nil, "", errors.Errorf(`Getting target manifest not supported by "dir:"`)
-	}
+func (s *dirImageSource) GetManifest() ([]byte, string, error) {
 	m, err := ioutil.ReadFile(s.ref.manifestPath())
 	if err != nil {
 		return nil, "", err
@@ -48,6 +43,10 @@ func (s *dirImageSource) GetManifest(instanceDigest *digest.Digest) ([]byte, str
 	return m, manifest.GuessMIMEType(m), err
 }
 
+func (s *dirImageSource) GetTargetManifest(digest digest.Digest) ([]byte, string, error) {
+	return nil, "", errors.Errorf(`Getting target manifest not supported by "dir:"`)
+}
+
 // GetBlob returns a stream for the specified blob, and the blob’s size (or -1 if unknown).
 func (s *dirImageSource) GetBlob(info types.BlobInfo) (io.ReadCloser, int64, error) {
 	r, err := os.Open(s.ref.layerPath(info.Digest))
@@ -61,14 +60,7 @@ func (s *dirImageSource) GetBlob(info types.BlobInfo) (io.ReadCloser, int64, err
 	return r, fi.Size(), nil
 }
 
-// GetSignatures returns the image's signatures.  It may use a remote (= slow) service.
-// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve signatures for
-// (when the primary manifest is a manifest list); this never happens if the primary manifest is not a manifest list
-// (e.g. if the source never returns manifest lists).
-func (s *dirImageSource) GetSignatures(ctx context.Context, instanceDigest *digest.Digest) ([][]byte, error) {
-	if instanceDigest != nil {
-		return nil, errors.Errorf(`Manifests lists are not supported by "dir:"`)
-	}
+func (s *dirImageSource) GetSignatures(ctx context.Context) ([][]byte, error) {
 	signatures := [][]byte{}
 	for i := 0; ; i++ {
 		signature, err := ioutil.ReadFile(s.ref.signaturePath(i))
@@ -82,8 +74,3 @@ func (s *dirImageSource) GetSignatures(ctx context.Context, instanceDigest *dige
 	}
 	return signatures, nil
 }
-
-// LayerInfosForCopy() returns updated layer info that should be used when copying, in preference to values in the manifest, if specified.
-func (s *dirImageSource) LayerInfosForCopy() []types.BlobInfo {
-	return nil
-}

vendor/github.com/containers/image/directory/directory_transport.go

@@ -134,14 +134,13 @@ func (ref dirReference) PolicyConfigurationNamespaces() []string {
 	return res
 }
 
-// NewImage returns a types.ImageCloser for this reference, possibly specialized for this ImageTransport.
-// The caller must call .Close() on the returned ImageCloser.
+// NewImage returns a types.Image for this reference, possibly specialized for this ImageTransport.
+// The caller must call .Close() on the returned Image.
 // NOTE: If any kind of signature verification should happen, build an UnparsedImage from the value returned by NewImageSource,
 // verify that UnparsedImage, and convert it into a real Image via image.FromUnparsedImage.
-// WARNING: This may not do the right thing for a manifest list, see image.FromSource for details.
-func (ref dirReference) NewImage(ctx *types.SystemContext) (types.ImageCloser, error) {
+func (ref dirReference) NewImage(ctx *types.SystemContext) (types.Image, error) {
 	src := newImageSource(ref)
-	return image.FromSource(ctx, src)
+	return image.FromSource(src)
 }
 
 // NewImageSource returns a types.ImageSource for this reference.
@@ -153,11 +152,7 @@ func (ref dirReference) NewImageSource(ctx *types.SystemContext) (types.ImageSou
 // NewImageDestination returns a types.ImageDestination for this reference.
 // The caller must call .Close() on the returned ImageDestination.
 func (ref dirReference) NewImageDestination(ctx *types.SystemContext) (types.ImageDestination, error) {
-	compress := false
-	if ctx != nil {
-		compress = ctx.DirForceCompress
-	}
-	return newImageDestination(ref, compress)
+	return newImageDestination(ref), nil
 }
 
 // DeleteImage deletes the named image from the registry, if supported.
@@ -180,8 +175,3 @@ func (ref dirReference) layerPath(digest digest.Digest) string {
 func (ref dirReference) signaturePath(index int) string {
 	return filepath.Join(ref.path, fmt.Sprintf("signature-%d", index+1))
 }
-
-// versionPath returns a path for the version file within a directory using our conventions.
-func (ref dirReference) versionPath() string {
-	return filepath.Join(ref.path, "version")
-}

vendor/github.com/containers/image/docker/archive/src.go

@@ -34,8 +34,3 @@ func (s *archiveImageSource) Reference() types.ImageReference {
 func (s *archiveImageSource) Close() error {
 	return nil
 }
-
-// LayerInfosForCopy() returns updated layer info that should be used when reading, in preference to values in the manifest, if specified.
-func (s *archiveImageSource) LayerInfosForCopy() []types.BlobInfo {
-	return nil
-}

vendor/github.com/containers/image/docker/archive/transport.go

@@ -125,14 +125,13 @@ func (ref archiveReference) PolicyConfigurationNamespaces() []string {
 	return []string{}
 }
 
-// NewImage returns a types.ImageCloser for this reference, possibly specialized for this ImageTransport.
-// The caller must call .Close() on the returned ImageCloser.
+// NewImage returns a types.Image for this reference, possibly specialized for this ImageTransport.
+// The caller must call .Close() on the returned Image.
 // NOTE: If any kind of signature verification should happen, build an UnparsedImage from the value returned by NewImageSource,
 // verify that UnparsedImage, and convert it into a real Image via image.FromUnparsedImage.
-// WARNING: This may not do the right thing for a manifest list, see image.FromSource for details.
-func (ref archiveReference) NewImage(ctx *types.SystemContext) (types.ImageCloser, error) {
+func (ref archiveReference) NewImage(ctx *types.SystemContext) (types.Image, error) {
 	src := newImageSource(ctx, ref)
-	return ctrImage.FromSource(ctx, src)
+	return ctrImage.FromSource(src)
 }
 
 // NewImageSource returns a types.ImageSource for this reference.

vendor/github.com/containers/image/docker/daemon/client.go

@@ -1,69 +0,0 @@
-package daemon
-
-import (
-	"net/http"
-	"path/filepath"
-
-	"github.com/containers/image/types"
-	dockerclient "github.com/docker/docker/client"
-	"github.com/docker/go-connections/tlsconfig"
-)
-
-const (
-	// The default API version to be used in case none is explicitly specified
-	defaultAPIVersion = "1.22"
-)
-
-// NewDockerClient initializes a new API client based on the passed SystemContext.
-func newDockerClient(ctx *types.SystemContext) (*dockerclient.Client, error) {
-	host := dockerclient.DefaultDockerHost
-	if ctx != nil && ctx.DockerDaemonHost != "" {
-		host = ctx.DockerDaemonHost
-	}
-
-	// Sadly, unix:// sockets don't work transparently with dockerclient.NewClient.
-	// They work fine with a nil httpClient; with a non-nil httpClient, the transport’s
-	// TLSClientConfig must be nil (or the client will try using HTTPS over the PF_UNIX socket
-	// regardless of the values in the *tls.Config), and we would have to call sockets.ConfigureTransport.
-	//
-	// We don't really want to configure anything for unix:// sockets, so just pass a nil *http.Client.
-	proto, _, _, err := dockerclient.ParseHost(host)
-	if err != nil {
-		return nil, err
-	}
-	var httpClient *http.Client
-	if proto != "unix" {
-		hc, err := tlsConfig(ctx)
-		if err != nil {
-			return nil, err
-		}
-		httpClient = hc
-	}
-
-	return dockerclient.NewClient(host, defaultAPIVersion, httpClient, nil)
-}
-
-func tlsConfig(ctx *types.SystemContext) (*http.Client, error) {
-	options := tlsconfig.Options{}
-	if ctx != nil && ctx.DockerDaemonInsecureSkipTLSVerify {
-		options.InsecureSkipVerify = true
-	}
-
-	if ctx != nil && ctx.DockerDaemonCertPath != "" {
-		options.CAFile = filepath.Join(ctx.DockerDaemonCertPath, "ca.pem")
-		options.CertFile = filepath.Join(ctx.DockerDaemonCertPath, "cert.pem")
-		options.KeyFile = filepath.Join(ctx.DockerDaemonCertPath, "key.pem")
-	}
-
-	tlsc, err := tlsconfig.Client(options)
-	if err != nil {
-		return nil, err
-	}
-
-	return &http.Client{
-		Transport: &http.Transport{
-			TLSClientConfig: tlsc,
-		},
-		CheckRedirect: dockerclient.CheckRedirect,
-	}, nil
-}

vendor/github.com/containers/image/docker/daemon/daemon_dest.go

@@ -14,7 +14,6 @@ import (
 
 type daemonImageDestination struct {
 	ref                  daemonReference
-	mustMatchRuntimeOS   bool
 	*tarfile.Destination // Implements most of types.ImageDestination
 	// For talking to imageLoadGoroutine
 	goroutineCancel context.CancelFunc
@@ -25,7 +24,7 @@ type daemonImageDestination struct {
 }
 
 // newImageDestination returns a types.ImageDestination for the specified image reference.
-func newImageDestination(ctx *types.SystemContext, ref daemonReference) (types.ImageDestination, error) {
+func newImageDestination(systemCtx *types.SystemContext, ref daemonReference) (types.ImageDestination, error) {
 	if ref.ref == nil {
 		return nil, errors.Errorf("Invalid destination docker-daemon:%s: a destination must be a name:tag", ref.StringWithinTransport())
 	}
@@ -34,12 +33,7 @@ func newImageDestination(ctx *types.SystemContext, ref daemonReference) (types.I
 		return nil, errors.Errorf("Invalid destination docker-daemon:%s: a destination must be a name:tag", ref.StringWithinTransport())
 	}
 
-	var mustMatchRuntimeOS = true
-	if ctx != nil && ctx.DockerDaemonHost != client.DefaultDockerHost {
-		mustMatchRuntimeOS = false
-	}
-
-	c, err := newDockerClient(ctx)
+	c, err := client.NewClient(client.DefaultDockerHost, "1.22", nil, nil) // FIXME: overridable host
 	if err != nil {
 		return nil, errors.Wrap(err, "Error initializing docker engine client")
 	}
@@ -48,17 +42,16 @@ func newImageDestination(ctx *types.SystemContext, ref daemonReference) (types.I
 	// Commit() may never be called, so we may never read from this channel; so, make this buffered to allow imageLoadGoroutine to write status and terminate even if we never read it.
 	statusChannel := make(chan error, 1)
 
-	goroutineContext, goroutineCancel := context.WithCancel(context.Background())
-	go imageLoadGoroutine(goroutineContext, c, reader, statusChannel)
+	ctx, goroutineCancel := context.WithCancel(context.Background())
+	go imageLoadGoroutine(ctx, c, reader, statusChannel)
 
 	return &daemonImageDestination{
-		ref:                ref,
-		mustMatchRuntimeOS: mustMatchRuntimeOS,
-		Destination:        tarfile.NewDestination(writer, namedTaggedRef),
-		goroutineCancel:    goroutineCancel,
-		statusChannel:      statusChannel,
-		writer:             writer,
-		committed:          false,
+		ref:             ref,
+		Destination:     tarfile.NewDestination(writer, namedTaggedRef),
+		goroutineCancel: goroutineCancel,
+		statusChannel:   statusChannel,
+		writer:          writer,
+		committed:       false,
 	}, nil
 }
 
@@ -87,7 +80,7 @@ func imageLoadGoroutine(ctx context.Context, c *client.Client, reader *io.PipeRe
 
 // MustMatchRuntimeOS returns true iff the destination can store only images targeted for the current runtime OS. False otherwise.
 func (d *daemonImageDestination) MustMatchRuntimeOS() bool {
-	return d.mustMatchRuntimeOS
+	return true
 }
 
 // Close removes resources associated with an initialized ImageDestination, if any.

vendor/github.com/containers/image/docker/daemon/daemon_src.go

@@ -6,12 +6,14 @@ import (
 	"os"
 
 	"github.com/containers/image/docker/tarfile"
-	"github.com/containers/image/internal/tmpdir"
 	"github.com/containers/image/types"
+	"github.com/docker/docker/client"
 	"github.com/pkg/errors"
 	"golang.org/x/net/context"
 )
 
+const temporaryDirectoryForBigFiles = "/var/tmp" // Do not use the system default of os.TempDir(), usually /tmp, because with systemd it could be a tmpfs.
+
 type daemonImageSource struct {
 	ref             daemonReference
 	*tarfile.Source // Implements most of types.ImageSource
@@ -33,7 +35,7 @@ type layerInfo struct {
 // is the config, and that the following len(RootFS) files are the layers, but that feels
 // way too brittle.)
 func newImageSource(ctx *types.SystemContext, ref daemonReference) (types.ImageSource, error) {
-	c, err := newDockerClient(ctx)
+	c, err := client.NewClient(client.DefaultDockerHost, "1.22", nil, nil) // FIXME: overridable host
 	if err != nil {
 		return nil, errors.Wrap(err, "Error initializing docker engine client")
 	}
@@ -46,7 +48,7 @@ func newImageSource(ctx *types.SystemContext, ref daemonReference) (types.ImageS
 	defer inputStream.Close()
 
 	// FIXME: use SystemContext here.
-	tarCopyFile, err := ioutil.TempFile(tmpdir.TemporaryDirectoryForBigFiles(), "docker-daemon-tar")
+	tarCopyFile, err := ioutil.TempFile(temporaryDirectoryForBigFiles, "docker-daemon-tar")
 	if err != nil {
 		return nil, err
 	}
@@ -81,8 +83,3 @@ func (s *daemonImageSource) Reference() types.ImageReference {
 func (s *daemonImageSource) Close() error {
 	return os.Remove(s.tarCopyPath)
 }
-
-// LayerInfosForCopy() returns updated layer info that should be used when reading, in preference to values in the manifest, if specified.
-func (s *daemonImageSource) LayerInfosForCopy() []types.BlobInfo {
-	return nil
-}

vendor/github.com/containers/image/docker/daemon/daemon_transport.go

@@ -151,17 +151,14 @@ func (ref daemonReference) PolicyConfigurationNamespaces() []string {
 	return []string{}
 }
 
-// NewImage returns a types.ImageCloser for this reference, possibly specialized for this ImageTransport.
-// The caller must call .Close() on the returned ImageCloser.
-// NOTE: If any kind of signature verification should happen, build an UnparsedImage from the value returned by NewImageSource,
-// verify that UnparsedImage, and convert it into a real Image via image.FromUnparsedImage.
-// WARNING: This may not do the right thing for a manifest list, see image.FromSource for details.
-func (ref daemonReference) NewImage(ctx *types.SystemContext) (types.ImageCloser, error) {
+// NewImage returns a types.Image for this reference.
+// The caller must call .Close() on the returned Image.
+func (ref daemonReference) NewImage(ctx *types.SystemContext) (types.Image, error) {
 	src, err := newImageSource(ctx, ref)
 	if err != nil {
 		return nil, err
 	}
-	return image.FromSource(ctx, src)
+	return image.FromSource(src)
 }
 
 // NewImageSource returns a types.ImageSource for this reference.

vendor/github.com/containers/image/docker/docker_client.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"io/ioutil"
 	"net/http"
+	"os"
 	"path/filepath"
 	"strings"
 	"time"
@@ -124,6 +125,69 @@ func dockerCertDir(ctx *types.SystemContext, hostPort string) string {
 	return filepath.Join(hostCertDir, hostPort)
 }
 
+func setupCertificates(dir string, tlsc *tls.Config) error {
+	logrus.Debugf("Looking for TLS certificates and private keys in %s", dir)
+	fs, err := ioutil.ReadDir(dir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		if os.IsPermission(err) {
+			logrus.Debugf("Skipping scan of %s due to permission error: %v", dir, err)
+			return nil
+		}
+		return err
+	}
+
+	for _, f := range fs {
+		fullPath := filepath.Join(dir, f.Name())
+		if strings.HasSuffix(f.Name(), ".crt") {
+			systemPool, err := tlsconfig.SystemCertPool()
+			if err != nil {
+				return errors.Wrap(err, "unable to get system cert pool")
+			}
+			tlsc.RootCAs = systemPool
+			logrus.Debugf(" crt: %s", fullPath)
+			data, err := ioutil.ReadFile(fullPath)
+			if err != nil {
+				return err
+			}
+			tlsc.RootCAs.AppendCertsFromPEM(data)
+		}
+		if strings.HasSuffix(f.Name(), ".cert") {
+			certName := f.Name()
+			keyName := certName[:len(certName)-5] + ".key"
+			logrus.Debugf(" cert: %s", fullPath)
+			if !hasFile(fs, keyName) {
+				return errors.Errorf("missing key %s for client certificate %s. Note that CA certificates should use the extension .crt", keyName, certName)
+			}
+			cert, err := tls.LoadX509KeyPair(filepath.Join(dir, certName), filepath.Join(dir, keyName))
+			if err != nil {
+				return err
+			}
+			tlsc.Certificates = append(tlsc.Certificates, cert)
+		}
+		if strings.HasSuffix(f.Name(), ".key") {
+			keyName := f.Name()
+			certName := keyName[:len(keyName)-4] + ".cert"
+			logrus.Debugf(" key: %s", fullPath)
+			if !hasFile(fs, certName) {
+				return errors.Errorf("missing client certificate %s for key %s", certName, keyName)
+			}
+		}
+	}
+	return nil
+}
+
+func hasFile(files []os.FileInfo, name string) bool {
+	for _, f := range files {
+		if f.Name() == name {
+			return true
+		}
+	}
+	return false
+}
+
 // newDockerClientFromRef returns a new dockerClient instance for refHostname (a host a specified in the Docker image reference, not canonicalized to dockerRegistry)
 // “write” specifies whether the client will be used for "write" access (in particular passed to lookaside.go:toplevelFromSection)
 func newDockerClientFromRef(ctx *types.SystemContext, ref dockerReference, write bool, actions string) (*dockerClient, error) {

vendor/github.com/containers/image/docker/docker_image.go

@@ -12,26 +12,26 @@ import (
 	"github.com/pkg/errors"
 )
 
-// Image is a Docker-specific implementation of types.ImageCloser with a few extra methods
+// Image is a Docker-specific implementation of types.Image with a few extra methods
 // which are specific to Docker.
 type Image struct {
-	types.ImageCloser
+	types.Image
 	src *dockerImageSource
 }
 
 // newImage returns a new Image interface type after setting up
 // a client to the registry hosting the given image.
 // The caller must call .Close() on the returned Image.
-func newImage(ctx *types.SystemContext, ref dockerReference) (types.ImageCloser, error) {
+func newImage(ctx *types.SystemContext, ref dockerReference) (types.Image, error) {
 	s, err := newImageSource(ctx, ref)
 	if err != nil {
 		return nil, err
 	}
-	img, err := image.FromSource(ctx, s)
+	img, err := image.FromSource(s)
 	if err != nil {
 		return nil, err
 	}
-	return &Image{ImageCloser: img, src: s}, nil
+	return &Image{Image: img, src: s}, nil
 }
 
 // SourceRefFullName returns a fully expanded name for the repository this image is in.

vendor/github.com/containers/image/docker/docker_image_dest.go

@@ -236,7 +236,7 @@ func (d *dockerImageDestination) PutManifest(m []byte) error {
 		return err
 	}
 	defer res.Body.Close()
-	if !successStatus(res.StatusCode) {
+	if res.StatusCode != http.StatusCreated {
 		err = errors.Wrapf(client.HandleErrorResponse(res), "Error uploading manifest to %s", path)
 		if isManifestInvalidError(errors.Cause(err)) {
 			err = types.ManifestTypeRejectedError{Err: err}
@@ -246,12 +246,6 @@ func (d *dockerImageDestination) PutManifest(m []byte) error {
 	return nil
 }
 
-// successStatus returns true if the argument is a successful HTTP response
-// code (in the range 200 - 399 inclusive).
-func successStatus(status int) bool {
-	return status >= 200 && status <= 399
-}
-
 // isManifestInvalidError returns true iff err from client.HandleErrorReponse is a “manifest invalid” error.
 func isManifestInvalidError(err error) bool {
 	errors, ok := err.(errcode.Errors)

vendor/github.com/containers/image/docker/docker_image_src.go

@@ -52,11 +52,6 @@ func (s *dockerImageSource) Close() error {
 	return nil
 }
 
-// LayerInfosForCopy() returns updated layer info that should be used when reading, in preference to values in the manifest, if specified.
-func (s *dockerImageSource) LayerInfosForCopy() []types.BlobInfo {
-	return nil
-}
-
 // simplifyContentType drops parameters from a HTTP media type (see https://tools.ietf.org/html/rfc7231#section-3.1.1.1)
 // Alternatively, an empty string is returned unchanged, and invalid values are "simplified" to an empty string.
 func simplifyContentType(contentType string) string {
@@ -72,12 +67,7 @@ func simplifyContentType(contentType string) string {
 
 // GetManifest returns the image's manifest along with its MIME type (which may be empty when it can't be determined but the manifest is available).
 // It may use a remote (= slow) service.
-// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve (when the primary manifest is a manifest list);
-// this never happens if the primary manifest is not a manifest list (e.g. if the source never returns manifest lists).
-func (s *dockerImageSource) GetManifest(instanceDigest *digest.Digest) ([]byte, string, error) {
-	if instanceDigest != nil {
-		return s.fetchManifest(context.TODO(), instanceDigest.String())
-	}
+func (s *dockerImageSource) GetManifest() ([]byte, string, error) {
 	err := s.ensureManifestIsLoaded(context.TODO())
 	if err != nil {
 		return nil, "", err
@@ -104,12 +94,18 @@ func (s *dockerImageSource) fetchManifest(ctx context.Context, tagOrDigest strin
 	return manblob, simplifyContentType(res.Header.Get("Content-Type")), nil
 }
 
+// GetTargetManifest returns an image's manifest given a digest.
+// This is mainly used to retrieve a single image's manifest out of a manifest list.
+func (s *dockerImageSource) GetTargetManifest(digest digest.Digest) ([]byte, string, error) {
+	return s.fetchManifest(context.TODO(), digest.String())
+}
+
 // ensureManifestIsLoaded sets s.cachedManifest and s.cachedManifestMIMEType
 //
 // ImageSource implementations are not required or expected to do any caching,
 // but because our signatures are “attached” to the manifest digest,
-// we need to ensure that the digest of the manifest returned by GetManifest(nil)
-// and used by GetSignatures(ctx, nil) are consistent, otherwise we would get spurious
+// we need to ensure that the digest of the manifest returned by GetManifest
+// and used by GetSignatures are consistent, otherwise we would get spurious
 // signature verification failures when pulling while a tag is being updated.
 func (s *dockerImageSource) ensureManifestIsLoaded(ctx context.Context) error {
 	if s.cachedManifest != nil {
@@ -180,30 +176,22 @@ func (s *dockerImageSource) GetBlob(info types.BlobInfo) (io.ReadCloser, int64,
 	return res.Body, getBlobSize(res), nil
 }
 
-// GetSignatures returns the image's signatures.  It may use a remote (= slow) service.
-// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve signatures for
-// (when the primary manifest is a manifest list); this never happens if the primary manifest is not a manifest list
-// (e.g. if the source never returns manifest lists).
-func (s *dockerImageSource) GetSignatures(ctx context.Context, instanceDigest *digest.Digest) ([][]byte, error) {
+func (s *dockerImageSource) GetSignatures(ctx context.Context) ([][]byte, error) {
 	if err := s.c.detectProperties(ctx); err != nil {
 		return nil, err
 	}
 	switch {
 	case s.c.signatureBase != nil:
-		return s.getSignaturesFromLookaside(ctx, instanceDigest)
+		return s.getSignaturesFromLookaside(ctx)
 	case s.c.supportsSignatures:
-		return s.getSignaturesFromAPIExtension(ctx, instanceDigest)
+		return s.getSignaturesFromAPIExtension(ctx)
 	default:
 		return [][]byte{}, nil
 	}
 }
 
-// manifestDigest returns a digest of the manifest, from instanceDigest if non-nil; or from the supplied reference,
-// or finally, from a fetched manifest.
-func (s *dockerImageSource) manifestDigest(ctx context.Context, instanceDigest *digest.Digest) (digest.Digest, error) {
-	if instanceDigest != nil {
-		return *instanceDigest, nil
-	}
+// manifestDigest returns a digest of the manifest, either from the supplied reference or from a fetched manifest.
+func (s *dockerImageSource) manifestDigest(ctx context.Context) (digest.Digest, error) {
 	if digested, ok := s.ref.ref.(reference.Digested); ok {
 		d := digested.Digest()
 		if d.Algorithm() == digest.Canonical {
@@ -218,8 +206,8 @@ func (s *dockerImageSource) manifestDigest(ctx context.Context, instanceDigest *
 
 // getSignaturesFromLookaside implements GetSignatures() from the lookaside location configured in s.c.signatureBase,
 // which is not nil.
-func (s *dockerImageSource) getSignaturesFromLookaside(ctx context.Context, instanceDigest *digest.Digest) ([][]byte, error) {
-	manifestDigest, err := s.manifestDigest(ctx, instanceDigest)
+func (s *dockerImageSource) getSignaturesFromLookaside(ctx context.Context) ([][]byte, error) {
+	manifestDigest, err := s.manifestDigest(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -288,8 +276,8 @@ func (s *dockerImageSource) getOneSignature(ctx context.Context, url *url.URL) (
 }
 
 // getSignaturesFromAPIExtension implements GetSignatures() using the X-Registry-Supports-Signatures API extension.
-func (s *dockerImageSource) getSignaturesFromAPIExtension(ctx context.Context, instanceDigest *digest.Digest) ([][]byte, error) {
-	manifestDigest, err := s.manifestDigest(ctx, instanceDigest)
+func (s *dockerImageSource) getSignaturesFromAPIExtension(ctx context.Context) ([][]byte, error) {
+	manifestDigest, err := s.manifestDigest(ctx)
 	if err != nil {
 		return nil, err
 	}

vendor/github.com/containers/image/docker/docker_transport.go

@@ -122,12 +122,11 @@ func (ref dockerReference) PolicyConfigurationNamespaces() []string {
 	return policyconfiguration.DockerReferenceNamespaces(ref.ref)
 }
 
-// NewImage returns a types.ImageCloser for this reference, possibly specialized for this ImageTransport.
-// The caller must call .Close() on the returned ImageCloser.
+// NewImage returns a types.Image for this reference, possibly specialized for this ImageTransport.
+// The caller must call .Close() on the returned Image.
 // NOTE: If any kind of signature verification should happen, build an UnparsedImage from the value returned by NewImageSource,
 // verify that UnparsedImage, and convert it into a real Image via image.FromUnparsedImage.
-// WARNING: This may not do the right thing for a manifest list, see image.FromSource for details.
-func (ref dockerReference) NewImage(ctx *types.SystemContext) (types.ImageCloser, error) {
+func (ref dockerReference) NewImage(ctx *types.SystemContext) (types.Image, error) {
 	return newImage(ctx, ref)
 }
 

vendor/github.com/containers/image/docker/tarfile/dest.go

@@ -11,7 +11,6 @@ import (
 	"time"
 
 	"github.com/containers/image/docker/reference"
-	"github.com/containers/image/internal/tmpdir"
 	"github.com/containers/image/manifest"
 	"github.com/containers/image/types"
 	"github.com/opencontainers/go-digest"
@@ -19,6 +18,8 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
+const temporaryDirectoryForBigFiles = "/var/tmp" // Do not use the system default of os.TempDir(), usually /tmp, because with systemd it could be a tmpfs.
+
 // Destination is a partial implementation of types.ImageDestination for writing to an io.Writer.
 type Destination struct {
 	writer  io.Writer
@@ -106,7 +107,7 @@ func (d *Destination) PutBlob(stream io.Reader, inputInfo types.BlobInfo) (types
 
 	if inputInfo.Size == -1 { // Ouch, we need to stream the blob into a temporary file just to determine the size.
 		logrus.Debugf("docker tarfile: input with unknown size, streaming to disk first ...")
-		streamCopy, err := ioutil.TempFile(tmpdir.TemporaryDirectoryForBigFiles(), "docker-tarfile-blob")
+		streamCopy, err := ioutil.TempFile(temporaryDirectoryForBigFiles, "docker-tarfile-blob")
 		if err != nil {
 			return types.BlobInfo{}, err
 		}
@@ -167,7 +168,7 @@ func (d *Destination) ReapplyBlob(info types.BlobInfo) (types.BlobInfo, error) {
 func (d *Destination) PutManifest(m []byte) error {
 	// We do not bother with types.ManifestTypeRejectedError; our .SupportedManifestMIMETypes() above is already providing only one alternative,
 	// so the caller trying a different manifest kind would be pointless.
-	var man manifest.Schema2
+	var man schema2Manifest
 	if err := json.Unmarshal(m, &man); err != nil {
 		return errors.Wrap(err, "Error parsing manifest")
 	}
@@ -176,12 +177,12 @@ func (d *Destination) PutManifest(m []byte) error {
 	}
 
 	layerPaths := []string{}
-	for _, l := range man.LayersDescriptors {
+	for _, l := range man.Layers {
 		layerPaths = append(layerPaths, l.Digest.String())
 	}
 
 	items := []ManifestItem{{
-		Config:       man.ConfigDescriptor.Digest.String(),
+		Config:       man.Config.Digest.String(),
 		RepoTags:     []string{d.repoTag},
 		Layers:       layerPaths,
 		Parent:       "",

vendor/github.com/containers/image/docker/tarfile/src.go

@@ -24,8 +24,8 @@ type Source struct {
 	tarManifest       *ManifestItem // nil if not available yet.
 	configBytes       []byte
 	configDigest      digest.Digest
-	orderedDiffIDList []digest.Digest
-	knownLayers       map[digest.Digest]*layerInfo
+	orderedDiffIDList []diffID
+	knownLayers       map[diffID]*layerInfo
 	// Other state
 	generatedManifest []byte // Private cache for GetManifest(), nil if not set yet.
 }
@@ -156,7 +156,7 @@ func (s *Source) ensureCachedDataIsPresent() error {
 	if err != nil {
 		return err
 	}
-	var parsedConfig manifest.Schema2Image // There's a lot of info there, but we only really care about layer DiffIDs.
+	var parsedConfig image // Most fields ommitted, we only care about layer DiffIDs.
 	if err := json.Unmarshal(configBytes, &parsedConfig); err != nil {
 		return errors.Wrapf(err, "Error decoding tar config %s", tarManifest[0].Config)
 	}
@@ -194,12 +194,12 @@ func (s *Source) LoadTarManifest() ([]ManifestItem, error) {
 	return s.loadTarManifest()
 }
 
-func (s *Source) prepareLayerData(tarManifest *ManifestItem, parsedConfig *manifest.Schema2Image) (map[digest.Digest]*layerInfo, error) {
+func (s *Source) prepareLayerData(tarManifest *ManifestItem, parsedConfig *image) (map[diffID]*layerInfo, error) {
 	// Collect layer data available in manifest and config.
 	if len(tarManifest.Layers) != len(parsedConfig.RootFS.DiffIDs) {
 		return nil, errors.Errorf("Inconsistent layer count: %d in manifest, %d in config", len(tarManifest.Layers), len(parsedConfig.RootFS.DiffIDs))
 	}
-	knownLayers := map[digest.Digest]*layerInfo{}
+	knownLayers := map[diffID]*layerInfo{}
 	unknownLayerSizes := map[string]*layerInfo{} // Points into knownLayers, a "to do list" of items with unknown sizes.
 	for i, diffID := range parsedConfig.RootFS.DiffIDs {
 		if _, ok := knownLayers[diffID]; ok {
@@ -249,34 +249,28 @@ func (s *Source) prepareLayerData(tarManifest *ManifestItem, parsedConfig *manif
 
 // GetManifest returns the image's manifest along with its MIME type (which may be empty when it can't be determined but the manifest is available).
 // It may use a remote (= slow) service.
-// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve (when the primary manifest is a manifest list);
-// this never happens if the primary manifest is not a manifest list (e.g. if the source never returns manifest lists).
-func (s *Source) GetManifest(instanceDigest *digest.Digest) ([]byte, string, error) {
-	if instanceDigest != nil {
-		// How did we even get here? GetManifest(nil) has returned a manifest.DockerV2Schema2MediaType.
-		return nil, "", errors.Errorf(`Manifest lists are not supported by "docker-daemon:"`)
-	}
+func (s *Source) GetManifest() ([]byte, string, error) {
 	if s.generatedManifest == nil {
 		if err := s.ensureCachedDataIsPresent(); err != nil {
 			return nil, "", err
 		}
-		m := manifest.Schema2{
+		m := schema2Manifest{
 			SchemaVersion: 2,
 			MediaType:     manifest.DockerV2Schema2MediaType,
-			ConfigDescriptor: manifest.Schema2Descriptor{
+			Config: distributionDescriptor{
 				MediaType: manifest.DockerV2Schema2ConfigMediaType,
 				Size:      int64(len(s.configBytes)),
 				Digest:    s.configDigest,
 			},
-			LayersDescriptors: []manifest.Schema2Descriptor{},
+			Layers: []distributionDescriptor{},
 		}
 		for _, diffID := range s.orderedDiffIDList {
 			li, ok := s.knownLayers[diffID]
 			if !ok {
 				return nil, "", errors.Errorf("Internal inconsistency: Information about layer %s missing", diffID)
 			}
-			m.LayersDescriptors = append(m.LayersDescriptors, manifest.Schema2Descriptor{
-				Digest:    diffID, // diffID is a digest of the uncompressed tarball
+			m.Layers = append(m.Layers, distributionDescriptor{
+				Digest:    digest.Digest(diffID), // diffID is a digest of the uncompressed tarball
 				MediaType: manifest.DockerV2Schema2LayerMediaType,
 				Size:      li.size,
 			})
@@ -290,6 +284,13 @@ func (s *Source) GetManifest(instanceDigest *digest.Digest) ([]byte, string, err
 	return s.generatedManifest, manifest.DockerV2Schema2MediaType, nil
 }
 
+// GetTargetManifest returns an image's manifest given a digest. This is mainly used to retrieve a single image's manifest
+// out of a manifest list.
+func (s *Source) GetTargetManifest(digest digest.Digest) ([]byte, string, error) {
+	// How did we even get here? GetManifest() above has returned a manifest.DockerV2Schema2MediaType.
+	return nil, "", errors.Errorf(`Manifest lists are not supported by "docker-daemon:"`)
+}
+
 type readCloseWrapper struct {
 	io.Reader
 	closeFunc func() error
@@ -312,7 +313,7 @@ func (s *Source) GetBlob(info types.BlobInfo) (io.ReadCloser, int64, error) {
 		return ioutil.NopCloser(bytes.NewReader(s.configBytes)), int64(len(s.configBytes)), nil
 	}
 
-	if li, ok := s.knownLayers[info.Digest]; ok { // diffID is a digest of the uncompressed tarball,
+	if li, ok := s.knownLayers[diffID(info.Digest)]; ok { // diffID is a digest of the uncompressed tarball,
 		stream, err := s.openTarComponent(li.path)
 		if err != nil {
 			return nil, 0, err
@@ -354,13 +355,6 @@ func (s *Source) GetBlob(info types.BlobInfo) (io.ReadCloser, int64, error) {
 }
 
 // GetSignatures returns the image's signatures.  It may use a remote (= slow) service.
-// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve signatures for
-// (when the primary manifest is a manifest list); this never happens if the primary manifest is not a manifest list
-// (e.g. if the source never returns manifest lists).
-func (s *Source) GetSignatures(ctx context.Context, instanceDigest *digest.Digest) ([][]byte, error) {
-	if instanceDigest != nil {
-		// How did we even get here? GetManifest(nil) has returned a manifest.DockerV2Schema2MediaType.
-		return nil, errors.Errorf(`Manifest lists are not supported by "docker-daemon:"`)
-	}
+func (s *Source) GetSignatures(ctx context.Context) ([][]byte, error) {
 	return [][]byte{}, nil
 }

vendor/github.com/containers/image/docker/tarfile/types.go

@@ -1,9 +1,6 @@
 package tarfile
 
-import (
-	"github.com/containers/image/manifest"
-	"github.com/opencontainers/go-digest"
-)
+import "github.com/opencontainers/go-digest"
 
 // Various data structures.
 
@@ -21,8 +18,37 @@ type ManifestItem struct {
 	Config       string
 	RepoTags     []string
 	Layers       []string
-	Parent       imageID                                      `json:",omitempty"`
-	LayerSources map[digest.Digest]manifest.Schema2Descriptor `json:",omitempty"`
+	Parent       imageID                           `json:",omitempty"`
+	LayerSources map[diffID]distributionDescriptor `json:",omitempty"`
 }
 
 type imageID string
+type diffID digest.Digest
+
+// Based on github.com/docker/distribution/blobs.go
+type distributionDescriptor struct {
+	MediaType string        `json:"mediaType,omitempty"`
+	Size      int64         `json:"size,omitempty"`
+	Digest    digest.Digest `json:"digest,omitempty"`
+	URLs      []string      `json:"urls,omitempty"`
+}
+
+// Based on github.com/docker/distribution/manifest/schema2/manifest.go
+// FIXME: We are repeating this all over the place; make a public copy?
+type schema2Manifest struct {
+	SchemaVersion int                      `json:"schemaVersion"`
+	MediaType     string                   `json:"mediaType,omitempty"`
+	Config        distributionDescriptor   `json:"config"`
+	Layers        []distributionDescriptor `json:"layers"`
+}
+
+// Based on github.com/docker/docker/image/image.go
+// MOST CONTENT OMITTED AS UNNECESSARY
+type image struct {
+	RootFS *rootFS `json:"rootfs,omitempty"`
+}
+
+type rootFS struct {
+	Type    string   `json:"type"`
+	DiffIDs []diffID `json:"diff_ids,omitempty"`
+}

vendor/github.com/containers/image/image/docker_list.go

@@ -2,7 +2,6 @@ package image
 
 import (
 	"encoding/json"
-	"fmt"
 	"runtime"
 
 	"github.com/containers/image/manifest"
@@ -22,7 +21,7 @@ type platformSpec struct {
 
 // A manifestDescriptor references a platform-specific manifest.
 type manifestDescriptor struct {
-	manifest.Schema2Descriptor
+	descriptor
 	Platform platformSpec `json:"platform"`
 }
 
@@ -32,36 +31,22 @@ type manifestList struct {
 	Manifests     []manifestDescriptor `json:"manifests"`
 }
 
-// chooseDigestFromManifestList parses blob as a schema2 manifest list,
-// and returns the digest of the image appropriate for the current environment.
-func chooseDigestFromManifestList(ctx *types.SystemContext, blob []byte) (digest.Digest, error) {
-	wantedArch := runtime.GOARCH
-	if ctx != nil && ctx.ArchitectureChoice != "" {
-		wantedArch = ctx.ArchitectureChoice
-	}
-	wantedOS := runtime.GOOS
-	if ctx != nil && ctx.OSChoice != "" {
-		wantedOS = ctx.OSChoice
-	}
-
+func manifestSchema2FromManifestList(src types.ImageSource, manblob []byte) (genericManifest, error) {
 	list := manifestList{}
-	if err := json.Unmarshal(blob, &list); err != nil {
-		return "", err
-	}
-	for _, d := range list.Manifests {
-		if d.Platform.Architecture == wantedArch && d.Platform.OS == wantedOS {
-			return d.Digest, nil
-		}
-	}
-	return "", fmt.Errorf("no image found in manifest list for architecture %s, OS %s", wantedArch, wantedOS)
-}
-
-func manifestSchema2FromManifestList(ctx *types.SystemContext, src types.ImageSource, manblob []byte) (genericManifest, error) {
-	targetManifestDigest, err := chooseDigestFromManifestList(ctx, manblob)
-	if err != nil {
+	if err := json.Unmarshal(manblob, &list); err != nil {
 		return nil, err
 	}
-	manblob, mt, err := src.GetManifest(&targetManifestDigest)
+	var targetManifestDigest digest.Digest
+	for _, d := range list.Manifests {
+		if d.Platform.Architecture == runtime.GOARCH && d.Platform.OS == runtime.GOOS {
+			targetManifestDigest = d.Digest
+			break
+		}
+	}
+	if targetManifestDigest == "" {
+		return nil, errors.New("no supported platform found in manifest list")
+	}
+	manblob, mt, err := src.GetTargetManifest(targetManifestDigest)
 	if err != nil {
 		return nil, err
 	}
@@ -74,20 +59,5 @@ func manifestSchema2FromManifestList(ctx *types.SystemContext, src types.ImageSo
 		return nil, errors.Errorf("Manifest image does not match selected manifest digest %s", targetManifestDigest)
 	}
 
-	return manifestInstanceFromBlob(ctx, src, manblob, mt)
-}
-
-// ChooseManifestInstanceFromManifestList returns a digest of a manifest appropriate
-// for the current system from the manifest available from src.
-func ChooseManifestInstanceFromManifestList(ctx *types.SystemContext, src types.UnparsedImage) (digest.Digest, error) {
-	// For now this only handles manifest.DockerV2ListMediaType; we can generalize it later,
-	// probably along with manifest list editing.
-	blob, mt, err := src.Manifest()
-	if err != nil {
-		return "", err
-	}
-	if mt != manifest.DockerV2ListMediaType {
-		return "", fmt.Errorf("Internal error: Trying to select an image from a non-manifest-list manifest type %s", mt)
-	}
-	return chooseDigestFromManifestList(ctx, blob)
+	return manifestInstanceFromBlob(src, manblob, mt)
 }

vendor/github.com/containers/image/image/docker_schema1.go

@@ -2,6 +2,9 @@ package image
 
 import (
 	"encoding/json"
+	"regexp"
+	"strings"
+	"time"
 
 	"github.com/containers/image/docker/reference"
 	"github.com/containers/image/manifest"
@@ -11,25 +14,87 @@ import (
 	"github.com/pkg/errors"
 )
 
-type manifestSchema1 struct {
-	m *manifest.Schema1
+var (
+	validHex = regexp.MustCompile(`^([a-f0-9]{64})$`)
+)
+
+type fsLayersSchema1 struct {
+	BlobSum digest.Digest `json:"blobSum"`
 }
 
-func manifestSchema1FromManifest(manifestBlob []byte) (genericManifest, error) {
-	m, err := manifest.Schema1FromManifest(manifestBlob)
-	if err != nil {
+type historySchema1 struct {
+	V1Compatibility string `json:"v1Compatibility"`
+}
+
+// historySchema1 is a string containing this.  It is similar to v1Image but not the same, in particular note the ThrowAway field.
+type v1Compatibility struct {
+	ID              string    `json:"id"`
+	Parent          string    `json:"parent,omitempty"`
+	Comment         string    `json:"comment,omitempty"`
+	Created         time.Time `json:"created"`
+	ContainerConfig struct {
+		Cmd []string
+	} `json:"container_config,omitempty"`
+	Author    string `json:"author,omitempty"`
+	ThrowAway bool   `json:"throwaway,omitempty"`
+}
+
+type manifestSchema1 struct {
+	Name          string            `json:"name"`
+	Tag           string            `json:"tag"`
+	Architecture  string            `json:"architecture"`
+	FSLayers      []fsLayersSchema1 `json:"fsLayers"`
+	History       []historySchema1  `json:"history"`
+	SchemaVersion int               `json:"schemaVersion"`
+}
+
+func manifestSchema1FromManifest(manifest []byte) (genericManifest, error) {
+	mschema1 := &manifestSchema1{}
+	if err := json.Unmarshal(manifest, mschema1); err != nil {
 		return nil, err
 	}
-	return &manifestSchema1{m: m}, nil
+	if mschema1.SchemaVersion != 1 {
+		return nil, errors.Errorf("unsupported schema version %d", mschema1.SchemaVersion)
+	}
+	if len(mschema1.FSLayers) != len(mschema1.History) {
+		return nil, errors.New("length of history not equal to number of layers")
+	}
+	if len(mschema1.FSLayers) == 0 {
+		return nil, errors.New("no FSLayers in manifest")
+	}
+
+	if err := fixManifestLayers(mschema1); err != nil {
+		return nil, err
+	}
+	return mschema1, nil
 }
 
 // manifestSchema1FromComponents builds a new manifestSchema1 from the supplied data.
-func manifestSchema1FromComponents(ref reference.Named, fsLayers []manifest.Schema1FSLayers, history []manifest.Schema1History, architecture string) genericManifest {
-	return &manifestSchema1{m: manifest.Schema1FromComponents(ref, fsLayers, history, architecture)}
+func manifestSchema1FromComponents(ref reference.Named, fsLayers []fsLayersSchema1, history []historySchema1, architecture string) genericManifest {
+	var name, tag string
+	if ref != nil { // Well, what to do if it _is_ nil? Most consumers actually don't use these fields nowadays, so we might as well try not supplying them.
+		name = reference.Path(ref)
+		if tagged, ok := ref.(reference.NamedTagged); ok {
+			tag = tagged.Tag()
+		}
+	}
+	return &manifestSchema1{
+		Name:          name,
+		Tag:           tag,
+		Architecture:  architecture,
+		FSLayers:      fsLayers,
+		History:       history,
+		SchemaVersion: 1,
+	}
 }
 
 func (m *manifestSchema1) serialize() ([]byte, error) {
-	return m.m.Serialize()
+	// docker/distribution requires a signature even if the incoming data uses the nominally unsigned DockerV2Schema1MediaType.
+	unsigned, err := json.Marshal(*m)
+	if err != nil {
+		return nil, err
+	}
+	return manifest.AddDummyV2S1Signature(unsigned)
 }
 
 func (m *manifestSchema1) manifestMIMEType() string {
@@ -39,7 +104,7 @@ func (m *manifestSchema1) manifestMIMEType() string {
 // ConfigInfo returns a complete BlobInfo for the separate config object, or a BlobInfo{Digest:""} if there isn't a separate object.
 // Note that the config object may not exist in the underlying storage in the return value of UpdatedImage! Use ConfigBlob() below.
 func (m *manifestSchema1) ConfigInfo() types.BlobInfo {
-	return m.m.ConfigInfo()
+	return types.BlobInfo{}
 }
 
 // ConfigBlob returns the blob described by ConfigInfo, iff ConfigInfo().Digest != ""; nil otherwise.
@@ -63,7 +128,11 @@ func (m *manifestSchema1) OCIConfig() (*imgspecv1.Image, error) {
 // The Digest field is guaranteed to be provided; Size may be -1.
 // WARNING: The list may contain duplicates, and they are semantically relevant.
 func (m *manifestSchema1) LayerInfos() []types.BlobInfo {
-	return m.m.LayerInfos()
+	layers := make([]types.BlobInfo, len(m.FSLayers))
+	for i, layer := range m.FSLayers { // NOTE: This includes empty layers (where m.History.V1Compatibility->ThrowAway)
+		layers[(len(m.FSLayers)-1)-i] = types.BlobInfo{Digest: layer.BlobSum, Size: -1}
+	}
+	return layers
 }
 
 // EmbeddedDockerReferenceConflicts whether a Docker reference embedded in the manifest, if any, conflicts with destination ref.
@@ -84,11 +153,22 @@ func (m *manifestSchema1) EmbeddedDockerReferenceConflicts(ref reference.Named)
 	} else {
 		tag = ""
 	}
-	return m.m.Name != name || m.m.Tag != tag
+	return m.Name != name || m.Tag != tag
 }
 
 func (m *manifestSchema1) imageInspectInfo() (*types.ImageInspectInfo, error) {
-	return m.m.Inspect(nil)
+	v1 := &v1Image{}
+	if err := json.Unmarshal([]byte(m.History[0].V1Compatibility), v1); err != nil {
+		return nil, err
+	}
+	return &types.ImageInspectInfo{
+		Tag:           m.Tag,
+		DockerVersion: v1.DockerVersion,
+		Created:       v1.Created,
+		Labels:        v1.Config.Labels,
+		Architecture:  v1.Architecture,
+		Os:            v1.OS,
+	}, nil
 }
 
 // UpdatedImageNeedsLayerDiffIDs returns true iff UpdatedImage(options) needs InformationOnly.LayerDiffIDs.
@@ -101,18 +181,25 @@ func (m *manifestSchema1) UpdatedImageNeedsLayerDiffIDs(options types.ManifestUp
 // UpdatedImage returns a types.Image modified according to options.
 // This does not change the state of the original Image object.
 func (m *manifestSchema1) UpdatedImage(options types.ManifestUpdateOptions) (types.Image, error) {
-	copy := manifestSchema1{m: manifest.Schema1Clone(m.m)}
+	copy := *m
 	if options.LayerInfos != nil {
-		if err := copy.m.UpdateLayerInfos(options.LayerInfos); err != nil {
-			return nil, err
+		// Our LayerInfos includes empty layers (where m.History.V1Compatibility->ThrowAway), so expect them to be included here as well.
+		if len(copy.FSLayers) != len(options.LayerInfos) {
+			return nil, errors.Errorf("Error preparing updated manifest: layer count changed from %d to %d", len(copy.FSLayers), len(options.LayerInfos))
+		}
+		for i, info := range options.LayerInfos {
+			// (docker push) sets up m.History.V1Compatibility->{Id,Parent} based on values of info.Digest,
+			// but (docker pull) ignores them in favor of computing DiffIDs from uncompressed data, except verifying the child->parent links and uniqueness.
+			// So, we don't bother recomputing the IDs in m.History.V1Compatibility.
+			copy.FSLayers[(len(options.LayerInfos)-1)-i].BlobSum = info.Digest
 		}
 	}
 	if options.EmbeddedDockerReference != nil {
-		copy.m.Name = reference.Path(options.EmbeddedDockerReference)
+		copy.Name = reference.Path(options.EmbeddedDockerReference)
 		if tagged, isTagged := options.EmbeddedDockerReference.(reference.NamedTagged); isTagged {
-			copy.m.Tag = tagged.Tag()
+			copy.Tag = tagged.Tag()
 		} else {
-			copy.m.Tag = ""
+			copy.Tag = ""
 		}
 	}
 
@@ -122,21 +209,7 @@ func (m *manifestSchema1) UpdatedImage(options types.ManifestUpdateOptions) (typ
 	// We have 2 MIME types for schema 1, which are basically equivalent (even the un-"Signed" MIME type will be rejected if there isn’t a signature; so,
 	// handle conversions between them by doing nothing.
 	case manifest.DockerV2Schema2MediaType:
-		m2, err := copy.convertToManifestSchema2(options.InformationOnly.LayerInfos, options.InformationOnly.LayerDiffIDs)
-		if err != nil {
-			return nil, err
-		}
-		return memoryImageFromManifest(m2), nil
-	case imgspecv1.MediaTypeImageManifest:
-		// We can't directly convert to OCI, but we can transitively convert via a Docker V2.2 Distribution manifest
-		m2, err := copy.convertToManifestSchema2(options.InformationOnly.LayerInfos, options.InformationOnly.LayerDiffIDs)
-		if err != nil {
-			return nil, err
-		}
-		return m2.UpdatedImage(types.ManifestUpdateOptions{
-			ManifestMIMEType: imgspecv1.MediaTypeImageManifest,
-			InformationOnly:  options.InformationOnly,
-		})
+		return copy.convertToManifestSchema2(options.InformationOnly.LayerInfos, options.InformationOnly.LayerDiffIDs)
 	default:
 		return nil, errors.Errorf("Conversion of image manifest from %s to %s is not implemented", manifest.DockerV2Schema1SignedMediaType, options.ManifestMIMEType)
 	}
@@ -144,32 +217,102 @@ func (m *manifestSchema1) UpdatedImage(options types.ManifestUpdateOptions) (typ
 	return memoryImageFromManifest(&copy), nil
 }
 
+// fixManifestLayers, after validating the supplied manifest
+// (to use correctly-formatted IDs, and to not have non-consecutive ID collisions in manifest.History),
+// modifies manifest to only have one entry for each layer ID in manifest.History (deleting the older duplicates,
+// both from manifest.History and manifest.FSLayers).
+// Note that even after this succeeds, manifest.FSLayers may contain duplicate entries
+// (for Dockerfile operations which change the configuration but not the filesystem).
+func fixManifestLayers(manifest *manifestSchema1) error {
+	type imageV1 struct {
+		ID     string
+		Parent string
+	}
+	// Per the specification, we can assume that len(manifest.FSLayers) == len(manifest.History)
+	imgs := make([]*imageV1, len(manifest.FSLayers))
+	for i := range manifest.FSLayers {
+		img := &imageV1{}
+
+		if err := json.Unmarshal([]byte(manifest.History[i].V1Compatibility), img); err != nil {
+			return err
+		}
+
+		imgs[i] = img
+		if err := validateV1ID(img.ID); err != nil {
+			return err
+		}
+	}
+	if imgs[len(imgs)-1].Parent != "" {
+		return errors.New("Invalid parent ID in the base layer of the image")
+	}
+	// check general duplicates to error instead of a deadlock
+	idmap := make(map[string]struct{})
+	var lastID string
+	for _, img := range imgs {
+		// skip IDs that appear after each other, we handle those later
+		if _, exists := idmap[img.ID]; img.ID != lastID && exists {
+			return errors.Errorf("ID %+v appears multiple times in manifest", img.ID)
+		}
+		lastID = img.ID
+		idmap[lastID] = struct{}{}
+	}
+	// backwards loop so that we keep the remaining indexes after removing items
+	for i := len(imgs) - 2; i >= 0; i-- {
+		if imgs[i].ID == imgs[i+1].ID { // repeated ID. remove and continue
+			manifest.FSLayers = append(manifest.FSLayers[:i], manifest.FSLayers[i+1:]...)
+			manifest.History = append(manifest.History[:i], manifest.History[i+1:]...)
+		} else if imgs[i].Parent != imgs[i+1].ID {
+			return errors.Errorf("Invalid parent ID. Expected %v, got %v", imgs[i+1].ID, imgs[i].Parent)
+		}
+	}
+	return nil
+}
+
+func validateV1ID(id string) error {
+	if ok := validHex.MatchString(id); !ok {
+		return errors.Errorf("image ID %q is invalid", id)
+	}
+	return nil
+}
+
 // Based on github.com/docker/docker/distribution/pull_v2.go
-func (m *manifestSchema1) convertToManifestSchema2(uploadedLayerInfos []types.BlobInfo, layerDiffIDs []digest.Digest) (genericManifest, error) {
-	if len(m.m.History) == 0 {
+func (m *manifestSchema1) convertToManifestSchema2(uploadedLayerInfos []types.BlobInfo, layerDiffIDs []digest.Digest) (types.Image, error) {
+	if len(m.History) == 0 {
 		// What would this even mean?! Anyhow, the rest of the code depends on fsLayers[0] and history[0] existing.
 		return nil, errors.Errorf("Cannot convert an image with 0 history entries to %s", manifest.DockerV2Schema2MediaType)
 	}
-	if len(m.m.History) != len(m.m.FSLayers) {
-		return nil, errors.Errorf("Inconsistent schema 1 manifest: %d history entries, %d fsLayers entries", len(m.m.History), len(m.m.FSLayers))
+	if len(m.History) != len(m.FSLayers) {
+		return nil, errors.Errorf("Inconsistent schema 1 manifest: %d history entries, %d fsLayers entries", len(m.History), len(m.FSLayers))
 	}
-	if uploadedLayerInfos != nil && len(uploadedLayerInfos) != len(m.m.FSLayers) {
-		return nil, errors.Errorf("Internal error: uploaded %d blobs, but schema1 manifest has %d fsLayers", len(uploadedLayerInfos), len(m.m.FSLayers))
+	if uploadedLayerInfos != nil && len(uploadedLayerInfos) != len(m.FSLayers) {
+		return nil, errors.Errorf("Internal error: uploaded %d blobs, but schema1 manifest has %d fsLayers", len(uploadedLayerInfos), len(m.FSLayers))
 	}
-	if layerDiffIDs != nil && len(layerDiffIDs) != len(m.m.FSLayers) {
-		return nil, errors.Errorf("Internal error: collected %d DiffID values, but schema1 manifest has %d fsLayers", len(layerDiffIDs), len(m.m.FSLayers))
+	if layerDiffIDs != nil && len(layerDiffIDs) != len(m.FSLayers) {
+		return nil, errors.Errorf("Internal error: collected %d DiffID values, but schema1 manifest has %d fsLayers", len(layerDiffIDs), len(m.FSLayers))
 	}
 
-	// Build a list of the diffIDs for the non-empty layers.
-	diffIDs := []digest.Digest{}
-	var layers []manifest.Schema2Descriptor
-	for v1Index := len(m.m.History) - 1; v1Index >= 0; v1Index-- {
-		v2Index := (len(m.m.History) - 1) - v1Index
+	rootFS := rootFS{
+		Type:      "layers",
+		DiffIDs:   []digest.Digest{},
+		BaseLayer: "",
+	}
+	var layers []descriptor
+	history := make([]imageHistory, len(m.History))
+	for v1Index := len(m.History) - 1; v1Index >= 0; v1Index-- {
+		v2Index := (len(m.History) - 1) - v1Index
 
-		var v1compat manifest.Schema1V1Compatibility
-		if err := json.Unmarshal([]byte(m.m.History[v1Index].V1Compatibility), &v1compat); err != nil {
+		var v1compat v1Compatibility
+		if err := json.Unmarshal([]byte(m.History[v1Index].V1Compatibility), &v1compat); err != nil {
 			return nil, errors.Wrapf(err, "Error decoding history entry %d", v1Index)
 		}
+		history[v2Index] = imageHistory{
+			Created:    v1compat.Created,
+			Author:     v1compat.Author,
+			CreatedBy:  strings.Join(v1compat.ContainerConfig.Cmd, " "),
+			Comment:    v1compat.Comment,
+			EmptyLayer: v1compat.ThrowAway,
+		}
+
 		if !v1compat.ThrowAway {
 			var size int64
 			if uploadedLayerInfos != nil {
@@ -179,23 +322,54 @@ func (m *manifestSchema1) convertToManifestSchema2(uploadedLayerInfos []types.Bl
 			if layerDiffIDs != nil {
 				d = layerDiffIDs[v2Index]
 			}
-			layers = append(layers, manifest.Schema2Descriptor{
+			layers = append(layers, descriptor{
 				MediaType: "application/vnd.docker.image.rootfs.diff.tar.gzip",
 				Size:      size,
-				Digest:    m.m.FSLayers[v1Index].BlobSum,
+				Digest:    m.FSLayers[v1Index].BlobSum,
 			})
-			diffIDs = append(diffIDs, d)
+			rootFS.DiffIDs = append(rootFS.DiffIDs, d)
 		}
 	}
-	configJSON, err := m.m.ToSchema2(diffIDs)
+	configJSON, err := configJSONFromV1Config([]byte(m.History[0].V1Compatibility), rootFS, history)
 	if err != nil {
 		return nil, err
 	}
-	configDescriptor := manifest.Schema2Descriptor{
+	configDescriptor := descriptor{
 		MediaType: "application/vnd.docker.container.image.v1+json",
 		Size:      int64(len(configJSON)),
 		Digest:    digest.FromBytes(configJSON),
 	}
 
-	return manifestSchema2FromComponents(configDescriptor, nil, configJSON, layers), nil
+	m2 := manifestSchema2FromComponents(configDescriptor, nil, configJSON, layers)
+	return memoryImageFromManifest(m2), nil
+}
+
+func configJSONFromV1Config(v1ConfigJSON []byte, rootFS rootFS, history []imageHistory) ([]byte, error) {
+	// github.com/docker/docker/image/v1/imagev1.go:MakeConfigFromV1Config unmarshals and re-marshals the input if docker_version is < 1.8.3 to remove blank fields;
+	// we don't do that here. FIXME? Should we? AFAICT it would only affect the digest value of the schema2 manifest, and we don't particularly need that to be
+	// a consistently reproducible value.
+
+	// Preserve everything we don't specifically know about.
+	// (This must be a *json.RawMessage, even though *[]byte is fairly redundant, because only *RawMessage implements json.Marshaler.)
+	rawContents := map[string]*json.RawMessage{}
+	if err := json.Unmarshal(v1ConfigJSON, &rawContents); err != nil { // We have already unmarshaled it before, using a more detailed schema?!
+		return nil, err
+	}
+
+	delete(rawContents, "id")
+	delete(rawContents, "parent")
+	delete(rawContents, "Size")
+	delete(rawContents, "parent_id")
+	delete(rawContents, "layer_id")
+	delete(rawContents, "throwaway")
+
+	updates := map[string]interface{}{"rootfs": rootFS, "history": history}
+	for field, value := range updates {
+		encoded, err := json.Marshal(value)
+		if err != nil {
+			return nil, err
+		}
+		rawContents[field] = (*json.RawMessage)(&encoded)
+	}
+	return json.Marshal(rawContents)
 }

vendor/github.com/containers/image/image/docker_schema2.go

@@ -29,44 +29,54 @@ var gzippedEmptyLayer = []byte{
 // gzippedEmptyLayerDigest is a digest of gzippedEmptyLayer
 const gzippedEmptyLayerDigest = digest.Digest("sha256:a3ed95caeb02ffe68cdd9fd84406680ae93d633cb16422d00e8a7c22955b46d4")
 
-type manifestSchema2 struct {
-	src        types.ImageSource // May be nil if configBlob is not nil
-	configBlob []byte            // If set, corresponds to contents of ConfigDescriptor.
-	m          *manifest.Schema2
+type descriptor struct {
+	MediaType string        `json:"mediaType"`
+	Size      int64         `json:"size"`
+	Digest    digest.Digest `json:"digest"`
+	URLs      []string      `json:"urls,omitempty"`
 }
 
-func manifestSchema2FromManifest(src types.ImageSource, manifestBlob []byte) (genericManifest, error) {
-	m, err := manifest.Schema2FromManifest(manifestBlob)
-	if err != nil {
+type manifestSchema2 struct {
+	src               types.ImageSource // May be nil if configBlob is not nil
+	configBlob        []byte            // If set, corresponds to contents of ConfigDescriptor.
+	SchemaVersion     int               `json:"schemaVersion"`
+	MediaType         string            `json:"mediaType"`
+	ConfigDescriptor  descriptor        `json:"config"`
+	LayersDescriptors []descriptor      `json:"layers"`
+}
+
+func manifestSchema2FromManifest(src types.ImageSource, manifest []byte) (genericManifest, error) {
+	v2s2 := manifestSchema2{src: src}
+	if err := json.Unmarshal(manifest, &v2s2); err != nil {
 		return nil, err
 	}
-	return &manifestSchema2{
-		src: src,
-		m:   m,
-	}, nil
+	return &v2s2, nil
 }
 
 // manifestSchema2FromComponents builds a new manifestSchema2 from the supplied data:
-func manifestSchema2FromComponents(config manifest.Schema2Descriptor, src types.ImageSource, configBlob []byte, layers []manifest.Schema2Descriptor) genericManifest {
+func manifestSchema2FromComponents(config descriptor, src types.ImageSource, configBlob []byte, layers []descriptor) genericManifest {
 	return &manifestSchema2{
-		src:        src,
-		configBlob: configBlob,
-		m:          manifest.Schema2FromComponents(config, layers),
+		src:               src,
+		configBlob:        configBlob,
+		SchemaVersion:     2,
+		MediaType:         manifest.DockerV2Schema2MediaType,
+		ConfigDescriptor:  config,
+		LayersDescriptors: layers,
 	}
 }
 
 func (m *manifestSchema2) serialize() ([]byte, error) {
-	return m.m.Serialize()
+	return json.Marshal(*m)
 }
 
 func (m *manifestSchema2) manifestMIMEType() string {
-	return m.m.MediaType
+	return m.MediaType
 }
 
 // ConfigInfo returns a complete BlobInfo for the separate config object, or a BlobInfo{Digest:""} if there isn't a separate object.
 // Note that the config object may not exist in the underlying storage in the return value of UpdatedImage! Use ConfigBlob() below.
 func (m *manifestSchema2) ConfigInfo() types.BlobInfo {
-	return m.m.ConfigInfo()
+	return types.BlobInfo{Digest: m.ConfigDescriptor.Digest, Size: m.ConfigDescriptor.Size}
 }
 
 // OCIConfig returns the image configuration as per OCI v1 image-spec. Information about
@@ -95,9 +105,9 @@ func (m *manifestSchema2) ConfigBlob() ([]byte, error) {
 			return nil, errors.Errorf("Internal error: neither src nor configBlob set in manifestSchema2")
 		}
 		stream, _, err := m.src.GetBlob(types.BlobInfo{
-			Digest: m.m.ConfigDescriptor.Digest,
-			Size:   m.m.ConfigDescriptor.Size,
-			URLs:   m.m.ConfigDescriptor.URLs,
+			Digest: m.ConfigDescriptor.Digest,
+			Size:   m.ConfigDescriptor.Size,
+			URLs:   m.ConfigDescriptor.URLs,
 		})
 		if err != nil {
 			return nil, err
@@ -108,8 +118,8 @@ func (m *manifestSchema2) ConfigBlob() ([]byte, error) {
 			return nil, err
 		}
 		computedDigest := digest.FromBytes(blob)
-		if computedDigest != m.m.ConfigDescriptor.Digest {
-			return nil, errors.Errorf("Download config.json digest %s does not match expected %s", computedDigest, m.m.ConfigDescriptor.Digest)
+		if computedDigest != m.ConfigDescriptor.Digest {
+			return nil, errors.Errorf("Download config.json digest %s does not match expected %s", computedDigest, m.ConfigDescriptor.Digest)
 		}
 		m.configBlob = blob
 	}
@@ -120,7 +130,15 @@ func (m *manifestSchema2) ConfigBlob() ([]byte, error) {
 // The Digest field is guaranteed to be provided; Size may be -1.
 // WARNING: The list may contain duplicates, and they are semantically relevant.
 func (m *manifestSchema2) LayerInfos() []types.BlobInfo {
-	return m.m.LayerInfos()
+	blobs := []types.BlobInfo{}
+	for _, layer := range m.LayersDescriptors {
+		blobs = append(blobs, types.BlobInfo{
+			Digest: layer.Digest,
+			Size:   layer.Size,
+			URLs:   layer.URLs,
+		})
+	}
+	return blobs
 }
 
 // EmbeddedDockerReferenceConflicts whether a Docker reference embedded in the manifest, if any, conflicts with destination ref.
@@ -131,18 +149,21 @@ func (m *manifestSchema2) EmbeddedDockerReferenceConflicts(ref reference.Named)
 }
 
 func (m *manifestSchema2) imageInspectInfo() (*types.ImageInspectInfo, error) {
-	getter := func(info types.BlobInfo) ([]byte, error) {
-		if info.Digest != m.ConfigInfo().Digest {
-			// Shouldn't ever happen
-			return nil, errors.New("asked for a different config blob")
-		}
-		config, err := m.ConfigBlob()
-		if err != nil {
-			return nil, err
-		}
-		return config, nil
+	config, err := m.ConfigBlob()
+	if err != nil {
+		return nil, err
 	}
-	return m.m.Inspect(getter)
+	v1 := &v1Image{}
+	if err := json.Unmarshal(config, v1); err != nil {
+		return nil, err
+	}
+	return &types.ImageInspectInfo{
+		DockerVersion: v1.DockerVersion,
+		Created:       v1.Created,
+		Labels:        v1.Config.Labels,
+		Architecture:  v1.Architecture,
+		Os:            v1.OS,
+	}, nil
 }
 
 // UpdatedImageNeedsLayerDiffIDs returns true iff UpdatedImage(options) needs InformationOnly.LayerDiffIDs.
@@ -155,14 +176,17 @@ func (m *manifestSchema2) UpdatedImageNeedsLayerDiffIDs(options types.ManifestUp
 // UpdatedImage returns a types.Image modified according to options.
 // This does not change the state of the original Image object.
 func (m *manifestSchema2) UpdatedImage(options types.ManifestUpdateOptions) (types.Image, error) {
-	copy := manifestSchema2{ // NOTE: This is not a deep copy, it still shares slices etc.
-		src:        m.src,
-		configBlob: m.configBlob,
-		m:          manifest.Schema2Clone(m.m),
-	}
+	copy := *m // NOTE: This is not a deep copy, it still shares slices etc.
 	if options.LayerInfos != nil {
-		if err := copy.m.UpdateLayerInfos(options.LayerInfos); err != nil {
-			return nil, err
+		if len(copy.LayersDescriptors) != len(options.LayerInfos) {
+			return nil, errors.Errorf("Error preparing updated manifest: layer count changed from %d to %d", len(copy.LayersDescriptors), len(options.LayerInfos))
+		}
+		copy.LayersDescriptors = make([]descriptor, len(options.LayerInfos))
+		for i, info := range options.LayerInfos {
+			copy.LayersDescriptors[i].MediaType = m.LayersDescriptors[i].MediaType
+			copy.LayersDescriptors[i].Digest = info.Digest
+			copy.LayersDescriptors[i].Size = info.Size
+			copy.LayersDescriptors[i].URLs = info.URLs
 		}
 	}
 	// Ignore options.EmbeddedDockerReference: it may be set when converting from schema1 to schema2, but we really don't care.
@@ -180,15 +204,6 @@ func (m *manifestSchema2) UpdatedImage(options types.ManifestUpdateOptions) (typ
 	return memoryImageFromManifest(&copy), nil
 }
 
-func oci1DescriptorFromSchema2Descriptor(d manifest.Schema2Descriptor) imgspecv1.Descriptor {
-	return imgspecv1.Descriptor{
-		MediaType: d.MediaType,
-		Size:      d.Size,
-		Digest:    d.Digest,
-		URLs:      d.URLs,
-	}
-}
-
 func (m *manifestSchema2) convertToManifestOCI1() (types.Image, error) {
 	configOCI, err := m.OCIConfig()
 	if err != nil {
@@ -199,16 +214,18 @@ func (m *manifestSchema2) convertToManifestOCI1() (types.Image, error) {
 		return nil, err
 	}
 
-	config := imgspecv1.Descriptor{
-		MediaType: imgspecv1.MediaTypeImageConfig,
-		Size:      int64(len(configOCIBytes)),
-		Digest:    digest.FromBytes(configOCIBytes),
+	config := descriptorOCI1{
+		descriptor: descriptor{
+			MediaType: imgspecv1.MediaTypeImageConfig,
+			Size:      int64(len(configOCIBytes)),
+			Digest:    digest.FromBytes(configOCIBytes),
+		},
 	}
 
-	layers := make([]imgspecv1.Descriptor, len(m.m.LayersDescriptors))
+	layers := make([]descriptorOCI1, len(m.LayersDescriptors))
 	for idx := range layers {
-		layers[idx] = oci1DescriptorFromSchema2Descriptor(m.m.LayersDescriptors[idx])
-		if m.m.LayersDescriptors[idx].MediaType == manifest.DockerV2Schema2ForeignLayerMediaType {
+		layers[idx] = descriptorOCI1{descriptor: m.LayersDescriptors[idx]}
+		if m.LayersDescriptors[idx].MediaType == manifest.DockerV2Schema2ForeignLayerMediaType {
 			layers[idx].MediaType = imgspecv1.MediaTypeImageLayerNonDistributable
 		} else {
 			// we assume layers are gzip'ed because docker v2s2 only deals with
@@ -227,14 +244,14 @@ func (m *manifestSchema2) convertToManifestSchema1(dest types.ImageDestination)
 	if err != nil {
 		return nil, err
 	}
-	imageConfig := &manifest.Schema2Image{}
+	imageConfig := &image{}
 	if err := json.Unmarshal(configBytes, imageConfig); err != nil {
 		return nil, err
 	}
 
 	// Build fsLayers and History, discarding all configs. We will patch the top-level config in later.
-	fsLayers := make([]manifest.Schema1FSLayers, len(imageConfig.History))
-	history := make([]manifest.Schema1History, len(imageConfig.History))
+	fsLayers := make([]fsLayersSchema1, len(imageConfig.History))
+	history := make([]historySchema1, len(imageConfig.History))
 	nonemptyLayerIndex := 0
 	var parentV1ID string // Set in the loop
 	v1ID := ""
@@ -262,10 +279,10 @@ func (m *manifestSchema2) convertToManifestSchema1(dest types.ImageDestination)
 			}
 			blobDigest = gzippedEmptyLayerDigest
 		} else {
-			if nonemptyLayerIndex >= len(m.m.LayersDescriptors) {
-				return nil, errors.Errorf("Invalid image configuration, needs more than the %d distributed layers", len(m.m.LayersDescriptors))
+			if nonemptyLayerIndex >= len(m.LayersDescriptors) {
+				return nil, errors.Errorf("Invalid image configuration, needs more than the %d distributed layers", len(m.LayersDescriptors))
 			}
-			blobDigest = m.m.LayersDescriptors[nonemptyLayerIndex].Digest
+			blobDigest = m.LayersDescriptors[nonemptyLayerIndex].Digest
 			nonemptyLayerIndex++
 		}
 
@@ -276,7 +293,7 @@ func (m *manifestSchema2) convertToManifestSchema1(dest types.ImageDestination)
 		}
 		v1ID = v
 
-		fakeImage := manifest.Schema1V1Compatibility{
+		fakeImage := v1Compatibility{
 			ID:        v1ID,
 			Parent:    parentV1ID,
 			Comment:   historyEntry.Comment,
@@ -290,8 +307,8 @@ func (m *manifestSchema2) convertToManifestSchema1(dest types.ImageDestination)
 			return nil, errors.Errorf("Internal error: Error creating v1compatibility for %#v", fakeImage)
 		}
 
-		fsLayers[v1Index] = manifest.Schema1FSLayers{BlobSum: blobDigest}
-		history[v1Index] = manifest.Schema1History{V1Compatibility: string(v1CompatibilityBytes)}
+		fsLayers[v1Index] = fsLayersSchema1{BlobSum: blobDigest}
+		history[v1Index] = historySchema1{V1Compatibility: string(v1CompatibilityBytes)}
 		// Note that parentV1ID of the top layer is preserved when exiting this loop
 	}
 

vendor/github.com/containers/image/image/manifest.go

@@ -1,14 +1,57 @@
 package image
 
 import (
-	"fmt"
+	"time"
 
 	"github.com/containers/image/docker/reference"
 	"github.com/containers/image/manifest"
+	"github.com/containers/image/pkg/strslice"
 	"github.com/containers/image/types"
+	"github.com/opencontainers/go-digest"
 	imgspecv1 "github.com/opencontainers/image-spec/specs-go/v1"
 )
 
+type config struct {
+	Cmd    strslice.StrSlice
+	Labels map[string]string
+}
+
+type v1Image struct {
+	ID              string    `json:"id,omitempty"`
+	Parent          string    `json:"parent,omitempty"`
+	Comment         string    `json:"comment,omitempty"`
+	Created         time.Time `json:"created"`
+	ContainerConfig *config   `json:"container_config,omitempty"`
+	DockerVersion   string    `json:"docker_version,omitempty"`
+	Author          string    `json:"author,omitempty"`
+	// Config is the configuration of the container received from the client
+	Config *config `json:"config,omitempty"`
+	// Architecture is the hardware that the image is build and runs on
+	Architecture string `json:"architecture,omitempty"`
+	// OS is the operating system used to build and run the image
+	OS string `json:"os,omitempty"`
+}
+
+type image struct {
+	v1Image
+	History []imageHistory `json:"history,omitempty"`
+	RootFS  *rootFS        `json:"rootfs,omitempty"`
+}
+
+type imageHistory struct {
+	Created    time.Time `json:"created"`
+	Author     string    `json:"author,omitempty"`
+	CreatedBy  string    `json:"created_by,omitempty"`
+	Comment    string    `json:"comment,omitempty"`
+	EmptyLayer bool      `json:"empty_layer,omitempty"`
+}
+
+type rootFS struct {
+	Type      string          `json:"type"`
+	DiffIDs   []digest.Digest `json:"diff_ids,omitempty"`
+	BaseLayer string          `json:"base_layer,omitempty"`
+}
+
 // genericManifest is an interface for parsing, modifying image manifests and related data.
 // Note that the public methods are intended to be a subset of types.Image
 // so that embedding a genericManifest into structs works.
@@ -44,24 +87,43 @@ type genericManifest interface {
 	UpdatedImage(options types.ManifestUpdateOptions) (types.Image, error)
 }
 
-// manifestInstanceFromBlob returns a genericManifest implementation for (manblob, mt) in src.
-// If manblob is a manifest list, it implicitly chooses an appropriate image from the list.
-func manifestInstanceFromBlob(ctx *types.SystemContext, src types.ImageSource, manblob []byte, mt string) (genericManifest, error) {
-	switch manifest.NormalizedMIMEType(mt) {
-	case manifest.DockerV2Schema1MediaType, manifest.DockerV2Schema1SignedMediaType:
+func manifestInstanceFromBlob(src types.ImageSource, manblob []byte, mt string) (genericManifest, error) {
+	switch mt {
+	// "application/json" is a valid v2s1 value per https://github.com/docker/distribution/blob/master/docs/spec/manifest-v2-1.md .
+	// This works for now, when nothing else seems to return "application/json"; if that were not true, the mapping/detection might
+	// need to happen within the ImageSource.
+	case manifest.DockerV2Schema1MediaType, manifest.DockerV2Schema1SignedMediaType, "application/json":
 		return manifestSchema1FromManifest(manblob)
 	case imgspecv1.MediaTypeImageManifest:
 		return manifestOCI1FromManifest(src, manblob)
 	case manifest.DockerV2Schema2MediaType:
 		return manifestSchema2FromManifest(src, manblob)
 	case manifest.DockerV2ListMediaType:
-		return manifestSchema2FromManifestList(ctx, src, manblob)
-	default: // Note that this may not be reachable, manifest.NormalizedMIMEType has a default for unknown values.
-		return nil, fmt.Errorf("Unimplemented manifest MIME type %s", mt)
+		return manifestSchema2FromManifestList(src, manblob)
+	default:
+		// If it's not a recognized manifest media type, or we have failed determining the type, we'll try one last time
+		// to deserialize using v2s1 as per https://github.com/docker/distribution/blob/master/manifests.go#L108
+		// and https://github.com/docker/distribution/blob/master/manifest/schema1/manifest.go#L50
+		//
+		// Crane registries can also return "text/plain", or pretty much anything else depending on a file extension “recognized” in the tag.
+		// This makes no real sense, but it happens
+		// because requests for manifests are
+		// redirected to a content distribution
+		// network which is configured that way. See https://bugzilla.redhat.com/show_bug.cgi?id=1389442
+		return manifestSchema1FromManifest(manblob)
 	}
 }
 
 // inspectManifest is an implementation of types.Image.Inspect
 func inspectManifest(m genericManifest) (*types.ImageInspectInfo, error) {
-	return m.imageInspectInfo()
+	info, err := m.imageInspectInfo()
+	if err != nil {
+		return nil, err
+	}
+	layers := m.LayerInfos()
+	info.Layers = make([]string, len(layers))
+	for i, layer := range layers {
+		info.Layers[i] = layer.Digest.String()
+	}
+	return info, nil
 }

vendor/github.com/containers/image/image/memory.go

@@ -33,6 +33,11 @@ func (i *memoryImage) Reference() types.ImageReference {
 	return nil
 }
 
+// Close removes resources associated with an initialized UnparsedImage, if any.
+func (i *memoryImage) Close() error {
+	return nil
+}
+
 // Size returns the size of the image as stored, if known, or -1 if not.
 func (i *memoryImage) Size() (int64, error) {
 	return -1, nil
@@ -62,9 +67,7 @@ func (i *memoryImage) Inspect() (*types.ImageInspectInfo, error) {
 	return inspectManifest(i.genericManifest)
 }
 
-// LayerInfosForCopy returns an updated set of layer blob information which may not match the manifest.
-// The Digest field is guaranteed to be provided; Size may be -1.
-// WARNING: The list may contain duplicates, and they are semantically relevant.
-func (i *memoryImage) LayerInfosForCopy() []types.BlobInfo {
-	return nil
+// IsMultiImage returns true if the image's manifest is a list of images, false otherwise.
+func (i *memoryImage) IsMultiImage() bool {
+	return false
 }

vendor/github.com/containers/image/image/oci.go

@@ -12,34 +12,41 @@ import (
 	"github.com/pkg/errors"
 )
 
-type manifestOCI1 struct {
-	src        types.ImageSource // May be nil if configBlob is not nil
-	configBlob []byte            // If set, corresponds to contents of m.Config.
-	m          *manifest.OCI1
+type descriptorOCI1 struct {
+	descriptor
+	Annotations map[string]string `json:"annotations,omitempty"`
 }
 
-func manifestOCI1FromManifest(src types.ImageSource, manifestBlob []byte) (genericManifest, error) {
-	m, err := manifest.OCI1FromManifest(manifestBlob)
-	if err != nil {
+type manifestOCI1 struct {
+	src               types.ImageSource // May be nil if configBlob is not nil
+	configBlob        []byte            // If set, corresponds to contents of ConfigDescriptor.
+	SchemaVersion     int               `json:"schemaVersion"`
+	ConfigDescriptor  descriptorOCI1    `json:"config"`
+	LayersDescriptors []descriptorOCI1  `json:"layers"`
+	Annotations       map[string]string `json:"annotations,omitempty"`
+}
+
+func manifestOCI1FromManifest(src types.ImageSource, manifest []byte) (genericManifest, error) {
+	oci := manifestOCI1{src: src}
+	if err := json.Unmarshal(manifest, &oci); err != nil {
 		return nil, err
 	}
-	return &manifestOCI1{
-		src: src,
-		m:   m,
-	}, nil
+	return &oci, nil
 }
 
 // manifestOCI1FromComponents builds a new manifestOCI1 from the supplied data:
-func manifestOCI1FromComponents(config imgspecv1.Descriptor, src types.ImageSource, configBlob []byte, layers []imgspecv1.Descriptor) genericManifest {
+func manifestOCI1FromComponents(config descriptorOCI1, src types.ImageSource, configBlob []byte, layers []descriptorOCI1) genericManifest {
 	return &manifestOCI1{
-		src:        src,
-		configBlob: configBlob,
-		m:          manifest.OCI1FromComponents(config, layers),
+		src:               src,
+		configBlob:        configBlob,
+		SchemaVersion:     2,
+		ConfigDescriptor:  config,
+		LayersDescriptors: layers,
 	}
 }
 
 func (m *manifestOCI1) serialize() ([]byte, error) {
-	return m.m.Serialize()
+	return json.Marshal(*m)
 }
 
 func (m *manifestOCI1) manifestMIMEType() string {
@@ -49,7 +56,7 @@ func (m *manifestOCI1) manifestMIMEType() string {
 // ConfigInfo returns a complete BlobInfo for the separate config object, or a BlobInfo{Digest:""} if there isn't a separate object.
 // Note that the config object may not exist in the underlying storage in the return value of UpdatedImage! Use ConfigBlob() below.
 func (m *manifestOCI1) ConfigInfo() types.BlobInfo {
-	return m.m.ConfigInfo()
+	return types.BlobInfo{Digest: m.ConfigDescriptor.Digest, Size: m.ConfigDescriptor.Size, Annotations: m.ConfigDescriptor.Annotations}
 }
 
 // ConfigBlob returns the blob described by ConfigInfo, iff ConfigInfo().Digest != ""; nil otherwise.
@@ -60,9 +67,9 @@ func (m *manifestOCI1) ConfigBlob() ([]byte, error) {
 			return nil, errors.Errorf("Internal error: neither src nor configBlob set in manifestOCI1")
 		}
 		stream, _, err := m.src.GetBlob(types.BlobInfo{
-			Digest: m.m.Config.Digest,
-			Size:   m.m.Config.Size,
-			URLs:   m.m.Config.URLs,
+			Digest: m.ConfigDescriptor.Digest,
+			Size:   m.ConfigDescriptor.Size,
+			URLs:   m.ConfigDescriptor.URLs,
 		})
 		if err != nil {
 			return nil, err
@@ -73,8 +80,8 @@ func (m *manifestOCI1) ConfigBlob() ([]byte, error) {
 			return nil, err
 		}
 		computedDigest := digest.FromBytes(blob)
-		if computedDigest != m.m.Config.Digest {
-			return nil, errors.Errorf("Download config.json digest %s does not match expected %s", computedDigest, m.m.Config.Digest)
+		if computedDigest != m.ConfigDescriptor.Digest {
+			return nil, errors.Errorf("Download config.json digest %s does not match expected %s", computedDigest, m.ConfigDescriptor.Digest)
 		}
 		m.configBlob = blob
 	}
@@ -100,7 +107,11 @@ func (m *manifestOCI1) OCIConfig() (*imgspecv1.Image, error) {
 // The Digest field is guaranteed to be provided; Size may be -1.
 // WARNING: The list may contain duplicates, and they are semantically relevant.
 func (m *manifestOCI1) LayerInfos() []types.BlobInfo {
-	return m.m.LayerInfos()
+	blobs := []types.BlobInfo{}
+	for _, layer := range m.LayersDescriptors {
+		blobs = append(blobs, types.BlobInfo{Digest: layer.Digest, Size: layer.Size, Annotations: layer.Annotations, URLs: layer.URLs})
+	}
+	return blobs
 }
 
 // EmbeddedDockerReferenceConflicts whether a Docker reference embedded in the manifest, if any, conflicts with destination ref.
@@ -111,18 +122,21 @@ func (m *manifestOCI1) EmbeddedDockerReferenceConflicts(ref reference.Named) boo
 }
 
 func (m *manifestOCI1) imageInspectInfo() (*types.ImageInspectInfo, error) {
-	getter := func(info types.BlobInfo) ([]byte, error) {
-		if info.Digest != m.ConfigInfo().Digest {
-			// Shouldn't ever happen
-			return nil, errors.New("asked for a different config blob")
-		}
-		config, err := m.ConfigBlob()
-		if err != nil {
-			return nil, err
-		}
-		return config, nil
+	config, err := m.ConfigBlob()
+	if err != nil {
+		return nil, err
 	}
-	return m.m.Inspect(getter)
+	v1 := &v1Image{}
+	if err := json.Unmarshal(config, v1); err != nil {
+		return nil, err
+	}
+	return &types.ImageInspectInfo{
+		DockerVersion: v1.DockerVersion,
+		Created:       v1.Created,
+		Labels:        v1.Config.Labels,
+		Architecture:  v1.Architecture,
+		Os:            v1.OS,
+	}, nil
 }
 
 // UpdatedImageNeedsLayerDiffIDs returns true iff UpdatedImage(options) needs InformationOnly.LayerDiffIDs.
@@ -135,14 +149,18 @@ func (m *manifestOCI1) UpdatedImageNeedsLayerDiffIDs(options types.ManifestUpdat
 // UpdatedImage returns a types.Image modified according to options.
 // This does not change the state of the original Image object.
 func (m *manifestOCI1) UpdatedImage(options types.ManifestUpdateOptions) (types.Image, error) {
-	copy := manifestOCI1{ // NOTE: This is not a deep copy, it still shares slices etc.
-		src:        m.src,
-		configBlob: m.configBlob,
-		m:          manifest.OCI1Clone(m.m),
-	}
+	copy := *m // NOTE: This is not a deep copy, it still shares slices etc.
 	if options.LayerInfos != nil {
-		if err := copy.m.UpdateLayerInfos(options.LayerInfos); err != nil {
-			return nil, err
+		if len(copy.LayersDescriptors) != len(options.LayerInfos) {
+			return nil, errors.Errorf("Error preparing updated manifest: layer count changed from %d to %d", len(copy.LayersDescriptors), len(options.LayerInfos))
+		}
+		copy.LayersDescriptors = make([]descriptorOCI1, len(options.LayerInfos))
+		for i, info := range options.LayerInfos {
+			copy.LayersDescriptors[i].MediaType = m.LayersDescriptors[i].MediaType
+			copy.LayersDescriptors[i].Digest = info.Digest
+			copy.LayersDescriptors[i].Size = info.Size
+			copy.LayersDescriptors[i].Annotations = info.Annotations
+			copy.LayersDescriptors[i].URLs = info.URLs
 		}
 	}
 	// Ignore options.EmbeddedDockerReference: it may be set when converting from schema1, but we really don't care.
@@ -158,26 +176,17 @@ func (m *manifestOCI1) UpdatedImage(options types.ManifestUpdateOptions) (types.
 	return memoryImageFromManifest(&copy), nil
 }
 
-func schema2DescriptorFromOCI1Descriptor(d imgspecv1.Descriptor) manifest.Schema2Descriptor {
-	return manifest.Schema2Descriptor{
-		MediaType: d.MediaType,
-		Size:      d.Size,
-		Digest:    d.Digest,
-		URLs:      d.URLs,
-	}
-}
-
 func (m *manifestOCI1) convertToManifestSchema2() (types.Image, error) {
 	// Create a copy of the descriptor.
-	config := schema2DescriptorFromOCI1Descriptor(m.m.Config)
+	config := m.ConfigDescriptor.descriptor
 
 	// The only difference between OCI and DockerSchema2 is the mediatypes. The
 	// media type of the manifest is handled by manifestSchema2FromComponents.
 	config.MediaType = manifest.DockerV2Schema2ConfigMediaType
 
-	layers := make([]manifest.Schema2Descriptor, len(m.m.Layers))
+	layers := make([]descriptor, len(m.LayersDescriptors))
 	for idx := range layers {
-		layers[idx] = schema2DescriptorFromOCI1Descriptor(m.m.Layers[idx])
+		layers[idx] = m.LayersDescriptors[idx].descriptor
 		layers[idx].MediaType = manifest.DockerV2Schema2LayerMediaType
 	}
 

vendor/github.com/containers/image/image/sourced.go

@@ -4,22 +4,12 @@
 package image
 
 import (
+	"github.com/containers/image/manifest"
 	"github.com/containers/image/types"
 )
 
-// imageCloser implements types.ImageCloser, perhaps allowing simple users
-// to use a single object without having keep a reference to a types.ImageSource
-// only to call types.ImageSource.Close().
-type imageCloser struct {
-	types.Image
-	src types.ImageSource
-}
-
-// FromSource returns a types.ImageCloser implementation for the default instance of source.
-// If source is a manifest list, .Manifest() still returns the manifest list,
-// but other methods transparently return data from an appropriate image instance.
-//
-// The caller must call .Close() on the returned ImageCloser.
+// FromSource returns a types.Image implementation for source.
+// The caller must call .Close() on the returned Image.
 //
 // FromSource “takes ownership” of the input ImageSource and will call src.Close()
 // when the image is closed.  (This does not prevent callers from using both the
@@ -28,19 +18,8 @@ type imageCloser struct {
 //
 // NOTE: If any kind of signature verification should happen, build an UnparsedImage from the value returned by NewImageSource,
 // verify that UnparsedImage, and convert it into a real Image via image.FromUnparsedImage instead of calling this function.
-func FromSource(ctx *types.SystemContext, src types.ImageSource) (types.ImageCloser, error) {
-	img, err := FromUnparsedImage(ctx, UnparsedInstance(src, nil))
-	if err != nil {
-		return nil, err
-	}
-	return &imageCloser{
-		Image: img,
-		src:   src,
-	}, nil
-}
-
-func (ic *imageCloser) Close() error {
-	return ic.src.Close()
+func FromSource(src types.ImageSource) (types.Image, error) {
+	return FromUnparsedImage(UnparsedFromSource(src))
 }
 
 // sourcedImage is a general set of utilities for working with container images,
@@ -59,22 +38,27 @@ type sourcedImage struct {
 }
 
 // FromUnparsedImage returns a types.Image implementation for unparsed.
-// If unparsed represents a manifest list, .Manifest() still returns the manifest list,
-// but other methods transparently return data from an appropriate single image.
+// The caller must call .Close() on the returned Image.
 //
-// The Image must not be used after the underlying ImageSource is Close()d.
-func FromUnparsedImage(ctx *types.SystemContext, unparsed *UnparsedImage) (types.Image, error) {
+// FromSource “takes ownership” of the input UnparsedImage and will call uparsed.Close()
+// when the image is closed.  (This does not prevent callers from using both the
+// UnparsedImage and ImageSource objects simultaneously, but it means that they only need to
+// keep a reference to the Image.)
+func FromUnparsedImage(unparsed *UnparsedImage) (types.Image, error) {
 	// Note that the input parameter above is specifically *image.UnparsedImage, not types.UnparsedImage:
 	// we want to be able to use unparsed.src.  We could make that an explicit interface, but, well,
 	// this is the only UnparsedImage implementation around, anyway.
 
+	// Also, we do not explicitly implement types.Image.Close; we let the implementation fall through to
+	// unparsed.Close.
+
 	// NOTE: It is essential for signature verification that all parsing done in this object happens on the same manifest which is returned by unparsed.Manifest().
 	manifestBlob, manifestMIMEType, err := unparsed.Manifest()
 	if err != nil {
 		return nil, err
 	}
 
-	parsedManifest, err := manifestInstanceFromBlob(ctx, unparsed.src, manifestBlob, manifestMIMEType)
+	parsedManifest, err := manifestInstanceFromBlob(unparsed.src, manifestBlob, manifestMIMEType)
 	if err != nil {
 		return nil, err
 	}
@@ -101,6 +85,6 @@ func (i *sourcedImage) Inspect() (*types.ImageInspectInfo, error) {
 	return inspectManifest(i.genericManifest)
 }
 
-func (i *sourcedImage) LayerInfosForCopy() []types.BlobInfo {
-	return i.UnparsedImage.LayerInfosForCopy()
+func (i *sourcedImage) IsMultiImage() bool {
+	return i.manifestMIMEType == manifest.DockerV2ListMediaType
 }

vendor/github.com/containers/image/image/unparsed.go

@@ -11,10 +11,8 @@ import (
 )
 
 // UnparsedImage implements types.UnparsedImage .
-// An UnparsedImage is a pair of (ImageSource, instance digest); it can represent either a manifest list or a single image instance.
 type UnparsedImage struct {
 	src            types.ImageSource
-	instanceDigest *digest.Digest
 	cachedManifest []byte // A private cache for Manifest(); nil if not yet known.
 	// A private cache for Manifest(), may be the empty string if guessing failed.
 	// Valid iff cachedManifest is not nil.
@@ -22,41 +20,49 @@ type UnparsedImage struct {
 	cachedSignatures       [][]byte // A private cache for Signatures(); nil if not yet known.
 }
 
-// UnparsedInstance returns a types.UnparsedImage implementation for (source, instanceDigest).
-// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve (when the primary manifest is a manifest list).
+// UnparsedFromSource returns a types.UnparsedImage implementation for source.
+// The caller must call .Close() on the returned UnparsedImage.
 //
-// The UnparsedImage must not be used after the underlying ImageSource is Close()d.
-func UnparsedInstance(src types.ImageSource, instanceDigest *digest.Digest) *UnparsedImage {
-	return &UnparsedImage{
-		src:            src,
-		instanceDigest: instanceDigest,
-	}
+// UnparsedFromSource “takes ownership” of the input ImageSource and will call src.Close()
+// when the image is closed.  (This does not prevent callers from using both the
+// UnparsedImage and ImageSource objects simultaneously, but it means that they only need to
+// keep a reference to the UnparsedImage.)
+func UnparsedFromSource(src types.ImageSource) *UnparsedImage {
+	return &UnparsedImage{src: src}
 }
 
 // Reference returns the reference used to set up this source, _as specified by the user_
 // (not as the image itself, or its underlying storage, claims).  This can be used e.g. to determine which public keys are trusted for this image.
 func (i *UnparsedImage) Reference() types.ImageReference {
-	// Note that this does not depend on instanceDigest; e.g. all instances within a manifest list need to be signed with the manifest list identity.
 	return i.src.Reference()
 }
 
+// Close removes resources associated with an initialized UnparsedImage, if any.
+func (i *UnparsedImage) Close() error {
+	return i.src.Close()
+}
+
 // Manifest is like ImageSource.GetManifest, but the result is cached; it is OK to call this however often you need.
 func (i *UnparsedImage) Manifest() ([]byte, string, error) {
 	if i.cachedManifest == nil {
-		m, mt, err := i.src.GetManifest(i.instanceDigest)
+		m, mt, err := i.src.GetManifest()
 		if err != nil {
 			return nil, "", err
 		}
 
 		// ImageSource.GetManifest does not do digest verification, but we do;
 		// this immediately protects also any user of types.Image.
-		if digest, haveDigest := i.expectedManifestDigest(); haveDigest {
-			matches, err := manifest.MatchesDigest(m, digest)
-			if err != nil {
-				return nil, "", errors.Wrap(err, "Error computing manifest digest")
-			}
-			if !matches {
-				return nil, "", errors.Errorf("Manifest does not match provided manifest digest %s", digest)
+		ref := i.Reference().DockerReference()
+		if ref != nil {
+			if canonical, ok := ref.(reference.Canonical); ok {
+				digest := digest.Digest(canonical.Digest())
+				matches, err := manifest.MatchesDigest(m, digest)
+				if err != nil {
+					return nil, "", errors.Wrap(err, "Error computing manifest digest")
+				}
+				if !matches {
+					return nil, "", errors.Errorf("Manifest does not match provided manifest digest %s", digest)
+				}
 			}
 		}
 
@@ -66,26 +72,10 @@ func (i *UnparsedImage) Manifest() ([]byte, string, error) {
 	return i.cachedManifest, i.cachedManifestMIMEType, nil
 }
 
-// expectedManifestDigest returns a the expected value of the manifest digest, and an indicator whether it is known.
-// The bool return value seems redundant with digest != ""; it is used explicitly
-// to refuse (unexpected) situations when the digest exists but is "".
-func (i *UnparsedImage) expectedManifestDigest() (digest.Digest, bool) {
-	if i.instanceDigest != nil {
-		return *i.instanceDigest, true
-	}
-	ref := i.Reference().DockerReference()
-	if ref != nil {
-		if canonical, ok := ref.(reference.Canonical); ok {
-			return canonical.Digest(), true
-		}
-	}
-	return "", false
-}
-
 // Signatures is like ImageSource.GetSignatures, but the result is cached; it is OK to call this however often you need.
 func (i *UnparsedImage) Signatures(ctx context.Context) ([][]byte, error) {
 	if i.cachedSignatures == nil {
-		sigs, err := i.src.GetSignatures(ctx, i.instanceDigest)
+		sigs, err := i.src.GetSignatures(ctx)
 		if err != nil {
 			return nil, err
 		}
@@ -93,10 +83,3 @@ func (i *UnparsedImage) Signatures(ctx context.Context) ([][]byte, error) {
 	}
 	return i.cachedSignatures, nil
 }
-
-// LayerInfosForCopy returns an updated set of layer blob information which may not match the manifest.
-// The Digest field is guaranteed to be provided; Size may be -1.
-// WARNING: The list may contain duplicates, and they are semantically relevant.
-func (i *UnparsedImage) LayerInfosForCopy() []types.BlobInfo {
-	return i.src.LayerInfosForCopy()
-}

vendor/github.com/containers/image/internal/tmpdir/tmpdir.go

@@ -1,19 +0,0 @@
-package tmpdir
-
-import (
-	"os"
-	"runtime"
-)
-
-// TemporaryDirectoryForBigFiles returns a directory for temporary (big) files.
-// On non Windows systems it avoids the use of os.TempDir(), because the default temporary directory usually falls under /tmp
-// which on systemd based systems could be the unsuitable tmpfs filesystem.
-func TemporaryDirectoryForBigFiles() string {
-	var temporaryDirectoryForBigFiles string
-	if runtime.GOOS == "windows" {
-		temporaryDirectoryForBigFiles = os.TempDir()
-	} else {
-		temporaryDirectoryForBigFiles = "/var/tmp"
-	}
-	return temporaryDirectoryForBigFiles
-}

vendor/github.com/containers/image/manifest/docker_schema1.go

@@ -1,310 +0,0 @@
-package manifest
-
-import (
-	"encoding/json"
-	"regexp"
-	"strings"
-	"time"
-
-	"github.com/containers/image/docker/reference"
-	"github.com/containers/image/types"
-	"github.com/docker/docker/api/types/versions"
-	"github.com/opencontainers/go-digest"
-	"github.com/pkg/errors"
-)
-
-// Schema1FSLayers is an entry of the "fsLayers" array in docker/distribution schema 1.
-type Schema1FSLayers struct {
-	BlobSum digest.Digest `json:"blobSum"`
-}
-
-// Schema1History is an entry of the "history" array in docker/distribution schema 1.
-type Schema1History struct {
-	V1Compatibility string `json:"v1Compatibility"`
-}
-
-// Schema1 is a manifest in docker/distribution schema 1.
-type Schema1 struct {
-	Name          string            `json:"name"`
-	Tag           string            `json:"tag"`
-	Architecture  string            `json:"architecture"`
-	FSLayers      []Schema1FSLayers `json:"fsLayers"`
-	History       []Schema1History  `json:"history"`
-	SchemaVersion int               `json:"schemaVersion"`
-}
-
-// Schema1V1Compatibility is a v1Compatibility in docker/distribution schema 1.
-type Schema1V1Compatibility struct {
-	ID              string    `json:"id"`
-	Parent          string    `json:"parent,omitempty"`
-	Comment         string    `json:"comment,omitempty"`
-	Created         time.Time `json:"created"`
-	ContainerConfig struct {
-		Cmd []string
-	} `json:"container_config,omitempty"`
-	Author    string `json:"author,omitempty"`
-	ThrowAway bool   `json:"throwaway,omitempty"`
-}
-
-// Schema1FromManifest creates a Schema1 manifest instance from a manifest blob.
-// (NOTE: The instance is not necessary a literal representation of the original blob,
-// layers with duplicate IDs are eliminated.)
-func Schema1FromManifest(manifest []byte) (*Schema1, error) {
-	s1 := Schema1{}
-	if err := json.Unmarshal(manifest, &s1); err != nil {
-		return nil, err
-	}
-	if s1.SchemaVersion != 1 {
-		return nil, errors.Errorf("unsupported schema version %d", s1.SchemaVersion)
-	}
-	if len(s1.FSLayers) != len(s1.History) {
-		return nil, errors.New("length of history not equal to number of layers")
-	}
-	if len(s1.FSLayers) == 0 {
-		return nil, errors.New("no FSLayers in manifest")
-	}
-	if err := s1.fixManifestLayers(); err != nil {
-		return nil, err
-	}
-	return &s1, nil
-}
-
-// Schema1FromComponents creates an Schema1 manifest instance from the supplied data.
-func Schema1FromComponents(ref reference.Named, fsLayers []Schema1FSLayers, history []Schema1History, architecture string) *Schema1 {
-	var name, tag string
-	if ref != nil { // Well, what to do if it _is_ nil? Most consumers actually don't use these fields nowadays, so we might as well try not supplying them.
-		name = reference.Path(ref)
-		if tagged, ok := ref.(reference.NamedTagged); ok {
-			tag = tagged.Tag()
-		}
-	}
-	return &Schema1{
-		Name:          name,
-		Tag:           tag,
-		Architecture:  architecture,
-		FSLayers:      fsLayers,
-		History:       history,
-		SchemaVersion: 1,
-	}
-}
-
-// Schema1Clone creates a copy of the supplied Schema1 manifest.
-func Schema1Clone(src *Schema1) *Schema1 {
-	copy := *src
-	return &copy
-}
-
-// ConfigInfo returns a complete BlobInfo for the separate config object, or a BlobInfo{Digest:""} if there isn't a separate object.
-func (m *Schema1) ConfigInfo() types.BlobInfo {
-	return types.BlobInfo{}
-}
-
-// LayerInfos returns a list of BlobInfos of layers referenced by this image, in order (the root layer first, and then successive layered layers).
-// The Digest field is guaranteed to be provided; Size may be -1.
-// WARNING: The list may contain duplicates, and they are semantically relevant.
-func (m *Schema1) LayerInfos() []types.BlobInfo {
-	layers := make([]types.BlobInfo, len(m.FSLayers))
-	for i, layer := range m.FSLayers { // NOTE: This includes empty layers (where m.History.V1Compatibility->ThrowAway)
-		layers[(len(m.FSLayers)-1)-i] = types.BlobInfo{Digest: layer.BlobSum, Size: -1}
-	}
-	return layers
-}
-
-// UpdateLayerInfos replaces the original layers with the specified BlobInfos (size+digest+urls), in order (the root layer first, and then successive layered layers)
-func (m *Schema1) UpdateLayerInfos(layerInfos []types.BlobInfo) error {
-	// Our LayerInfos includes empty layers (where m.History.V1Compatibility->ThrowAway), so expect them to be included here as well.
-	if len(m.FSLayers) != len(layerInfos) {
-		return errors.Errorf("Error preparing updated manifest: layer count changed from %d to %d", len(m.FSLayers), len(layerInfos))
-	}
-	for i, info := range layerInfos {
-		// (docker push) sets up m.History.V1Compatibility->{Id,Parent} based on values of info.Digest,
-		// but (docker pull) ignores them in favor of computing DiffIDs from uncompressed data, except verifying the child->parent links and uniqueness.
-		// So, we don't bother recomputing the IDs in m.History.V1Compatibility.
-		m.FSLayers[(len(layerInfos)-1)-i].BlobSum = info.Digest
-	}
-	return nil
-}
-
-// Serialize returns the manifest in a blob format.
-// NOTE: Serialize() does not in general reproduce the original blob if this object was loaded from one, even if no modifications were made!
-func (m *Schema1) Serialize() ([]byte, error) {
-	// docker/distribution requires a signature even if the incoming data uses the nominally unsigned DockerV2Schema1MediaType.
-	unsigned, err := json.Marshal(*m)
-	if err != nil {
-		return nil, err
-	}
-	return AddDummyV2S1Signature(unsigned)
-}
-
-// fixManifestLayers, after validating the supplied manifest
-// (to use correctly-formatted IDs, and to not have non-consecutive ID collisions in m.History),
-// modifies manifest to only have one entry for each layer ID in m.History (deleting the older duplicates,
-// both from m.History and m.FSLayers).
-// Note that even after this succeeds, m.FSLayers may contain duplicate entries
-// (for Dockerfile operations which change the configuration but not the filesystem).
-func (m *Schema1) fixManifestLayers() error {
-	type imageV1 struct {
-		ID     string
-		Parent string
-	}
-	// Per the specification, we can assume that len(m.FSLayers) == len(m.History)
-	imgs := make([]*imageV1, len(m.FSLayers))
-	for i := range m.FSLayers {
-		img := &imageV1{}
-
-		if err := json.Unmarshal([]byte(m.History[i].V1Compatibility), img); err != nil {
-			return err
-		}
-
-		imgs[i] = img
-		if err := validateV1ID(img.ID); err != nil {
-			return err
-		}
-	}
-	if imgs[len(imgs)-1].Parent != "" {
-		return errors.New("Invalid parent ID in the base layer of the image")
-	}
-	// check general duplicates to error instead of a deadlock
-	idmap := make(map[string]struct{})
-	var lastID string
-	for _, img := range imgs {
-		// skip IDs that appear after each other, we handle those later
-		if _, exists := idmap[img.ID]; img.ID != lastID && exists {
-			return errors.Errorf("ID %+v appears multiple times in manifest", img.ID)
-		}
-		lastID = img.ID
-		idmap[lastID] = struct{}{}
-	}
-	// backwards loop so that we keep the remaining indexes after removing items
-	for i := len(imgs) - 2; i >= 0; i-- {
-		if imgs[i].ID == imgs[i+1].ID { // repeated ID. remove and continue
-			m.FSLayers = append(m.FSLayers[:i], m.FSLayers[i+1:]...)
-			m.History = append(m.History[:i], m.History[i+1:]...)
-		} else if imgs[i].Parent != imgs[i+1].ID {
-			return errors.Errorf("Invalid parent ID. Expected %v, got %v", imgs[i+1].ID, imgs[i].Parent)
-		}
-	}
-	return nil
-}
-
-var validHex = regexp.MustCompile(`^([a-f0-9]{64})$`)
-
-func validateV1ID(id string) error {
-	if ok := validHex.MatchString(id); !ok {
-		return errors.Errorf("image ID %q is invalid", id)
-	}
-	return nil
-}
-
-// Inspect returns various information for (skopeo inspect) parsed from the manifest and configuration.
-func (m *Schema1) Inspect(_ func(types.BlobInfo) ([]byte, error)) (*types.ImageInspectInfo, error) {
-	s1 := &Schema2V1Image{}
-	if err := json.Unmarshal([]byte(m.History[0].V1Compatibility), s1); err != nil {
-		return nil, err
-	}
-	return &types.ImageInspectInfo{
-		Tag:           m.Tag,
-		Created:       s1.Created,
-		DockerVersion: s1.DockerVersion,
-		Labels:        make(map[string]string),
-		Architecture:  s1.Architecture,
-		Os:            s1.OS,
-		Layers:        LayerInfosToStrings(m.LayerInfos()),
-	}, nil
-}
-
-// ToSchema2 builds a schema2-style configuration blob using the supplied diffIDs.
-func (m *Schema1) ToSchema2(diffIDs []digest.Digest) ([]byte, error) {
-	// Convert the schema 1 compat info into a schema 2 config, constructing some of the fields
-	// that aren't directly comparable using info from the manifest.
-	if len(m.History) == 0 {
-		return nil, errors.New("image has no layers")
-	}
-	s2 := struct {
-		Schema2Image
-		ID        string `json:"id,omitempty"`
-		Parent    string `json:"parent,omitempty"`
-		ParentID  string `json:"parent_id,omitempty"`
-		LayerID   string `json:"layer_id,omitempty"`
-		ThrowAway bool   `json:"throwaway,omitempty"`
-		Size      int64  `json:",omitempty"`
-	}{}
-	config := []byte(m.History[0].V1Compatibility)
-	err := json.Unmarshal(config, &s2)
-	if err != nil {
-		return nil, errors.Wrapf(err, "error decoding configuration")
-	}
-	// Images created with versions prior to 1.8.3 require us to re-encode the encoded object,
-	// adding some fields that aren't "omitempty".
-	if s2.DockerVersion != "" && versions.LessThan(s2.DockerVersion, "1.8.3") {
-		config, err = json.Marshal(&s2)
-		if err != nil {
-			return nil, errors.Wrapf(err, "error re-encoding compat image config %#v", s2)
-		}
-	}
-	// Build the history.
-	convertedHistory := []Schema2History{}
-	for _, h := range m.History {
-		compat := Schema1V1Compatibility{}
-		if err := json.Unmarshal([]byte(h.V1Compatibility), &compat); err != nil {
-			return nil, errors.Wrapf(err, "error decoding history information")
-		}
-		hitem := Schema2History{
-			Created:    compat.Created,
-			CreatedBy:  strings.Join(compat.ContainerConfig.Cmd, " "),
-			Author:     compat.Author,
-			Comment:    compat.Comment,
-			EmptyLayer: compat.ThrowAway,
-		}
-		convertedHistory = append([]Schema2History{hitem}, convertedHistory...)
-	}
-	// Build the rootfs information.  We need the decompressed sums that we've been
-	// calculating to fill in the DiffIDs.  It's expected (but not enforced by us)
-	// that the number of diffIDs corresponds to the number of non-EmptyLayer
-	// entries in the history.
-	rootFS := &Schema2RootFS{
-		Type:    "layers",
-		DiffIDs: diffIDs,
-	}
-	// And now for some raw manipulation.
-	raw := make(map[string]*json.RawMessage)
-	err = json.Unmarshal(config, &raw)
-	if err != nil {
-		return nil, errors.Wrapf(err, "error re-decoding compat image config %#v: %v", s2)
-	}
-	// Drop some fields.
-	delete(raw, "id")
-	delete(raw, "parent")
-	delete(raw, "parent_id")
-	delete(raw, "layer_id")
-	delete(raw, "throwaway")
-	delete(raw, "Size")
-	// Add the history and rootfs information.
-	rootfs, err := json.Marshal(rootFS)
-	if err != nil {
-		return nil, errors.Errorf("error encoding rootfs information %#v: %v", rootFS, err)
-	}
-	rawRootfs := json.RawMessage(rootfs)
-	raw["rootfs"] = &rawRootfs
-	history, err := json.Marshal(convertedHistory)
-	if err != nil {
-		return nil, errors.Errorf("error encoding history information %#v: %v", convertedHistory, err)
-	}
-	rawHistory := json.RawMessage(history)
-	raw["history"] = &rawHistory
-	// Encode the result.
-	config, err = json.Marshal(raw)
-	if err != nil {
-		return nil, errors.Errorf("error re-encoding compat image config %#v: %v", s2, err)
-	}
-	return config, nil
-}
-
-// ImageID computes an ID which can uniquely identify this image by its contents.
-func (m *Schema1) ImageID(diffIDs []digest.Digest) (string, error) {
-	image, err := m.ToSchema2(diffIDs)
-	if err != nil {
-		return "", err
-	}
-	return digest.FromBytes(image).Hex(), nil
-}

vendor/github.com/containers/image/manifest/docker_schema2.go

@@ -1,251 +0,0 @@
-package manifest
-
-import (
-	"encoding/json"
-	"time"
-
-	"github.com/containers/image/pkg/strslice"
-	"github.com/containers/image/types"
-	"github.com/opencontainers/go-digest"
-	"github.com/pkg/errors"
-)
-
-// Schema2Descriptor is a “descriptor” in docker/distribution schema 2.
-type Schema2Descriptor struct {
-	MediaType string        `json:"mediaType"`
-	Size      int64         `json:"size"`
-	Digest    digest.Digest `json:"digest"`
-	URLs      []string      `json:"urls,omitempty"`
-}
-
-// Schema2 is a manifest in docker/distribution schema 2.
-type Schema2 struct {
-	SchemaVersion     int                 `json:"schemaVersion"`
-	MediaType         string              `json:"mediaType"`
-	ConfigDescriptor  Schema2Descriptor   `json:"config"`
-	LayersDescriptors []Schema2Descriptor `json:"layers"`
-}
-
-// Schema2Port is a Port, a string containing port number and protocol in the
-// format "80/tcp", from docker/go-connections/nat.
-type Schema2Port string
-
-// Schema2PortSet is a PortSet, a collection of structs indexed by Port, from
-// docker/go-connections/nat.
-type Schema2PortSet map[Schema2Port]struct{}
-
-// Schema2HealthConfig is a HealthConfig, which holds configuration settings
-// for the HEALTHCHECK feature, from docker/docker/api/types/container.
-type Schema2HealthConfig struct {
-	// Test is the test to perform to check that the container is healthy.
-	// An empty slice means to inherit the default.
-	// The options are:
-	// {} : inherit healthcheck
-	// {"NONE"} : disable healthcheck
-	// {"CMD", args...} : exec arguments directly
-	// {"CMD-SHELL", command} : run command with system's default shell
-	Test []string `json:",omitempty"`
-
-	// Zero means to inherit. Durations are expressed as integer nanoseconds.
-	Interval time.Duration `json:",omitempty"` // Interval is the time to wait between checks.
-	Timeout  time.Duration `json:",omitempty"` // Timeout is the time to wait before considering the check to have hung.
-
-	// Retries is the number of consecutive failures needed to consider a container as unhealthy.
-	// Zero means inherit.
-	Retries int `json:",omitempty"`
-}
-
-// Schema2Config is a Config in docker/docker/api/types/container.
-type Schema2Config struct {
-	Hostname        string               // Hostname
-	Domainname      string               // Domainname
-	User            string               // User that will run the command(s) inside the container, also support user:group
-	AttachStdin     bool                 // Attach the standard input, makes possible user interaction
-	AttachStdout    bool                 // Attach the standard output
-	AttachStderr    bool                 // Attach the standard error
-	ExposedPorts    Schema2PortSet       `json:",omitempty"` // List of exposed ports
-	Tty             bool                 // Attach standard streams to a tty, including stdin if it is not closed.
-	OpenStdin       bool                 // Open stdin
-	StdinOnce       bool                 // If true, close stdin after the 1 attached client disconnects.
-	Env             []string             // List of environment variable to set in the container
-	Cmd             strslice.StrSlice    // Command to run when starting the container
-	Healthcheck     *Schema2HealthConfig `json:",omitempty"` // Healthcheck describes how to check the container is healthy
-	ArgsEscaped     bool                 `json:",omitempty"` // True if command is already escaped (Windows specific)
-	Image           string               // Name of the image as it was passed by the operator (e.g. could be symbolic)
-	Volumes         map[string]struct{}  // List of volumes (mounts) used for the container
-	WorkingDir      string               // Current directory (PWD) in the command will be launched
-	Entrypoint      strslice.StrSlice    // Entrypoint to run when starting the container
-	NetworkDisabled bool                 `json:",omitempty"` // Is network disabled
-	MacAddress      string               `json:",omitempty"` // Mac Address of the container
-	OnBuild         []string             // ONBUILD metadata that were defined on the image Dockerfile
-	Labels          map[string]string    // List of labels set to this container
-	StopSignal      string               `json:",omitempty"` // Signal to stop a container
-	StopTimeout     *int                 `json:",omitempty"` // Timeout (in seconds) to stop a container
-	Shell           strslice.StrSlice    `json:",omitempty"` // Shell for shell-form of RUN, CMD, ENTRYPOINT
-}
-
-// Schema2V1Image is a V1Image in docker/docker/image.
-type Schema2V1Image struct {
-	// ID is a unique 64 character identifier of the image
-	ID string `json:"id,omitempty"`
-	// Parent is the ID of the parent image
-	Parent string `json:"parent,omitempty"`
-	// Comment is the commit message that was set when committing the image
-	Comment string `json:"comment,omitempty"`
-	// Created is the timestamp at which the image was created
-	Created time.Time `json:"created"`
-	// Container is the id of the container used to commit
-	Container string `json:"container,omitempty"`
-	// ContainerConfig is the configuration of the container that is committed into the image
-	ContainerConfig Schema2Config `json:"container_config,omitempty"`
-	// DockerVersion specifies the version of Docker that was used to build the image
-	DockerVersion string `json:"docker_version,omitempty"`
-	// Author is the name of the author that was specified when committing the image
-	Author string `json:"author,omitempty"`
-	// Config is the configuration of the container received from the client
-	Config *Schema2Config `json:"config,omitempty"`
-	// Architecture is the hardware that the image is build and runs on
-	Architecture string `json:"architecture,omitempty"`
-	// OS is the operating system used to build and run the image
-	OS string `json:"os,omitempty"`
-	// Size is the total size of the image including all layers it is composed of
-	Size int64 `json:",omitempty"`
-}
-
-// Schema2RootFS is a description of how to build up an image's root filesystem, from docker/docker/image.
-type Schema2RootFS struct {
-	Type    string          `json:"type"`
-	DiffIDs []digest.Digest `json:"diff_ids,omitempty"`
-}
-
-// Schema2History stores build commands that were used to create an image, from docker/docker/image.
-type Schema2History struct {
-	// Created is the timestamp at which the image was created
-	Created time.Time `json:"created"`
-	// Author is the name of the author that was specified when committing the image
-	Author string `json:"author,omitempty"`
-	// CreatedBy keeps the Dockerfile command used while building the image
-	CreatedBy string `json:"created_by,omitempty"`
-	// Comment is the commit message that was set when committing the image
-	Comment string `json:"comment,omitempty"`
-	// EmptyLayer is set to true if this history item did not generate a
-	// layer. Otherwise, the history item is associated with the next
-	// layer in the RootFS section.
-	EmptyLayer bool `json:"empty_layer,omitempty"`
-}
-
-// Schema2Image is an Image in docker/docker/image.
-type Schema2Image struct {
-	Schema2V1Image
-	Parent     digest.Digest    `json:"parent,omitempty"`
-	RootFS     *Schema2RootFS   `json:"rootfs,omitempty"`
-	History    []Schema2History `json:"history,omitempty"`
-	OSVersion  string           `json:"os.version,omitempty"`
-	OSFeatures []string         `json:"os.features,omitempty"`
-
-	// rawJSON caches the immutable JSON associated with this image.
-	rawJSON []byte
-
-	// computedID is the ID computed from the hash of the image config.
-	// Not to be confused with the legacy V1 ID in V1Image.
-	computedID digest.Digest
-}
-
-// Schema2FromManifest creates a Schema2 manifest instance from a manifest blob.
-func Schema2FromManifest(manifest []byte) (*Schema2, error) {
-	s2 := Schema2{}
-	if err := json.Unmarshal(manifest, &s2); err != nil {
-		return nil, err
-	}
-	return &s2, nil
-}
-
-// Schema2FromComponents creates an Schema2 manifest instance from the supplied data.
-func Schema2FromComponents(config Schema2Descriptor, layers []Schema2Descriptor) *Schema2 {
-	return &Schema2{
-		SchemaVersion:     2,
-		MediaType:         DockerV2Schema2MediaType,
-		ConfigDescriptor:  config,
-		LayersDescriptors: layers,
-	}
-}
-
-// Schema2Clone creates a copy of the supplied Schema2 manifest.
-func Schema2Clone(src *Schema2) *Schema2 {
-	copy := *src
-	return &copy
-}
-
-// ConfigInfo returns a complete BlobInfo for the separate config object, or a BlobInfo{Digest:""} if there isn't a separate object.
-func (m *Schema2) ConfigInfo() types.BlobInfo {
-	return types.BlobInfo{Digest: m.ConfigDescriptor.Digest, Size: m.ConfigDescriptor.Size}
-}
-
-// LayerInfos returns a list of BlobInfos of layers referenced by this image, in order (the root layer first, and then successive layered layers).
-// The Digest field is guaranteed to be provided; Size may be -1.
-// WARNING: The list may contain duplicates, and they are semantically relevant.
-func (m *Schema2) LayerInfos() []types.BlobInfo {
-	blobs := []types.BlobInfo{}
-	for _, layer := range m.LayersDescriptors {
-		blobs = append(blobs, types.BlobInfo{
-			Digest: layer.Digest,
-			Size:   layer.Size,
-			URLs:   layer.URLs,
-		})
-	}
-	return blobs
-}
-
-// UpdateLayerInfos replaces the original layers with the specified BlobInfos (size+digest+urls), in order (the root layer first, and then successive layered layers)
-func (m *Schema2) UpdateLayerInfos(layerInfos []types.BlobInfo) error {
-	if len(m.LayersDescriptors) != len(layerInfos) {
-		return errors.Errorf("Error preparing updated manifest: layer count changed from %d to %d", len(m.LayersDescriptors), len(layerInfos))
-	}
-	original := m.LayersDescriptors
-	m.LayersDescriptors = make([]Schema2Descriptor, len(layerInfos))
-	for i, info := range layerInfos {
-		m.LayersDescriptors[i].MediaType = original[i].MediaType
-		m.LayersDescriptors[i].Digest = info.Digest
-		m.LayersDescriptors[i].Size = info.Size
-		m.LayersDescriptors[i].URLs = info.URLs
-	}
-	return nil
-}
-
-// Serialize returns the manifest in a blob format.
-// NOTE: Serialize() does not in general reproduce the original blob if this object was loaded from one, even if no modifications were made!
-func (m *Schema2) Serialize() ([]byte, error) {
-	return json.Marshal(*m)
-}
-
-// Inspect returns various information for (skopeo inspect) parsed from the manifest and configuration.
-func (m *Schema2) Inspect(configGetter func(types.BlobInfo) ([]byte, error)) (*types.ImageInspectInfo, error) {
-	config, err := configGetter(m.ConfigInfo())
-	if err != nil {
-		return nil, err
-	}
-	s2 := &Schema2Image{}
-	if err := json.Unmarshal(config, s2); err != nil {
-		return nil, err
-	}
-	i := &types.ImageInspectInfo{
-		Tag:           "",
-		Created:       s2.Created,
-		DockerVersion: s2.DockerVersion,
-		Architecture:  s2.Architecture,
-		Os:            s2.OS,
-		Layers:        LayerInfosToStrings(m.LayerInfos()),
-	}
-	if s2.Config != nil {
-		i.Labels = s2.Config.Labels
-	}
-	return i, nil
-}
-
-// ImageID computes an ID which can uniquely identify this image by its contents.
-func (m *Schema2) ImageID([]digest.Digest) (string, error) {
-	if err := m.ConfigDescriptor.Digest.Validate(); err != nil {
-		return "", err
-	}
-	return m.ConfigDescriptor.Digest.Hex(), nil
-}

vendor/github.com/containers/image/manifest/manifest.go

@@ -2,9 +2,7 @@ package manifest
 
 import (
 	"encoding/json"
-	"fmt"
 
-	"github.com/containers/image/types"
 	"github.com/docker/libtrust"
 	"github.com/opencontainers/go-digest"
 	imgspecv1 "github.com/opencontainers/image-spec/specs-go/v1"
@@ -37,40 +35,7 @@ var DefaultRequestedManifestMIMETypes = []string{
 	DockerV2Schema2MediaType,
 	DockerV2Schema1SignedMediaType,
 	DockerV2Schema1MediaType,
-	DockerV2ListMediaType,
-}
-
-// Manifest is an interface for parsing, modifying image manifests in isolation.
-// Callers can either use this abstract interface without understanding the details of the formats,
-// or instantiate a specific implementation (e.g. manifest.OCI1) and access the public members
-// directly.
-//
-// See types.Image for functionality not limited to manifests, including format conversions and config parsing.
-// This interface is similar to, but not strictly equivalent to, the equivalent methods in types.Image.
-type Manifest interface {
-	// ConfigInfo returns a complete BlobInfo for the separate config object, or a BlobInfo{Digest:""} if there isn't a separate object.
-	ConfigInfo() types.BlobInfo
-	// LayerInfos returns a list of BlobInfos of layers referenced by this image, in order (the root layer first, and then successive layered layers).
-	// The Digest field is guaranteed to be provided; Size may be -1.
-	// WARNING: The list may contain duplicates, and they are semantically relevant.
-	LayerInfos() []types.BlobInfo
-	// UpdateLayerInfos replaces the original layers with the specified BlobInfos (size+digest+urls), in order (the root layer first, and then successive layered layers)
-	UpdateLayerInfos(layerInfos []types.BlobInfo) error
-
-	// ImageID computes an ID which can uniquely identify this image by its contents, irrespective
-	// of which (of possibly more than one simultaneously valid) reference was used to locate the
-	// image, and unchanged by whether or how the layers are compressed.  The result takes the form
-	// of the hexadecimal portion of a digest.Digest.
-	ImageID(diffIDs []digest.Digest) (string, error)
-
-	// Inspect returns various information for (skopeo inspect) parsed from the manifest,
-	// incorporating information from a configuration blob returned by configGetter, if
-	// the underlying image format is expected to include a configuration blob.
-	Inspect(configGetter func(types.BlobInfo) ([]byte, error)) (*types.ImageInspectInfo, error)
-
-	// Serialize returns the manifest in a blob format.
-	// NOTE: Serialize() does not in general reproduce the original blob if this object was loaded from one, even if no modifications were made!
-	Serialize() ([]byte, error)
+	// DockerV2ListMediaType, // FIXME: Restore this ASAP
 }
 
 // GuessMIMEType guesses MIME type of a manifest and returns it _if it is recognized_, or "" if unknown or unrecognized.
@@ -177,62 +142,3 @@ func AddDummyV2S1Signature(manifest []byte) ([]byte, error) {
 	}
 	return js.PrettySignature("signatures")
 }
-
-// MIMETypeIsMultiImage returns true if mimeType is a list of images
-func MIMETypeIsMultiImage(mimeType string) bool {
-	return mimeType == DockerV2ListMediaType
-}
-
-// NormalizedMIMEType returns the effective MIME type of a manifest MIME type returned by a server,
-// centralizing various workarounds.
-func NormalizedMIMEType(input string) string {
-	switch input {
-	// "application/json" is a valid v2s1 value per https://github.com/docker/distribution/blob/master/docs/spec/manifest-v2-1.md .
-	// This works for now, when nothing else seems to return "application/json"; if that were not true, the mapping/detection might
-	// need to happen within the ImageSource.
-	case "application/json":
-		return DockerV2Schema1SignedMediaType
-	case DockerV2Schema1MediaType, DockerV2Schema1SignedMediaType,
-		imgspecv1.MediaTypeImageManifest,
-		DockerV2Schema2MediaType,
-		DockerV2ListMediaType:
-		return input
-	default:
-		// If it's not a recognized manifest media type, or we have failed determining the type, we'll try one last time
-		// to deserialize using v2s1 as per https://github.com/docker/distribution/blob/master/manifests.go#L108
-		// and https://github.com/docker/distribution/blob/master/manifest/schema1/manifest.go#L50
-		//
-		// Crane registries can also return "text/plain", or pretty much anything else depending on a file extension “recognized” in the tag.
-		// This makes no real sense, but it happens
-		// because requests for manifests are
-		// redirected to a content distribution
-		// network which is configured that way. See https://bugzilla.redhat.com/show_bug.cgi?id=1389442
-		return DockerV2Schema1SignedMediaType
-	}
-}
-
-// FromBlob returns a Manifest instance for the specified manifest blob and the corresponding MIME type
-func FromBlob(manblob []byte, mt string) (Manifest, error) {
-	switch NormalizedMIMEType(mt) {
-	case DockerV2Schema1MediaType, DockerV2Schema1SignedMediaType:
-		return Schema1FromManifest(manblob)
-	case imgspecv1.MediaTypeImageManifest:
-		return OCI1FromManifest(manblob)
-	case DockerV2Schema2MediaType:
-		return Schema2FromManifest(manblob)
-	case DockerV2ListMediaType:
-		return nil, fmt.Errorf("Treating manifest lists as individual manifests is not implemented")
-	default: // Note that this may not be reachable, NormalizedMIMEType has a default for unknown values.
-		return nil, fmt.Errorf("Unimplemented manifest MIME type %s", mt)
-	}
-}
-
-// LayerInfosToStrings converts a list of layer infos, presumably obtained from a Manifest.LayerInfos()
-// method call, into a format suitable for inclusion in a types.ImageInspectInfo structure.
-func LayerInfosToStrings(infos []types.BlobInfo) []string {
-	layers := make([]string, len(infos))
-	for i, info := range infos {
-		layers[i] = info.Digest.String()
-	}
-	return layers
-}

vendor/github.com/containers/image/manifest/oci.go

@@ -1,120 +0,0 @@
-package manifest
-
-import (
-	"encoding/json"
-	"time"
-
-	"github.com/containers/image/types"
-	"github.com/opencontainers/go-digest"
-	"github.com/opencontainers/image-spec/specs-go"
-	imgspecv1 "github.com/opencontainers/image-spec/specs-go/v1"
-	"github.com/pkg/errors"
-)
-
-// OCI1 is a manifest.Manifest implementation for OCI images.
-// The underlying data from imgspecv1.Manifest is also available.
-type OCI1 struct {
-	imgspecv1.Manifest
-}
-
-// OCI1FromManifest creates an OCI1 manifest instance from a manifest blob.
-func OCI1FromManifest(manifest []byte) (*OCI1, error) {
-	oci1 := OCI1{}
-	if err := json.Unmarshal(manifest, &oci1); err != nil {
-		return nil, err
-	}
-	return &oci1, nil
-}
-
-// OCI1FromComponents creates an OCI1 manifest instance from the supplied data.
-func OCI1FromComponents(config imgspecv1.Descriptor, layers []imgspecv1.Descriptor) *OCI1 {
-	return &OCI1{
-		imgspecv1.Manifest{
-			Versioned: specs.Versioned{SchemaVersion: 2},
-			Config:    config,
-			Layers:    layers,
-		},
-	}
-}
-
-// OCI1Clone creates a copy of the supplied OCI1 manifest.
-func OCI1Clone(src *OCI1) *OCI1 {
-	return &OCI1{
-		Manifest: src.Manifest,
-	}
-}
-
-// ConfigInfo returns a complete BlobInfo for the separate config object, or a BlobInfo{Digest:""} if there isn't a separate object.
-func (m *OCI1) ConfigInfo() types.BlobInfo {
-	return types.BlobInfo{Digest: m.Config.Digest, Size: m.Config.Size, Annotations: m.Config.Annotations}
-}
-
-// LayerInfos returns a list of BlobInfos of layers referenced by this image, in order (the root layer first, and then successive layered layers).
-// The Digest field is guaranteed to be provided; Size may be -1.
-// WARNING: The list may contain duplicates, and they are semantically relevant.
-func (m *OCI1) LayerInfos() []types.BlobInfo {
-	blobs := []types.BlobInfo{}
-	for _, layer := range m.Layers {
-		blobs = append(blobs, types.BlobInfo{Digest: layer.Digest, Size: layer.Size, Annotations: layer.Annotations, URLs: layer.URLs, MediaType: layer.MediaType})
-	}
-	return blobs
-}
-
-// UpdateLayerInfos replaces the original layers with the specified BlobInfos (size+digest+urls), in order (the root layer first, and then successive layered layers)
-func (m *OCI1) UpdateLayerInfos(layerInfos []types.BlobInfo) error {
-	if len(m.Layers) != len(layerInfos) {
-		return errors.Errorf("Error preparing updated manifest: layer count changed from %d to %d", len(m.Layers), len(layerInfos))
-	}
-	original := m.Layers
-	m.Layers = make([]imgspecv1.Descriptor, len(layerInfos))
-	for i, info := range layerInfos {
-		m.Layers[i].MediaType = original[i].MediaType
-		m.Layers[i].Digest = info.Digest
-		m.Layers[i].Size = info.Size
-		m.Layers[i].Annotations = info.Annotations
-		m.Layers[i].URLs = info.URLs
-	}
-	return nil
-}
-
-// Serialize returns the manifest in a blob format.
-// NOTE: Serialize() does not in general reproduce the original blob if this object was loaded from one, even if no modifications were made!
-func (m *OCI1) Serialize() ([]byte, error) {
-	return json.Marshal(*m)
-}
-
-// Inspect returns various information for (skopeo inspect) parsed from the manifest and configuration.
-func (m *OCI1) Inspect(configGetter func(types.BlobInfo) ([]byte, error)) (*types.ImageInspectInfo, error) {
-	config, err := configGetter(m.ConfigInfo())
-	if err != nil {
-		return nil, err
-	}
-	v1 := &imgspecv1.Image{}
-	if err := json.Unmarshal(config, v1); err != nil {
-		return nil, err
-	}
-	d1 := &Schema2V1Image{}
-	json.Unmarshal(config, d1)
-	created := time.Time{}
-	if v1.Created != nil {
-		created = *v1.Created
-	}
-	i := &types.ImageInspectInfo{
-		Tag:           "",
-		Created:       created,
-		DockerVersion: d1.DockerVersion,
-		Labels:        v1.Config.Labels,
-		Architecture:  v1.Architecture,
-		Os:            v1.OS,
-		Layers:        LayerInfosToStrings(m.LayerInfos()),
-	}
-	return i, nil
-}
-
-// ImageID computes an ID which can uniquely identify this image by its contents.
-func (m *OCI1) ImageID([]digest.Digest) (string, error) {
-	if err := m.Config.Digest.Validate(); err != nil {
-		return "", err
-	}
-	return m.Config.Digest.Hex(), nil
-}

vendor/github.com/containers/image/oci/archive/oci_src.go

@@ -68,12 +68,14 @@ func (s *ociArchiveImageSource) Close() error {
 	return s.unpackedSrc.Close()
 }
 
-// GetManifest returns the image's manifest along with its MIME type (which may be empty when it can't be determined but the manifest is available).
-// It may use a remote (= slow) service.
-// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve (when the primary manifest is a manifest list);
-// this never happens if the primary manifest is not a manifest list (e.g. if the source never returns manifest lists).
-func (s *ociArchiveImageSource) GetManifest(instanceDigest *digest.Digest) ([]byte, string, error) {
-	return s.unpackedSrc.GetManifest(instanceDigest)
+// GetManifest returns the image's manifest along with its MIME type
+// (which may be empty when it can't be determined but the manifest is available).
+func (s *ociArchiveImageSource) GetManifest() ([]byte, string, error) {
+	return s.unpackedSrc.GetManifest()
+}
+
+func (s *ociArchiveImageSource) GetTargetManifest(digest digest.Digest) ([]byte, string, error) {
+	return s.unpackedSrc.GetTargetManifest(digest)
 }
 
 // GetBlob returns a stream for the specified blob, and the blob's size.
@@ -81,15 +83,6 @@ func (s *ociArchiveImageSource) GetBlob(info types.BlobInfo) (io.ReadCloser, int
 	return s.unpackedSrc.GetBlob(info)
 }
 
-// GetSignatures returns the image's signatures.  It may use a remote (= slow) service.
-// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve signatures for
-// (when the primary manifest is a manifest list); this never happens if the primary manifest is not a manifest list
-// (e.g. if the source never returns manifest lists).
-func (s *ociArchiveImageSource) GetSignatures(ctx context.Context, instanceDigest *digest.Digest) ([][]byte, error) {
-	return s.unpackedSrc.GetSignatures(ctx, instanceDigest)
-}
-
-// LayerInfosForCopy() returns updated layer info that should be used when reading, in preference to values in the manifest, if specified.
-func (s *ociArchiveImageSource) LayerInfosForCopy() []types.BlobInfo {
-	return nil
+func (s *ociArchiveImageSource) GetSignatures(c context.Context) ([][]byte, error) {
+	return s.unpackedSrc.GetSignatures(c)
 }

vendor/github.com/containers/image/oci/archive/oci_transport.go

@@ -4,13 +4,13 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
+	"path/filepath"
+	"regexp"
 	"strings"
 
 	"github.com/containers/image/directory/explicitfilepath"
 	"github.com/containers/image/docker/reference"
 	"github.com/containers/image/image"
-	"github.com/containers/image/internal/tmpdir"
-	"github.com/containers/image/oci/internal"
 	ocilayout "github.com/containers/image/oci/layout"
 	"github.com/containers/image/transports"
 	"github.com/containers/image/types"
@@ -48,12 +48,51 @@ func (t ociArchiveTransport) ParseReference(reference string) (types.ImageRefere
 
 // ValidatePolicyConfigurationScope checks that scope is a valid name for a signature.PolicyTransportScopes keys
 func (t ociArchiveTransport) ValidatePolicyConfigurationScope(scope string) error {
-	return internal.ValidateScope(scope)
+	var file string
+	sep := strings.SplitN(scope, ":", 2)
+	file = sep[0]
+
+	if len(sep) == 2 {
+		image := sep[1]
+		if !refRegexp.MatchString(image) {
+			return errors.Errorf("Invalid image %s", image)
+		}
+	}
+
+	if !strings.HasPrefix(file, "/") {
+		return errors.Errorf("Invalid scope %s: must be an absolute path", scope)
+	}
+	// Refuse also "/", otherwise "/" and "" would have the same semantics,
+	// and "" could be unexpectedly shadowed by the "/" entry.
+	// (Note: we do allow "/:someimage", a bit ridiculous but why refuse it?)
+	if scope == "/" {
+		return errors.New(`Invalid scope "/": Use the generic default scope ""`)
+	}
+	cleaned := filepath.Clean(file)
+	if cleaned != file {
+		return errors.Errorf(`Invalid scope %s: Uses non-canonical path format, perhaps try with path %s`, scope, cleaned)
+	}
+	return nil
 }
 
+// annotation spex from https://github.com/opencontainers/image-spec/blob/master/annotations.md#pre-defined-annotation-keys
+const (
+	separator = `(?:[-._:@+]|--)`
+	alphanum  = `(?:[A-Za-z0-9]+)`
+	component = `(?:` + alphanum + `(?:` + separator + alphanum + `)*)`
+)
+
+var refRegexp = regexp.MustCompile(`^` + component + `(?:/` + component + `)*$`)
+
 // ParseReference converts a string, which should not start with the ImageTransport.Name prefix, into an OCI ImageReference.
 func ParseReference(reference string) (types.ImageReference, error) {
-	file, image := internal.SplitPathAndImage(reference)
+	var file, image string
+	sep := strings.SplitN(reference, ":", 2)
+	file = sep[0]
+
+	if len(sep) == 2 {
+		image = sep[1]
+	}
 	return NewReference(file, image)
 }
 
@@ -63,15 +102,14 @@ func NewReference(file, image string) (types.ImageReference, error) {
 	if err != nil {
 		return nil, err
 	}
-
-	if err := internal.ValidateOCIPath(file); err != nil {
-		return nil, err
+	// This is necessary to prevent directory paths returned by PolicyConfigurationNamespaces
+	// from being ambiguous with values of PolicyConfigurationIdentity.
+	if strings.Contains(resolved, ":") {
+		return nil, errors.Errorf("Invalid OCI reference %s:%s: path %s contains a colon", file, image, resolved)
 	}
-
-	if err := internal.ValidateImageName(image); err != nil {
-		return nil, err
+	if len(image) > 0 && !refRegexp.MatchString(image) {
+		return nil, errors.Errorf("Invalid image %s", image)
 	}
-
 	return ociArchiveReference{file: file, resolvedFile: resolved, image: image}, nil
 }
 
@@ -116,17 +154,14 @@ func (ref ociArchiveReference) PolicyConfigurationNamespaces() []string {
 	return res
 }
 
-// NewImage returns a types.ImageCloser for this reference, possibly specialized for this ImageTransport.
-// The caller must call .Close() on the returned ImageCloser.
-// NOTE: If any kind of signature verification should happen, build an UnparsedImage from the value returned by NewImageSource,
-// verify that UnparsedImage, and convert it into a real Image via image.FromUnparsedImage.
-// WARNING: This may not do the right thing for a manifest list, see image.FromSource for details.
-func (ref ociArchiveReference) NewImage(ctx *types.SystemContext) (types.ImageCloser, error) {
+// NewImage returns a types.Image for this reference, possibly specialized for this ImageTransport.
+// The caller must call .Close() on the returned Image.
+func (ref ociArchiveReference) NewImage(ctx *types.SystemContext) (types.Image, error) {
 	src, err := newImageSource(ctx, ref)
 	if err != nil {
 		return nil, err
 	}
-	return image.FromSource(ctx, src)
+	return image.FromSource(src)
 }
 
 // NewImageSource returns a types.ImageSource for this reference.
@@ -159,7 +194,7 @@ func (t *tempDirOCIRef) deleteTempDir() error {
 
 // createOCIRef creates the oci reference of the image
 func createOCIRef(image string) (tempDirOCIRef, error) {
-	dir, err := ioutil.TempDir(tmpdir.TemporaryDirectoryForBigFiles(), "oci")
+	dir, err := ioutil.TempDir("/var/tmp", "oci")
 	if err != nil {
 		return tempDirOCIRef{}, errors.Wrapf(err, "error creating temp directory")
 	}

vendor/github.com/containers/image/oci/internal/oci_util.go

@@ -1,126 +0,0 @@
-package internal
-
-import (
-	"github.com/pkg/errors"
-	"path/filepath"
-	"regexp"
-	"runtime"
-	"strings"
-)
-
-// annotation spex from https://github.com/opencontainers/image-spec/blob/master/annotations.md#pre-defined-annotation-keys
-const (
-	separator = `(?:[-._:@+]|--)`
-	alphanum  = `(?:[A-Za-z0-9]+)`
-	component = `(?:` + alphanum + `(?:` + separator + alphanum + `)*)`
-)
-
-var refRegexp = regexp.MustCompile(`^` + component + `(?:/` + component + `)*$`)
-var windowsRefRegexp = regexp.MustCompile(`^([a-zA-Z]:\\.+?):(.*)$`)
-
-// ValidateImageName returns nil if the image name is empty or matches the open-containers image name specs.
-// In any other case an error is returned.
-func ValidateImageName(image string) error {
-	if len(image) == 0 {
-		return nil
-	}
-
-	var err error
-	if !refRegexp.MatchString(image) {
-		err = errors.Errorf("Invalid image %s", image)
-	}
-	return err
-}
-
-// SplitPathAndImage tries to split the provided OCI reference into the OCI path and image.
-// Neither path nor image parts are validated at this stage.
-func SplitPathAndImage(reference string) (string, string) {
-	if runtime.GOOS == "windows" {
-		return splitPathAndImageWindows(reference)
-	}
-	return splitPathAndImageNonWindows(reference)
-}
-
-func splitPathAndImageWindows(reference string) (string, string) {
-	groups := windowsRefRegexp.FindStringSubmatch(reference)
-	// nil group means no match
-	if groups == nil {
-		return reference, ""
-	}
-
-	// we expect three elements. First one full match, second the capture group for the path and
-	// the third the capture group for the image
-	if len(groups) != 3 {
-		return reference, ""
-	}
-	return groups[1], groups[2]
-}
-
-func splitPathAndImageNonWindows(reference string) (string, string) {
-	sep := strings.SplitN(reference, ":", 2)
-	path := sep[0]
-
-	var image string
-	if len(sep) == 2 {
-		image = sep[1]
-	}
-	return path, image
-}
-
-// ValidateOCIPath takes the OCI path and validates it.
-func ValidateOCIPath(path string) error {
-	if runtime.GOOS == "windows" {
-		// On Windows we must allow for a ':' as part of the path
-		if strings.Count(path, ":") > 1 {
-			return errors.Errorf("Invalid OCI reference: path %s contains more than one colon", path)
-		}
-	} else {
-		if strings.Contains(path, ":") {
-			return errors.Errorf("Invalid OCI reference: path %s contains a colon", path)
-		}
-	}
-	return nil
-}
-
-// ValidateScope validates a policy configuration scope for an OCI transport.
-func ValidateScope(scope string) error {
-	var err error
-	if runtime.GOOS == "windows" {
-		err = validateScopeWindows(scope)
-	} else {
-		err = validateScopeNonWindows(scope)
-	}
-	if err != nil {
-		return err
-	}
-
-	cleaned := filepath.Clean(scope)
-	if cleaned != scope {
-		return errors.Errorf(`Invalid scope %s: Uses non-canonical path format, perhaps try with path %s`, scope, cleaned)
-	}
-
-	return nil
-}
-
-func validateScopeWindows(scope string) error {
-	matched, _ := regexp.Match(`^[a-zA-Z]:\\`, []byte(scope))
-	if !matched {
-		return errors.Errorf("Invalid scope '%s'. Must be an absolute path", scope)
-	}
-
-	return nil
-}
-
-func validateScopeNonWindows(scope string) error {
-	if !strings.HasPrefix(scope, "/") {
-		return errors.Errorf("Invalid scope %s: must be an absolute path", scope)
-	}
-
-	// Refuse also "/", otherwise "/" and "" would have the same semantics,
-	// and "" could be unexpectedly shadowed by the "/" entry.
-	if scope == "/" {
-		return errors.New(`Invalid scope "/": Use the generic default scope ""`)
-	}
-
-	return nil
-}

vendor/github.com/containers/image/oci/layout/oci_dest.go

@@ -18,47 +18,21 @@ import (
 )
 
 type ociImageDestination struct {
-	ref           ociReference
-	index         imgspecv1.Index
-	sharedBlobDir string
+	ref   ociReference
+	index imgspecv1.Index
 }
 
 // newImageDestination returns an ImageDestination for writing to an existing directory.
-func newImageDestination(ctx *types.SystemContext, ref ociReference) (types.ImageDestination, error) {
+func newImageDestination(ref ociReference) (types.ImageDestination, error) {
 	if ref.image == "" {
 		return nil, errors.Errorf("cannot save image with empty image.ref.name")
 	}
-
-	var index *imgspecv1.Index
-	if indexExists(ref) {
-		var err error
-		index, err = ref.getIndex()
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		index = &imgspecv1.Index{
-			Versioned: imgspec.Versioned{
-				SchemaVersion: 2,
-			},
-		}
+	index := imgspecv1.Index{
+		Versioned: imgspec.Versioned{
+			SchemaVersion: 2,
+		},
 	}
-
-	d := &ociImageDestination{ref: ref, index: *index}
-	if ctx != nil {
-		d.sharedBlobDir = ctx.OCISharedBlobDirPath
-	}
-
-	if err := ensureDirectoryExists(d.ref.dir); err != nil {
-		return nil, err
-	}
-	// Per the OCI image specification, layouts MUST have a "blobs" subdirectory,
-	// but it MAY be empty (e.g. if we never end up calling PutBlob)
-	// https://github.com/opencontainers/image-spec/blame/7c889fafd04a893f5c5f50b7ab9963d5d64e5242/image-layout.md#L19
-	if err := ensureDirectoryExists(filepath.Join(d.ref.dir, "blobs")); err != nil {
-		return nil, err
-	}
-	return d, nil
+	return &ociImageDestination{ref: ref, index: index}, nil
 }
 
 // Reference returns the reference used to set up this destination.  Note that this should directly correspond to user's intent,
@@ -107,16 +81,16 @@ func (d *ociImageDestination) MustMatchRuntimeOS() bool {
 // to any other readers for download using the supplied digest.
 // If stream.Read() at any time, ESPECIALLY at end of input, returns an error, PutBlob MUST 1) fail, and 2) delete any data stored so far.
 func (d *ociImageDestination) PutBlob(stream io.Reader, inputInfo types.BlobInfo) (types.BlobInfo, error) {
+	if err := ensureDirectoryExists(d.ref.dir); err != nil {
+		return types.BlobInfo{}, err
+	}
 	blobFile, err := ioutil.TempFile(d.ref.dir, "oci-put-blob")
 	if err != nil {
 		return types.BlobInfo{}, err
 	}
 	succeeded := false
-	explicitClosed := false
 	defer func() {
-		if !explicitClosed {
-			blobFile.Close()
-		}
+		blobFile.Close()
 		if !succeeded {
 			os.Remove(blobFile.Name())
 		}
@@ -136,28 +110,17 @@ func (d *ociImageDestination) PutBlob(stream io.Reader, inputInfo types.BlobInfo
 	if err := blobFile.Sync(); err != nil {
 		return types.BlobInfo{}, err
 	}
-
-	// On POSIX systems, blobFile was created with mode 0600, so we need to make it readable.
-	// On Windows, the “permissions of newly created files” argument to syscall.Open is
-	// ignored and the file is already readable; besides, blobFile.Chmod, i.e. syscall.Fchmod,
-	// always fails on Windows.
-	if runtime.GOOS != "windows" {
-		if err := blobFile.Chmod(0644); err != nil {
-			return types.BlobInfo{}, err
-		}
+	if err := blobFile.Chmod(0644); err != nil {
+		return types.BlobInfo{}, err
 	}
 
-	blobPath, err := d.ref.blobPath(computedDigest, d.sharedBlobDir)
+	blobPath, err := d.ref.blobPath(computedDigest)
 	if err != nil {
 		return types.BlobInfo{}, err
 	}
 	if err := ensureParentDirectoryExists(blobPath); err != nil {
 		return types.BlobInfo{}, err
 	}
-
-	// need to explicitly close the file, since a rename won't otherwise not work on Windows
-	blobFile.Close()
-	explicitClosed = true
 	if err := os.Rename(blobFile.Name(), blobPath); err != nil {
 		return types.BlobInfo{}, err
 	}
@@ -173,7 +136,7 @@ func (d *ociImageDestination) HasBlob(info types.BlobInfo) (bool, int64, error)
 	if info.Digest == "" {
 		return false, -1, errors.Errorf(`"Can not check for a blob with unknown digest`)
 	}
-	blobPath, err := d.ref.blobPath(info.Digest, d.sharedBlobDir)
+	blobPath, err := d.ref.blobPath(info.Digest)
 	if err != nil {
 		return false, -1, err
 	}
@@ -206,7 +169,7 @@ func (d *ociImageDestination) PutManifest(m []byte) error {
 	desc.MediaType = imgspecv1.MediaTypeImageManifest
 	desc.Size = int64(len(m))
 
-	blobPath, err := d.ref.blobPath(digest, d.sharedBlobDir)
+	blobPath, err := d.ref.blobPath(digest)
 	if err != nil {
 		return err
 	}
@@ -228,20 +191,23 @@ func (d *ociImageDestination) PutManifest(m []byte) error {
 		Architecture: runtime.GOARCH,
 		OS:           runtime.GOOS,
 	}
-	d.addManifest(&desc)
+	d.index.Manifests = append(d.index.Manifests, desc)
 
 	return nil
 }
 
-func (d *ociImageDestination) addManifest(desc *imgspecv1.Descriptor) {
-	for i, manifest := range d.index.Manifests {
-		if manifest.Annotations["org.opencontainers.image.ref.name"] == desc.Annotations["org.opencontainers.image.ref.name"] {
-			// TODO Should there first be a cleanup based on the descriptor we are going to replace?
-			d.index.Manifests[i] = *desc
-			return
+func ensureDirectoryExists(path string) error {
+	if _, err := os.Stat(path); err != nil && os.IsNotExist(err) {
+		if err := os.MkdirAll(path, 0755); err != nil {
+			return err
 		}
 	}
-	d.index.Manifests = append(d.index.Manifests, *desc)
+	return nil
+}
+
+// ensureParentDirectoryExists ensures the parent of the supplied path exists.
+func ensureParentDirectoryExists(path string) error {
+	return ensureDirectoryExists(filepath.Dir(path))
 }
 
 func (d *ociImageDestination) PutSignatures(signatures [][]byte) error {
@@ -265,30 +231,3 @@ func (d *ociImageDestination) Commit() error {
 	}
 	return ioutil.WriteFile(d.ref.indexPath(), indexJSON, 0644)
 }
-
-func ensureDirectoryExists(path string) error {
-	if _, err := os.Stat(path); err != nil && os.IsNotExist(err) {
-		if err := os.MkdirAll(path, 0755); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// ensureParentDirectoryExists ensures the parent of the supplied path exists.
-func ensureParentDirectoryExists(path string) error {
-	return ensureDirectoryExists(filepath.Dir(path))
-}
-
-// indexExists checks whether the index location specified in the OCI reference exists.
-// The implementation is opinionated, since in case of unexpected errors false is returned
-func indexExists(ref ociReference) bool {
-	_, err := os.Stat(ref.indexPath())
-	if err == nil {
-		return true
-	}
-	if os.IsNotExist(err) {
-		return false
-	}
-	return true
-}

vendor/github.com/containers/image/oci/layout/oci_src.go

@@ -17,10 +17,9 @@ import (
 )
 
 type ociImageSource struct {
-	ref           ociReference
-	descriptor    imgspecv1.Descriptor
-	client        *http.Client
-	sharedBlobDir string
+	ref        ociReference
+	descriptor imgspecv1.Descriptor
+	client     *http.Client
 }
 
 // newImageSource returns an ImageSource for reading from an existing directory.
@@ -41,12 +40,7 @@ func newImageSource(ctx *types.SystemContext, ref ociReference) (types.ImageSour
 	if err != nil {
 		return nil, err
 	}
-	d := &ociImageSource{ref: ref, descriptor: descriptor, client: client}
-	if ctx != nil {
-		// TODO(jonboulle): check dir existence?
-		d.sharedBlobDir = ctx.OCISharedBlobDirPath
-	}
-	return d, nil
+	return &ociImageSource{ref: ref, descriptor: descriptor, client: client}, nil
 }
 
 // Reference returns the reference used to set up this source.
@@ -61,26 +55,8 @@ func (s *ociImageSource) Close() error {
 
 // GetManifest returns the image's manifest along with its MIME type (which may be empty when it can't be determined but the manifest is available).
 // It may use a remote (= slow) service.
-// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve (when the primary manifest is a manifest list);
-// this never happens if the primary manifest is not a manifest list (e.g. if the source never returns manifest lists).
-func (s *ociImageSource) GetManifest(instanceDigest *digest.Digest) ([]byte, string, error) {
-	var dig digest.Digest
-	var mimeType string
-	if instanceDigest == nil {
-		dig = digest.Digest(s.descriptor.Digest)
-		mimeType = s.descriptor.MediaType
-	} else {
-		dig = *instanceDigest
-		// XXX: instanceDigest means that we don't immediately have the context of what
-		//      mediaType the manifest has. In OCI this means that we don't know
-		//      what reference it came from, so we just *assume* that its
-		//      MediaTypeImageManifest.
-		// FIXME: We should actually be able to look up the manifest in the index,
-		// and see the MIME type there.
-		mimeType = imgspecv1.MediaTypeImageManifest
-	}
-
-	manifestPath, err := s.ref.blobPath(dig, s.sharedBlobDir)
+func (s *ociImageSource) GetManifest() ([]byte, string, error) {
+	manifestPath, err := s.ref.blobPath(digest.Digest(s.descriptor.Digest))
 	if err != nil {
 		return nil, "", err
 	}
@@ -89,7 +65,25 @@ func (s *ociImageSource) GetManifest(instanceDigest *digest.Digest) ([]byte, str
 		return nil, "", err
 	}
 
-	return m, mimeType, nil
+	return m, s.descriptor.MediaType, nil
+}
+
+func (s *ociImageSource) GetTargetManifest(digest digest.Digest) ([]byte, string, error) {
+	manifestPath, err := s.ref.blobPath(digest)
+	if err != nil {
+		return nil, "", err
+	}
+
+	m, err := ioutil.ReadFile(manifestPath)
+	if err != nil {
+		return nil, "", err
+	}
+
+	// XXX: GetTargetManifest means that we don't have the context of what
+	//      mediaType the manifest has. In OCI this means that we don't know
+	//      what reference it came from, so we just *assume* that its
+	//      MediaTypeImageManifest.
+	return m, imgspecv1.MediaTypeImageManifest, nil
 }
 
 // GetBlob returns a stream for the specified blob, and the blob's size.
@@ -98,7 +92,7 @@ func (s *ociImageSource) GetBlob(info types.BlobInfo) (io.ReadCloser, int64, err
 		return s.getExternalBlob(info.URLs)
 	}
 
-	path, err := s.ref.blobPath(info.Digest, s.sharedBlobDir)
+	path, err := s.ref.blobPath(info.Digest)
 	if err != nil {
 		return nil, 0, err
 	}
@@ -114,11 +108,7 @@ func (s *ociImageSource) GetBlob(info types.BlobInfo) (io.ReadCloser, int64, err
 	return r, fi.Size(), nil
 }
 
-// GetSignatures returns the image's signatures.  It may use a remote (= slow) service.
-// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve signatures for
-// (when the primary manifest is a manifest list); this never happens if the primary manifest is not a manifest list
-// (e.g. if the source never returns manifest lists).
-func (s *ociImageSource) GetSignatures(ctx context.Context, instanceDigest *digest.Digest) ([][]byte, error) {
+func (s *ociImageSource) GetSignatures(context.Context) ([][]byte, error) {
 	return [][]byte{}, nil
 }
 
@@ -143,11 +133,6 @@ func (s *ociImageSource) getExternalBlob(urls []string) (io.ReadCloser, int64, e
 	return nil, 0, errWrap
 }
 
-// LayerInfosForCopy() returns updated layer info that should be used when reading, in preference to values in the manifest, if specified.
-func (s *ociImageSource) LayerInfosForCopy() []types.BlobInfo {
-	return nil
-}
-
 func getBlobSize(resp *http.Response) int64 {
 	size, err := strconv.ParseInt(resp.Header.Get("Content-Length"), 10, 64)
 	if err != nil {

vendor/github.com/containers/image/oci/layout/oci_transport.go

@@ -5,12 +5,12 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"regexp"
 	"strings"
 
 	"github.com/containers/image/directory/explicitfilepath"
 	"github.com/containers/image/docker/reference"
 	"github.com/containers/image/image"
-	"github.com/containers/image/oci/internal"
 	"github.com/containers/image/transports"
 	"github.com/containers/image/types"
 	"github.com/opencontainers/go-digest"
@@ -36,12 +36,45 @@ func (t ociTransport) ParseReference(reference string) (types.ImageReference, er
 	return ParseReference(reference)
 }
 
+// annotation spex from https://github.com/opencontainers/image-spec/blob/master/annotations.md#pre-defined-annotation-keys
+const (
+	separator = `(?:[-._:@+]|--)`
+	alphanum  = `(?:[A-Za-z0-9]+)`
+	component = `(?:` + alphanum + `(?:` + separator + alphanum + `)*)`
+)
+
+var refRegexp = regexp.MustCompile(`^` + component + `(?:/` + component + `)*$`)
+
 // ValidatePolicyConfigurationScope checks that scope is a valid name for a signature.PolicyTransportScopes keys
 // (i.e. a valid PolicyConfigurationIdentity() or PolicyConfigurationNamespaces() return value).
 // It is acceptable to allow an invalid value which will never be matched, it can "only" cause user confusion.
 // scope passed to this function will not be "", that value is always allowed.
 func (t ociTransport) ValidatePolicyConfigurationScope(scope string) error {
-	return internal.ValidateScope(scope)
+	var dir string
+	sep := strings.SplitN(scope, ":", 2)
+	dir = sep[0]
+
+	if len(sep) == 2 {
+		image := sep[1]
+		if !refRegexp.MatchString(image) {
+			return errors.Errorf("Invalid image %s", image)
+		}
+	}
+
+	if !strings.HasPrefix(dir, "/") {
+		return errors.Errorf("Invalid scope %s: must be an absolute path", scope)
+	}
+	// Refuse also "/", otherwise "/" and "" would have the same semantics,
+	// and "" could be unexpectedly shadowed by the "/" entry.
+	// (Note: we do allow "/:someimage", a bit ridiculous but why refuse it?)
+	if scope == "/" {
+		return errors.New(`Invalid scope "/": Use the generic default scope ""`)
+	}
+	cleaned := filepath.Clean(dir)
+	if cleaned != dir {
+		return errors.Errorf(`Invalid scope %s: Uses non-canonical path format, perhaps try with path %s`, scope, cleaned)
+	}
+	return nil
 }
 
 // ociReference is an ImageReference for OCI directory paths.
@@ -59,7 +92,13 @@ type ociReference struct {
 
 // ParseReference converts a string, which should not start with the ImageTransport.Name prefix, into an OCI ImageReference.
 func ParseReference(reference string) (types.ImageReference, error) {
-	dir, image := internal.SplitPathAndImage(reference)
+	var dir, image string
+	sep := strings.SplitN(reference, ":", 2)
+	dir = sep[0]
+
+	if len(sep) == 2 {
+		image = sep[1]
+	}
 	return NewReference(dir, image)
 }
 
@@ -72,15 +111,14 @@ func NewReference(dir, image string) (types.ImageReference, error) {
 	if err != nil {
 		return nil, err
 	}
-
-	if err := internal.ValidateOCIPath(dir); err != nil {
-		return nil, err
+	// This is necessary to prevent directory paths returned by PolicyConfigurationNamespaces
+	// from being ambiguous with values of PolicyConfigurationIdentity.
+	if strings.Contains(resolved, ":") {
+		return nil, errors.Errorf("Invalid OCI reference %s:%s: path %s contains a colon", dir, image, resolved)
 	}
-
-	if err = internal.ValidateImageName(image); err != nil {
-		return nil, err
+	if len(image) > 0 && !refRegexp.MatchString(image) {
+		return nil, errors.Errorf("Invalid image %s", image)
 	}
-
 	return ociReference{dir: dir, resolvedDir: resolved, image: image}, nil
 }
 
@@ -139,40 +177,28 @@ func (ref ociReference) PolicyConfigurationNamespaces() []string {
 	return res
 }
 
-// NewImage returns a types.ImageCloser for this reference, possibly specialized for this ImageTransport.
-// The caller must call .Close() on the returned ImageCloser.
+// NewImage returns a types.Image for this reference, possibly specialized for this ImageTransport.
+// The caller must call .Close() on the returned Image.
 // NOTE: If any kind of signature verification should happen, build an UnparsedImage from the value returned by NewImageSource,
 // verify that UnparsedImage, and convert it into a real Image via image.FromUnparsedImage.
-// WARNING: This may not do the right thing for a manifest list, see image.FromSource for details.
-func (ref ociReference) NewImage(ctx *types.SystemContext) (types.ImageCloser, error) {
+func (ref ociReference) NewImage(ctx *types.SystemContext) (types.Image, error) {
 	src, err := newImageSource(ctx, ref)
 	if err != nil {
 		return nil, err
 	}
-	return image.FromSource(ctx, src)
-}
-
-// getIndex returns a pointer to the index references by this ociReference. If an error occurs opening an index nil is returned together
-// with an error.
-func (ref ociReference) getIndex() (*imgspecv1.Index, error) {
-	indexJSON, err := os.Open(ref.indexPath())
-	if err != nil {
-		return nil, err
-	}
-	defer indexJSON.Close()
-
-	index := &imgspecv1.Index{}
-	if err := json.NewDecoder(indexJSON).Decode(index); err != nil {
-		return nil, err
-	}
-	return index, nil
+	return image.FromSource(src)
 }
 
 func (ref ociReference) getManifestDescriptor() (imgspecv1.Descriptor, error) {
-	index, err := ref.getIndex()
+	indexJSON, err := os.Open(ref.indexPath())
 	if err != nil {
 		return imgspecv1.Descriptor{}, err
 	}
+	defer indexJSON.Close()
+	index := imgspecv1.Index{}
+	if err := json.NewDecoder(indexJSON).Decode(&index); err != nil {
+		return imgspecv1.Descriptor{}, err
+	}
 
 	var d *imgspecv1.Descriptor
 	if ref.image == "" {
@@ -224,7 +250,7 @@ func (ref ociReference) NewImageSource(ctx *types.SystemContext) (types.ImageSou
 // NewImageDestination returns a types.ImageDestination for this reference.
 // The caller must call .Close() on the returned ImageDestination.
 func (ref ociReference) NewImageDestination(ctx *types.SystemContext) (types.ImageDestination, error) {
-	return newImageDestination(ctx, ref)
+	return newImageDestination(ref)
 }
 
 // DeleteImage deletes the named image from the registry, if supported.
@@ -243,13 +269,9 @@ func (ref ociReference) indexPath() string {
 }
 
 // blobPath returns a path for a blob within a directory using OCI image-layout conventions.
-func (ref ociReference) blobPath(digest digest.Digest, sharedBlobDir string) (string, error) {
+func (ref ociReference) blobPath(digest digest.Digest) (string, error) {
 	if err := digest.Validate(); err != nil {
 		return "", errors.Wrapf(err, "unexpected digest reference %s", digest)
 	}
-	blobDir := filepath.Join(ref.dir, "blobs")
-	if sharedBlobDir != "" {
-		blobDir = sharedBlobDir
-	}
-	return filepath.Join(blobDir, digest.Algorithm().String(), digest.Hex()), nil
+	return filepath.Join(ref.dir, "blobs", digest.Algorithm().String(), digest.Hex()), nil
 }

vendor/github.com/containers/image/openshift/openshift.go

@@ -200,15 +200,20 @@ func (s *openshiftImageSource) Close() error {
 	return nil
 }
 
-// GetManifest returns the image's manifest along with its MIME type (which may be empty when it can't be determined but the manifest is available).
-// It may use a remote (= slow) service.
-// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve (when the primary manifest is a manifest list);
-// this never happens if the primary manifest is not a manifest list (e.g. if the source never returns manifest lists).
-func (s *openshiftImageSource) GetManifest(instanceDigest *digest.Digest) ([]byte, string, error) {
+func (s *openshiftImageSource) GetTargetManifest(digest digest.Digest) ([]byte, string, error) {
 	if err := s.ensureImageIsResolved(context.TODO()); err != nil {
 		return nil, "", err
 	}
-	return s.docker.GetManifest(instanceDigest)
+	return s.docker.GetTargetManifest(digest)
+}
+
+// GetManifest returns the image's manifest along with its MIME type (which may be empty when it can't be determined but the manifest is available).
+// It may use a remote (= slow) service.
+func (s *openshiftImageSource) GetManifest() ([]byte, string, error) {
+	if err := s.ensureImageIsResolved(context.TODO()); err != nil {
+		return nil, "", err
+	}
+	return s.docker.GetManifest()
 }
 
 // GetBlob returns a stream for the specified blob, and the blob’s size (or -1 if unknown).
@@ -219,21 +224,12 @@ func (s *openshiftImageSource) GetBlob(info types.BlobInfo) (io.ReadCloser, int6
 	return s.docker.GetBlob(info)
 }
 
-// GetSignatures returns the image's signatures.  It may use a remote (= slow) service.
-// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve signatures for
-// (when the primary manifest is a manifest list); this never happens if the primary manifest is not a manifest list
-// (e.g. if the source never returns manifest lists).
-func (s *openshiftImageSource) GetSignatures(ctx context.Context, instanceDigest *digest.Digest) ([][]byte, error) {
-	var imageName string
-	if instanceDigest == nil {
-		if err := s.ensureImageIsResolved(ctx); err != nil {
-			return nil, err
-		}
-		imageName = s.imageStreamImageName
-	} else {
-		imageName = instanceDigest.String()
+func (s *openshiftImageSource) GetSignatures(ctx context.Context) ([][]byte, error) {
+	if err := s.ensureImageIsResolved(ctx); err != nil {
+		return nil, err
 	}
-	image, err := s.client.getImage(ctx, imageName)
+
+	image, err := s.client.getImage(ctx, s.imageStreamImageName)
 	if err != nil {
 		return nil, err
 	}
@@ -246,11 +242,6 @@ func (s *openshiftImageSource) GetSignatures(ctx context.Context, instanceDigest
 	return sigs, nil
 }
 
-// LayerInfosForCopy() returns updated layer info that should be used when reading, in preference to values in the manifest, if specified.
-func (s *openshiftImageSource) LayerInfosForCopy() []types.BlobInfo {
-	return nil
-}
-
 // ensureImageIsResolved sets up s.docker and s.imageStreamImageName
 func (s *openshiftImageSource) ensureImageIsResolved(ctx context.Context) error {
 	if s.docker != nil {

vendor/github.com/containers/image/openshift/openshift_transport.go

@@ -125,17 +125,16 @@ func (ref openshiftReference) PolicyConfigurationNamespaces() []string {
 	return policyconfiguration.DockerReferenceNamespaces(ref.dockerReference)
 }
 
-// NewImage returns a types.ImageCloser for this reference, possibly specialized for this ImageTransport.
-// The caller must call .Close() on the returned ImageCloser.
+// NewImage returns a types.Image for this reference, possibly specialized for this ImageTransport.
+// The caller must call .Close() on the returned Image.
 // NOTE: If any kind of signature verification should happen, build an UnparsedImage from the value returned by NewImageSource,
 // verify that UnparsedImage, and convert it into a real Image via image.FromUnparsedImage.
-// WARNING: This may not do the right thing for a manifest list, see image.FromSource for details.
-func (ref openshiftReference) NewImage(ctx *types.SystemContext) (types.ImageCloser, error) {
+func (ref openshiftReference) NewImage(ctx *types.SystemContext) (types.Image, error) {
 	src, err := newImageSource(ctx, ref)
 	if err != nil {
 		return nil, err
 	}
-	return genericImage.FromSource(ctx, src)
+	return genericImage.FromSource(src)
 }
 
 // NewImageSource returns a types.ImageSource for this reference.

vendor/github.com/containers/image/ostree/ostree_dest.go

@@ -4,8 +4,6 @@ package ostree
 
 import (
 	"bytes"
-	"compress/gzip"
-	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -14,26 +12,17 @@ import (
 	"os/exec"
 	"path/filepath"
 	"strconv"
+	"strings"
 	"time"
 
 	"github.com/containers/image/manifest"
 	"github.com/containers/image/types"
 	"github.com/containers/storage/pkg/archive"
 	"github.com/opencontainers/go-digest"
-	"github.com/ostreedev/ostree-go/pkg/otbuiltin"
 	"github.com/pkg/errors"
-	"github.com/vbatts/tar-split/tar/asm"
-	"github.com/vbatts/tar-split/tar/storage"
-)
 
-// #cgo pkg-config: glib-2.0 gobject-2.0 ostree-1
-// #include <glib.h>
-// #include <glib-object.h>
-// #include <gio/gio.h>
-// #include <stdlib.h>
-// #include <ostree.h>
-// #include <gio/ginputstream.h>
-import "C"
+	"github.com/ostreedev/ostree-go/pkg/otbuiltin"
+)
 
 type blobToImport struct {
 	Size     int64
@@ -46,24 +35,18 @@ type descriptor struct {
 	Digest digest.Digest `json:"digest"`
 }
 
-type fsLayersSchema1 struct {
-	BlobSum digest.Digest `json:"blobSum"`
-}
-
 type manifestSchema struct {
-	LayersDescriptors []descriptor      `json:"layers"`
-	FSLayers          []fsLayersSchema1 `json:"fsLayers"`
+	ConfigDescriptor  descriptor   `json:"config"`
+	LayersDescriptors []descriptor `json:"layers"`
 }
 
 type ostreeImageDestination struct {
-	ref           ostreeReference
-	manifest      string
-	schema        manifestSchema
-	tmpDirPath    string
-	blobs         map[string]*blobToImport
-	digest        digest.Digest
-	signaturesLen int
-	repo          *C.struct_OstreeRepo
+	ref        ostreeReference
+	manifest   string
+	schema     manifestSchema
+	tmpDirPath string
+	blobs      map[string]*blobToImport
+	digest     digest.Digest
 }
 
 // newImageDestination returns an ImageDestination for writing to an existing ostree.
@@ -72,7 +55,7 @@ func newImageDestination(ref ostreeReference, tmpDirPath string) (types.ImageDes
 	if err := ensureDirectoryExists(tmpDirPath); err != nil {
 		return nil, err
 	}
-	return &ostreeImageDestination{ref, "", manifestSchema{}, tmpDirPath, map[string]*blobToImport{}, "", 0, nil}, nil
+	return &ostreeImageDestination{ref, "", manifestSchema{}, tmpDirPath, map[string]*blobToImport{}, ""}, nil
 }
 
 // Reference returns the reference used to set up this destination.  Note that this should directly correspond to user's intent,
@@ -83,9 +66,6 @@ func (d *ostreeImageDestination) Reference() types.ImageReference {
 
 // Close removes resources associated with an initialized ImageDestination, if any.
 func (d *ostreeImageDestination) Close() error {
-	if d.repo != nil {
-		C.g_object_unref(C.gpointer(d.repo))
-	}
 	return os.RemoveAll(d.tmpDirPath)
 }
 
@@ -194,35 +174,6 @@ func (d *ostreeImageDestination) ostreeCommit(repo *otbuiltin.Repo, branch strin
 	return err
 }
 
-func generateTarSplitMetadata(output *bytes.Buffer, file string) error {
-	mfz := gzip.NewWriter(output)
-	defer mfz.Close()
-	metaPacker := storage.NewJSONPacker(mfz)
-
-	stream, err := os.OpenFile(file, os.O_RDONLY, 0)
-	if err != nil {
-		return err
-	}
-	defer stream.Close()
-
-	gzReader, err := gzip.NewReader(stream)
-	if err != nil {
-		return err
-	}
-	defer gzReader.Close()
-
-	its, err := asm.NewInputTarStream(gzReader, metaPacker, nil)
-	if err != nil {
-		return err
-	}
-
-	_, err = io.Copy(ioutil.Discard, its)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
 func (d *ostreeImageDestination) importBlob(repo *otbuiltin.Repo, blob *blobToImport) error {
 	ostreeBranch := fmt.Sprintf("ociimage/%s", blob.Digest.Hex())
 	destinationPath := filepath.Join(d.tmpDirPath, blob.Digest.Hex(), "root")
@@ -234,11 +185,6 @@ func (d *ostreeImageDestination) importBlob(repo *otbuiltin.Repo, blob *blobToIm
 		os.RemoveAll(destinationPath)
 	}()
 
-	var tarSplitOutput bytes.Buffer
-	if err := generateTarSplitMetadata(&tarSplitOutput, blob.BlobPath); err != nil {
-		return err
-	}
-
 	if os.Getuid() == 0 {
 		if err := archive.UntarPath(blob.BlobPath, destinationPath); err != nil {
 			return err
@@ -256,35 +202,28 @@ func (d *ostreeImageDestination) importBlob(repo *otbuiltin.Repo, blob *blobToIm
 			return err
 		}
 	}
-	return d.ostreeCommit(repo, ostreeBranch, destinationPath, []string{fmt.Sprintf("docker.size=%d", blob.Size),
-		fmt.Sprintf("tarsplit.output=%s", base64.StdEncoding.EncodeToString(tarSplitOutput.Bytes()))})
-
-}
-
-func (d *ostreeImageDestination) importConfig(repo *otbuiltin.Repo, blob *blobToImport) error {
-	ostreeBranch := fmt.Sprintf("ociimage/%s", blob.Digest.Hex())
-	destinationPath := filepath.Dir(blob.BlobPath)
-
 	return d.ostreeCommit(repo, ostreeBranch, destinationPath, []string{fmt.Sprintf("docker.size=%d", blob.Size)})
 }
 
+func (d *ostreeImageDestination) importConfig(blob *blobToImport) error {
+	ostreeBranch := fmt.Sprintf("ociimage/%s", blob.Digest.Hex())
+
+	return exec.Command("ostree", "commit",
+		"--repo", d.ref.repo,
+		fmt.Sprintf("--add-metadata-string=docker.size=%d", blob.Size),
+		"--branch", ostreeBranch, filepath.Dir(blob.BlobPath)).Run()
+}
+
 func (d *ostreeImageDestination) HasBlob(info types.BlobInfo) (bool, int64, error) {
-
-	if d.repo == nil {
-		repo, err := openRepo(d.ref.repo)
-		if err != nil {
-			return false, 0, err
-		}
-		d.repo = repo
-	}
 	branch := fmt.Sprintf("ociimage/%s", info.Digest.Hex())
-
-	found, data, err := readMetadata(d.repo, branch, "docker.size")
-	if err != nil || !found {
-		return found, -1, err
+	output, err := exec.Command("ostree", "show", "--repo", d.ref.repo, "--print-metadata-key=docker.size", branch).CombinedOutput()
+	if err != nil {
+		if bytes.Index(output, []byte("not found")) >= 0 || bytes.Index(output, []byte("No such")) >= 0 {
+			return false, -1, nil
+		}
+		return false, -1, err
 	}
-
-	size, err := strconv.ParseInt(data, 10, 64)
+	size, err := strconv.ParseInt(strings.Trim(string(output), "'\n"), 10, 64)
 	if err != nil {
 		return false, -1, err
 	}
@@ -333,7 +272,6 @@ func (d *ostreeImageDestination) PutSignatures(signatures [][]byte) error {
 			return err
 		}
 	}
-	d.signaturesLen = len(signatures)
 	return nil
 }
 
@@ -348,37 +286,24 @@ func (d *ostreeImageDestination) Commit() error {
 		return err
 	}
 
-	checkLayer := func(hash string) error {
+	for _, layer := range d.schema.LayersDescriptors {
+		hash := layer.Digest.Hex()
 		blob := d.blobs[hash]
 		// if the blob is not present in d.blobs then it is already stored in OSTree,
 		// and we don't need to import it.
 		if blob == nil {
-			return nil
+			continue
 		}
 		err := d.importBlob(repo, blob)
 		if err != nil {
 			return err
 		}
-
-		delete(d.blobs, hash)
-		return nil
-	}
-	for _, layer := range d.schema.LayersDescriptors {
-		hash := layer.Digest.Hex()
-		if err = checkLayer(hash); err != nil {
-			return err
-		}
-	}
-	for _, layer := range d.schema.FSLayers {
-		hash := layer.BlobSum.Hex()
-		if err = checkLayer(hash); err != nil {
-			return err
-		}
 	}
 
-	// Import the other blobs that are not layers
-	for _, blob := range d.blobs {
-		err := d.importConfig(repo, blob)
+	hash := d.schema.ConfigDescriptor.Digest.Hex()
+	blob := d.blobs[hash]
+	if blob != nil {
+		err := d.importConfig(blob)
 		if err != nil {
 			return err
 		}
@@ -386,9 +311,7 @@ func (d *ostreeImageDestination) Commit() error {
 
 	manifestPath := filepath.Join(d.tmpDirPath, "manifest")
 
-	metadata := []string{fmt.Sprintf("docker.manifest=%s", string(d.manifest)),
-		fmt.Sprintf("signatures=%d", d.signaturesLen),
-		fmt.Sprintf("docker.digest=%s", string(d.digest))}
+	metadata := []string{fmt.Sprintf("docker.manifest=%s", string(d.manifest)), fmt.Sprintf("docker.digest=%s", string(d.digest))}
 	err = d.ostreeCommit(repo, fmt.Sprintf("ociimage/%s", d.ref.branchName), manifestPath, metadata)
 
 	_, err = repo.CommitTransaction()

vendor/github.com/containers/image/ostree/ostree_src.go

@@ -1,354 +0,0 @@
-// +build !containers_image_ostree_stub
-
-package ostree
-
-import (
-	"bytes"
-	"compress/gzip"
-	"context"
-	"encoding/base64"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"strconv"
-	"strings"
-	"unsafe"
-
-	"github.com/containers/image/manifest"
-	"github.com/containers/image/types"
-	"github.com/containers/storage/pkg/ioutils"
-	"github.com/opencontainers/go-digest"
-	glib "github.com/ostreedev/ostree-go/pkg/glibobject"
-	"github.com/pkg/errors"
-	"github.com/vbatts/tar-split/tar/asm"
-	"github.com/vbatts/tar-split/tar/storage"
-)
-
-// #cgo pkg-config: glib-2.0 gobject-2.0 ostree-1
-// #include <glib.h>
-// #include <glib-object.h>
-// #include <gio/gio.h>
-// #include <stdlib.h>
-// #include <ostree.h>
-// #include <gio/ginputstream.h>
-import "C"
-
-type ostreeImageSource struct {
-	ref    ostreeReference
-	tmpDir string
-	repo   *C.struct_OstreeRepo
-}
-
-// newImageSource returns an ImageSource for reading from an existing directory.
-func newImageSource(ctx *types.SystemContext, tmpDir string, ref ostreeReference) (types.ImageSource, error) {
-	return &ostreeImageSource{ref: ref, tmpDir: tmpDir}, nil
-}
-
-// Reference returns the reference used to set up this source.
-func (s *ostreeImageSource) Reference() types.ImageReference {
-	return s.ref
-}
-
-// Close removes resources associated with an initialized ImageSource, if any.
-func (s *ostreeImageSource) Close() error {
-	if s.repo != nil {
-		C.g_object_unref(C.gpointer(s.repo))
-	}
-	return nil
-}
-
-func (s *ostreeImageSource) getLayerSize(blob string) (int64, error) {
-	b := fmt.Sprintf("ociimage/%s", blob)
-	found, data, err := readMetadata(s.repo, b, "docker.size")
-	if err != nil || !found {
-		return 0, err
-	}
-	return strconv.ParseInt(data, 10, 64)
-}
-
-func (s *ostreeImageSource) getLenSignatures() (int64, error) {
-	b := fmt.Sprintf("ociimage/%s", s.ref.branchName)
-	found, data, err := readMetadata(s.repo, b, "signatures")
-	if err != nil {
-		return -1, err
-	}
-	if !found {
-		// if 'signatures' is not present, just return 0 signatures.
-		return 0, nil
-	}
-	return strconv.ParseInt(data, 10, 64)
-}
-
-func (s *ostreeImageSource) getTarSplitData(blob string) ([]byte, error) {
-	b := fmt.Sprintf("ociimage/%s", blob)
-	found, out, err := readMetadata(s.repo, b, "tarsplit.output")
-	if err != nil || !found {
-		return nil, err
-	}
-	return base64.StdEncoding.DecodeString(out)
-}
-
-// GetManifest returns the image's manifest along with its MIME type (which may be empty when it can't be determined but the manifest is available).
-// It may use a remote (= slow) service.
-func (s *ostreeImageSource) GetManifest(instanceDigest *digest.Digest) ([]byte, string, error) {
-	if instanceDigest != nil {
-		return nil, "", errors.Errorf(`Manifest lists are not supported by "ostree:"`)
-	}
-	if s.repo == nil {
-		repo, err := openRepo(s.ref.repo)
-		if err != nil {
-			return nil, "", err
-		}
-		s.repo = repo
-	}
-
-	b := fmt.Sprintf("ociimage/%s", s.ref.branchName)
-	found, out, err := readMetadata(s.repo, b, "docker.manifest")
-	if err != nil {
-		return nil, "", err
-	}
-	if !found {
-		return nil, "", errors.New("manifest not found")
-	}
-	m := []byte(out)
-	return m, manifest.GuessMIMEType(m), nil
-}
-
-func (s *ostreeImageSource) GetTargetManifest(digest digest.Digest) ([]byte, string, error) {
-	return nil, "", errors.New("manifest lists are not supported by this transport")
-}
-
-func openRepo(path string) (*C.struct_OstreeRepo, error) {
-	var cerr *C.GError
-	cpath := C.CString(path)
-	defer C.free(unsafe.Pointer(cpath))
-	pathc := C.g_file_new_for_path(cpath)
-	defer C.g_object_unref(C.gpointer(pathc))
-	repo := C.ostree_repo_new(pathc)
-	r := glib.GoBool(glib.GBoolean(C.ostree_repo_open(repo, nil, &cerr)))
-	if !r {
-		C.g_object_unref(C.gpointer(repo))
-		return nil, glib.ConvertGError(glib.ToGError(unsafe.Pointer(cerr)))
-	}
-	return repo, nil
-}
-
-type ostreePathFileGetter struct {
-	repo       *C.struct_OstreeRepo
-	parentRoot *C.GFile
-}
-
-type ostreeReader struct {
-	stream *C.GFileInputStream
-}
-
-func (o ostreeReader) Close() error {
-	C.g_object_unref(C.gpointer(o.stream))
-	return nil
-}
-func (o ostreeReader) Read(p []byte) (int, error) {
-	var cerr *C.GError
-	instanceCast := C.g_type_check_instance_cast((*C.GTypeInstance)(unsafe.Pointer(o.stream)), C.g_input_stream_get_type())
-	stream := (*C.GInputStream)(unsafe.Pointer(instanceCast))
-
-	b := C.g_input_stream_read_bytes(stream, (C.gsize)(cap(p)), nil, &cerr)
-	if b == nil {
-		return 0, glib.ConvertGError(glib.ToGError(unsafe.Pointer(cerr)))
-	}
-	defer C.g_bytes_unref(b)
-
-	count := int(C.g_bytes_get_size(b))
-	if count == 0 {
-		return 0, io.EOF
-	}
-	data := (*[1 << 30]byte)(unsafe.Pointer(C.g_bytes_get_data(b, nil)))[:count:count]
-	copy(p, data)
-	return count, nil
-}
-
-func readMetadata(repo *C.struct_OstreeRepo, commit, key string) (bool, string, error) {
-	var cerr *C.GError
-	var ref *C.char
-	defer C.free(unsafe.Pointer(ref))
-
-	cCommit := C.CString(commit)
-	defer C.free(unsafe.Pointer(cCommit))
-
-	if !glib.GoBool(glib.GBoolean(C.ostree_repo_resolve_rev(repo, cCommit, C.gboolean(1), &ref, &cerr))) {
-		return false, "", glib.ConvertGError(glib.ToGError(unsafe.Pointer(cerr)))
-	}
-
-	if ref == nil {
-		return false, "", nil
-	}
-
-	var variant *C.GVariant
-	if !glib.GoBool(glib.GBoolean(C.ostree_repo_load_variant(repo, C.OSTREE_OBJECT_TYPE_COMMIT, ref, &variant, &cerr))) {
-		return false, "", glib.ConvertGError(glib.ToGError(unsafe.Pointer(cerr)))
-	}
-	defer C.g_variant_unref(variant)
-	if variant != nil {
-		cKey := C.CString(key)
-		defer C.free(unsafe.Pointer(cKey))
-
-		metadata := C.g_variant_get_child_value(variant, 0)
-		defer C.g_variant_unref(metadata)
-
-		data := C.g_variant_lookup_value(metadata, (*C.gchar)(cKey), nil)
-		if data != nil {
-			defer C.g_variant_unref(data)
-			ptr := (*C.char)(C.g_variant_get_string(data, nil))
-			val := C.GoString(ptr)
-			return true, val, nil
-		}
-	}
-	return false, "", nil
-}
-
-func newOSTreePathFileGetter(repo *C.struct_OstreeRepo, commit string) (*ostreePathFileGetter, error) {
-	var cerr *C.GError
-	var parentRoot *C.GFile
-	cCommit := C.CString(commit)
-	defer C.free(unsafe.Pointer(cCommit))
-	if !glib.GoBool(glib.GBoolean(C.ostree_repo_read_commit(repo, cCommit, &parentRoot, nil, nil, &cerr))) {
-		return &ostreePathFileGetter{}, glib.ConvertGError(glib.ToGError(unsafe.Pointer(cerr)))
-	}
-
-	C.g_object_ref(C.gpointer(repo))
-
-	return &ostreePathFileGetter{repo: repo, parentRoot: parentRoot}, nil
-}
-
-func (o ostreePathFileGetter) Get(filename string) (io.ReadCloser, error) {
-	var file *C.GFile
-	if strings.HasPrefix(filename, "./") {
-		filename = filename[2:]
-	}
-	cfilename := C.CString(filename)
-	defer C.free(unsafe.Pointer(cfilename))
-
-	file = (*C.GFile)(C.g_file_resolve_relative_path(o.parentRoot, cfilename))
-
-	var cerr *C.GError
-	stream := C.g_file_read(file, nil, &cerr)
-	if stream == nil {
-		return nil, glib.ConvertGError(glib.ToGError(unsafe.Pointer(cerr)))
-	}
-
-	return &ostreeReader{stream: stream}, nil
-}
-
-func (o ostreePathFileGetter) Close() {
-	C.g_object_unref(C.gpointer(o.repo))
-	C.g_object_unref(C.gpointer(o.parentRoot))
-}
-
-func (s *ostreeImageSource) readSingleFile(commit, path string) (io.ReadCloser, error) {
-	getter, err := newOSTreePathFileGetter(s.repo, commit)
-	if err != nil {
-		return nil, err
-	}
-	defer getter.Close()
-
-	return getter.Get(path)
-}
-
-// GetBlob returns a stream for the specified blob, and the blob's size.
-func (s *ostreeImageSource) GetBlob(info types.BlobInfo) (io.ReadCloser, int64, error) {
-	blob := info.Digest.Hex()
-	branch := fmt.Sprintf("ociimage/%s", blob)
-
-	if s.repo == nil {
-		repo, err := openRepo(s.ref.repo)
-		if err != nil {
-			return nil, 0, err
-		}
-		s.repo = repo
-	}
-
-	layerSize, err := s.getLayerSize(blob)
-	if err != nil {
-		return nil, 0, err
-	}
-
-	tarsplit, err := s.getTarSplitData(blob)
-	if err != nil {
-		return nil, 0, err
-	}
-
-	// if tarsplit is nil we are looking at the manifest.  Return directly the file in /content
-	if tarsplit == nil {
-		file, err := s.readSingleFile(branch, "/content")
-		if err != nil {
-			return nil, 0, err
-		}
-		return file, layerSize, nil
-	}
-
-	mf := bytes.NewReader(tarsplit)
-	mfz, err := gzip.NewReader(mf)
-	if err != nil {
-		return nil, 0, err
-	}
-	defer mfz.Close()
-	metaUnpacker := storage.NewJSONUnpacker(mfz)
-
-	getter, err := newOSTreePathFileGetter(s.repo, branch)
-	if err != nil {
-		return nil, 0, err
-	}
-
-	ots := asm.NewOutputTarStream(getter, metaUnpacker)
-
-	pipeReader, pipeWriter := io.Pipe()
-	go func() {
-		io.Copy(pipeWriter, ots)
-		pipeWriter.Close()
-	}()
-
-	rc := ioutils.NewReadCloserWrapper(pipeReader, func() error {
-		getter.Close()
-		return ots.Close()
-	})
-	return rc, layerSize, nil
-}
-
-func (s *ostreeImageSource) GetSignatures(ctx context.Context, instanceDigest *digest.Digest) ([][]byte, error) {
-	if instanceDigest != nil {
-		return nil, errors.New("manifest lists are not supported by this transport")
-	}
-	lenSignatures, err := s.getLenSignatures()
-	if err != nil {
-		return nil, err
-	}
-	branch := fmt.Sprintf("ociimage/%s", s.ref.branchName)
-
-	if s.repo == nil {
-		repo, err := openRepo(s.ref.repo)
-		if err != nil {
-			return nil, err
-		}
-		s.repo = repo
-	}
-
-	signatures := [][]byte{}
-	for i := int64(1); i <= lenSignatures; i++ {
-		sigReader, err := s.readSingleFile(branch, fmt.Sprintf("/signature-%d", i))
-		if err != nil {
-			return nil, err
-		}
-		defer sigReader.Close()
-
-		sig, err := ioutil.ReadAll(sigReader)
-		if err != nil {
-			return nil, err
-		}
-		signatures = append(signatures, sig)
-	}
-	return signatures, nil
-}
-
-// LayerInfosForCopy() returns updated layer info that should be used when reading, in preference to values in the manifest, if specified.
-func (s *ostreeImageSource) LayerInfosForCopy() []types.BlobInfo {
-	return nil
-}

vendor/github.com/containers/image/ostree/ostree_transport.go

@@ -10,12 +10,12 @@ import (
 	"regexp"
 	"strings"
 
+	"github.com/pkg/errors"
+
 	"github.com/containers/image/directory/explicitfilepath"
 	"github.com/containers/image/docker/reference"
-	"github.com/containers/image/image"
 	"github.com/containers/image/transports"
 	"github.com/containers/image/types"
-	"github.com/pkg/errors"
 )
 
 const defaultOSTreeRepo = "/ostree/repo"
@@ -66,11 +66,6 @@ type ostreeReference struct {
 	repo       string
 }
 
-type ostreeImageCloser struct {
-	types.ImageCloser
-	size int64
-}
-
 func (t ostreeTransport) ParseReference(ref string) (types.ImageReference, error) {
 	var repo = ""
 	var image = ""
@@ -115,7 +110,7 @@ func NewReference(image string, repo string) (types.ImageReference, error) {
 	// This is necessary to prevent directory paths returned by PolicyConfigurationNamespaces
 	// from being ambiguous with values of PolicyConfigurationIdentity.
 	if strings.Contains(resolved, ":") {
-		return nil, errors.Errorf("Invalid OSTree reference %s@%s: path %s contains a colon", image, repo, resolved)
+		return nil, errors.Errorf("Invalid OSTreeCI reference %s@%s: path %s contains a colon", image, repo, resolved)
 	}
 
 	return ostreeReference{
@@ -173,38 +168,18 @@ func (ref ostreeReference) PolicyConfigurationNamespaces() []string {
 	return res
 }
 
-func (s *ostreeImageCloser) Size() (int64, error) {
-	return s.size, nil
-}
-
-// NewImage returns a types.ImageCloser for this reference, possibly specialized for this ImageTransport.
-// The caller must call .Close() on the returned ImageCloser.
+// NewImage returns a types.Image for this reference, possibly specialized for this ImageTransport.
+// The caller must call .Close() on the returned Image.
 // NOTE: If any kind of signature verification should happen, build an UnparsedImage from the value returned by NewImageSource,
 // verify that UnparsedImage, and convert it into a real Image via image.FromUnparsedImage.
-func (ref ostreeReference) NewImage(ctx *types.SystemContext) (types.ImageCloser, error) {
-	var tmpDir string
-	if ctx == nil || ctx.OSTreeTmpDirPath == "" {
-		tmpDir = os.TempDir()
-	} else {
-		tmpDir = ctx.OSTreeTmpDirPath
-	}
-	src, err := newImageSource(ctx, tmpDir, ref)
-	if err != nil {
-		return nil, err
-	}
-	return image.FromSource(ctx, src)
+func (ref ostreeReference) NewImage(ctx *types.SystemContext) (types.Image, error) {
+	return nil, errors.New("Reading ostree: images is currently not supported")
 }
 
 // NewImageSource returns a types.ImageSource for this reference.
 // The caller must call .Close() on the returned ImageSource.
 func (ref ostreeReference) NewImageSource(ctx *types.SystemContext) (types.ImageSource, error) {
-	var tmpDir string
-	if ctx == nil || ctx.OSTreeTmpDirPath == "" {
-		tmpDir = os.TempDir()
-	} else {
-		tmpDir = ctx.OSTreeTmpDirPath
-	}
-	return newImageSource(ctx, tmpDir, ref)
+	return nil, errors.New("Reading ostree: images is currently not supported")
 }
 
 // NewImageDestination returns a types.ImageDestination for this reference.

vendor/github.com/containers/image/signature/policy_config.go

@@ -70,11 +70,7 @@ func NewPolicyFromFile(fileName string) (*Policy, error) {
 	if err != nil {
 		return nil, err
 	}
-	policy, err := NewPolicyFromBytes(contents)
-	if err != nil {
-		return nil, errors.Wrapf(err, "invalid policy in %q", fileName)
-	}
-	return policy, nil
+	return NewPolicyFromBytes(contents)
 }
 
 // NewPolicyFromBytes returns a policy parsed from the specified blob.

vendor/github.com/containers/image/storage/storage_reference.go

@@ -1,5 +1,3 @@
-// +build !containers_image_storage_stub
-
 package storage
 
 import (
@@ -8,7 +6,6 @@ import (
 	"github.com/containers/image/docker/reference"
 	"github.com/containers/image/types"
 	"github.com/containers/storage"
-	digest "github.com/opencontainers/go-digest"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
@@ -21,11 +18,9 @@ type storageReference struct {
 	reference string
 	id        string
 	name      reference.Named
-	tag       string
-	digest    digest.Digest
 }
 
-func newReference(transport storageTransport, reference, id string, name reference.Named, tag string, digest digest.Digest) *storageReference {
+func newReference(transport storageTransport, reference, id string, name reference.Named) *storageReference {
 	// We take a copy of the transport, which contains a pointer to the
 	// store that it used for resolving this reference, so that the
 	// transport that we'll return from Transport() won't be affected by
@@ -35,8 +30,6 @@ func newReference(transport storageTransport, reference, id string, name referen
 		reference: reference,
 		id:        id,
 		name:      name,
-		tag:       tag,
-		digest:    digest,
 	}
 }
 
@@ -44,32 +37,11 @@ func newReference(transport storageTransport, reference, id string, name referen
 // one present with the same name or ID, and return the image.
 func (s *storageReference) resolveImage() (*storage.Image, error) {
 	if s.id == "" {
-		// Look for an image that has the expanded reference name as an explicit Name value.
 		image, err := s.transport.store.Image(s.reference)
 		if image != nil && err == nil {
 			s.id = image.ID
 		}
 	}
-	if s.id == "" && s.name != nil && s.digest != "" {
-		// Look for an image with the specified digest that has the same name,
-		// though possibly with a different tag or digest, as a Name value, so
-		// that the canonical reference can be implicitly resolved to the image.
-		images, err := s.transport.store.ImagesByDigest(s.digest)
-		if images != nil && err == nil {
-			repo := reference.FamiliarName(reference.TrimNamed(s.name))
-		search:
-			for _, image := range images {
-				for _, name := range image.Names {
-					if named, err := reference.ParseNormalizedNamed(name); err == nil {
-						if reference.FamiliarName(reference.TrimNamed(named)) == repo {
-							s.id = image.ID
-							break search
-						}
-					}
-				}
-			}
-		}
-	}
 	if s.id == "" {
 		logrus.Errorf("reference %q does not resolve to an image ID", s.StringWithinTransport())
 		return nil, ErrNoSuchImage
@@ -78,15 +50,12 @@ func (s *storageReference) resolveImage() (*storage.Image, error) {
 	if err != nil {
 		return nil, errors.Wrapf(err, "error reading image %q", s.id)
 	}
-	if s.name != nil {
-		repo := reference.FamiliarName(reference.TrimNamed(s.name))
+	if s.reference != "" {
 		nameMatch := false
 		for _, name := range img.Names {
-			if named, err := reference.ParseNormalizedNamed(name); err == nil {
-				if reference.FamiliarName(reference.TrimNamed(named)) == repo {
-					nameMatch = true
-					break
-				}
+			if name == s.reference {
+				nameMatch = true
+				break
 			}
 		}
 		if !nameMatch {
@@ -107,21 +76,8 @@ func (s storageReference) Transport() types.ImageTransport {
 	}
 }
 
-// Return a name with a tag or digest, if we have either, else return it bare.
+// Return a name with a tag, if we have a name to base them on.
 func (s storageReference) DockerReference() reference.Named {
-	if s.name == nil {
-		return nil
-	}
-	if s.tag != "" {
-		if namedTagged, err := reference.WithTag(s.name, s.tag); err == nil {
-			return namedTagged
-		}
-	}
-	if s.digest != "" {
-		if canonical, err := reference.WithDigest(s.name, s.digest); err == nil {
-			return canonical
-		}
-	}
 	return s.name
 }
 
@@ -135,7 +91,7 @@ func (s storageReference) StringWithinTransport() string {
 		optionsList = ":" + strings.Join(options, ",")
 	}
 	storeSpec := "[" + s.transport.store.GraphDriverName() + "@" + s.transport.store.GraphRoot() + "+" + s.transport.store.RunRoot() + optionsList + "]"
-	if s.reference == "" {
+	if s.name == nil {
 		return storeSpec + "@" + s.id
 	}
 	if s.id == "" {
@@ -164,8 +120,11 @@ func (s storageReference) PolicyConfigurationNamespaces() []string {
 	driverlessStoreSpec := "[" + s.transport.store.GraphRoot() + "]"
 	namespaces := []string{}
 	if s.name != nil {
-		name := reference.TrimNamed(s.name)
-		components := strings.Split(name.String(), "/")
+		if s.id != "" {
+			// The reference without the ID is also a valid namespace.
+			namespaces = append(namespaces, storeSpec+s.reference)
+		}
+		components := strings.Split(s.name.Name(), "/")
 		for len(components) > 0 {
 			namespaces = append(namespaces, storeSpec+strings.Join(components, "/"))
 			components = components[:len(components)-1]
@@ -176,13 +135,8 @@ func (s storageReference) PolicyConfigurationNamespaces() []string {
 	return namespaces
 }
 
-// NewImage returns a types.ImageCloser for this reference, possibly specialized for this ImageTransport.
-// The caller must call .Close() on the returned ImageCloser.
-// NOTE: If any kind of signature verification should happen, build an UnparsedImage from the value returned by NewImageSource,
-// verify that UnparsedImage, and convert it into a real Image via image.FromUnparsedImage.
-// WARNING: This may not do the right thing for a manifest list, see image.FromSource for details.
-func (s storageReference) NewImage(ctx *types.SystemContext) (types.ImageCloser, error) {
-	return newImage(ctx, s)
+func (s storageReference) NewImage(ctx *types.SystemContext) (types.Image, error) {
+	return newImage(s)
 }
 
 func (s storageReference) DeleteImage(ctx *types.SystemContext) error {
@@ -205,5 +159,5 @@ func (s storageReference) NewImageSource(ctx *types.SystemContext) (types.ImageS
 }
 
 func (s storageReference) NewImageDestination(ctx *types.SystemContext) (types.ImageDestination, error) {
-	return newImageDestination(ctx, s)
+	return newImageDestination(s)
 }

vendor/github.com/containers/image/storage/storage_transport.go

@@ -1,5 +1,3 @@
-// +build !containers_image_storage_stub
-
 package storage
 
 import (
@@ -13,14 +11,11 @@ import (
 	"github.com/containers/image/types"
 	"github.com/containers/storage"
 	"github.com/containers/storage/pkg/idtools"
-	digest "github.com/opencontainers/go-digest"
+	"github.com/opencontainers/go-digest"
+	ddigest "github.com/opencontainers/go-digest"
 	"github.com/sirupsen/logrus"
 )
 
-const (
-	minimumTruncatedIDLength = 3
-)
-
 func init() {
 	transports.Register(Transport)
 }
@@ -106,133 +101,69 @@ func (s *storageTransport) DefaultGIDMap() []idtools.IDMap {
 // relative to the given store, and returns it in a reference object.
 func (s storageTransport) ParseStoreReference(store storage.Store, ref string) (*storageReference, error) {
 	var name reference.Named
+	var sum digest.Digest
+	var err error
 	if ref == "" {
-		return nil, errors.Wrapf(ErrInvalidReference, "%q is an empty reference")
+		return nil, ErrInvalidReference
 	}
 	if ref[0] == '[' {
 		// Ignore the store specifier.
 		closeIndex := strings.IndexRune(ref, ']')
 		if closeIndex < 1 {
-			return nil, errors.Wrapf(ErrInvalidReference, "store specifier in %q did not end", ref)
+			return nil, ErrInvalidReference
 		}
 		ref = ref[closeIndex+1:]
 	}
-
-	// The last segment, if there's more than one, is either a digest from a reference, or an image ID.
-	split := strings.LastIndex(ref, "@")
-	idOrDigest := ""
-	if split != -1 {
-		// Peel off that last bit so that we can work on the rest.
-		idOrDigest = ref[split+1:]
-		if idOrDigest == "" {
-			return nil, errors.Wrapf(ErrInvalidReference, "%q does not look like a digest or image ID", idOrDigest)
+	refInfo := strings.SplitN(ref, "@", 2)
+	if len(refInfo) == 1 {
+		// A name.
+		name, err = reference.ParseNormalizedNamed(refInfo[0])
+		if err != nil {
+			return nil, err
 		}
-		ref = ref[:split]
+	} else if len(refInfo) == 2 {
+		// An ID, possibly preceded by a name.
+		if refInfo[0] != "" {
+			name, err = reference.ParseNormalizedNamed(refInfo[0])
+			if err != nil {
+				return nil, err
+			}
+		}
+		sum, err = digest.Parse(refInfo[1])
+		if err != nil || sum.Validate() != nil {
+			sum, err = digest.Parse("sha256:" + refInfo[1])
+			if err != nil || sum.Validate() != nil {
+				return nil, err
+			}
+		}
+	} else { // Coverage: len(refInfo) is always 1 or 2
+		// Anything else: store specified in a form we don't
+		// recognize.
+		return nil, ErrInvalidReference
 	}
-
-	// The middle segment (now the last segment), if there is one, is a digest.
-	split = strings.LastIndex(ref, "@")
-	sum := digest.Digest("")
-	if split != -1 {
-		sum = digest.Digest(ref[split+1:])
-		if sum == "" {
-			return nil, errors.Wrapf(ErrInvalidReference, "%q does not look like an image digest", sum)
-		}
-		ref = ref[:split]
-	}
-
-	// If we have something that unambiguously should be a digest, validate it, and then the third part,
-	// if we have one, as an ID.
-	id := ""
-	if sum != "" {
-		if idSum, err := digest.Parse("sha256:" + idOrDigest); err != nil || idSum.Validate() != nil {
-			return nil, errors.Wrapf(ErrInvalidReference, "%q does not look like an image ID", idOrDigest)
-		}
-		if err := sum.Validate(); err != nil {
-			return nil, errors.Wrapf(ErrInvalidReference, "%q does not look like an image digest", sum)
-		}
-		id = idOrDigest
-		if img, err := store.Image(idOrDigest); err == nil && img != nil && len(idOrDigest) >= minimumTruncatedIDLength && strings.HasPrefix(img.ID, idOrDigest) {
-			// The ID is a truncated version of the ID of an image that's present in local storage,
-			// so we might as well use the expanded value.
-			id = img.ID
-		}
-	} else if idOrDigest != "" {
-		// There was no middle portion, so the final portion could be either a digest or an ID.
-		if idSum, err := digest.Parse("sha256:" + idOrDigest); err == nil && idSum.Validate() == nil {
-			// It's an ID.
-			id = idOrDigest
-		} else if idSum, err := digest.Parse(idOrDigest); err == nil && idSum.Validate() == nil {
-			// It's a digest.
-			sum = idSum
-		} else if img, err := store.Image(idOrDigest); err == nil && img != nil && len(idOrDigest) >= minimumTruncatedIDLength && strings.HasPrefix(img.ID, idOrDigest) {
-			// It's a truncated version of the ID of an image that's present in local storage,
-			// and we may need the expanded value.
-			id = img.ID
-		} else {
-			return nil, errors.Wrapf(ErrInvalidReference, "%q does not look like a digest or image ID", idOrDigest)
-		}
-	}
-
-	// If we only had one portion, then _maybe_ it's a truncated image ID.  Only check on that if it's
-	// at least of what we guess is a reasonable minimum length, because we don't want a really short value
-	// like "a" matching an image by ID prefix when the input was actually meant to specify an image name.
-	if len(ref) >= minimumTruncatedIDLength && sum == "" && id == "" {
-		if img, err := store.Image(ref); err == nil && img != nil && strings.HasPrefix(img.ID, ref) {
-			// It's a truncated version of the ID of an image that's present in local storage;
-			// we need to expand it.
-			id = img.ID
-			ref = ""
-		}
-	}
-
-	// The initial portion is probably a name, possibly with a tag.
-	if ref != "" {
-		var err error
-		if name, err = reference.ParseNormalizedNamed(ref); err != nil {
-			return nil, errors.Wrapf(err, "error parsing named reference %q", ref)
-		}
-	}
-	if name == nil && sum == "" && id == "" {
-		return nil, errors.Errorf("error parsing reference")
-	}
-
-	// Construct a copy of the store spec.
 	optionsList := ""
 	options := store.GraphOptions()
 	if len(options) > 0 {
 		optionsList = ":" + strings.Join(options, ",")
 	}
 	storeSpec := "[" + store.GraphDriverName() + "@" + store.GraphRoot() + "+" + store.RunRoot() + optionsList + "]"
-
-	// Convert the name back into a reference string, if we got a name.
+	id := ""
+	if sum.Validate() == nil {
+		id = sum.Hex()
+	}
 	refname := ""
-	tag := ""
 	if name != nil {
-		if sum.Validate() == nil {
-			canonical, err := reference.WithDigest(name, sum)
-			if err != nil {
-				return nil, errors.Wrapf(err, "error mixing name %q with digest %q", name, sum)
-			}
-			refname = verboseName(canonical)
-		} else {
-			name = reference.TagNameOnly(name)
-			tagged, ok := name.(reference.Tagged)
-			if !ok {
-				return nil, errors.Errorf("error parsing possibly-tagless name %q", ref)
-			}
-			refname = verboseName(name)
-			tag = tagged.Tag()
-		}
+		name = reference.TagNameOnly(name)
+		refname = verboseName(name)
 	}
 	if refname == "" {
-		logrus.Debugf("parsed reference to id into %q", storeSpec+"@"+id)
+		logrus.Debugf("parsed reference into %q", storeSpec+"@"+id)
 	} else if id == "" {
-		logrus.Debugf("parsed reference to refname into %q", storeSpec+refname)
+		logrus.Debugf("parsed reference into %q", storeSpec+refname)
 	} else {
-		logrus.Debugf("parsed reference to refname@id into %q", storeSpec+refname+"@"+id)
+		logrus.Debugf("parsed reference into %q", storeSpec+refname+"@"+id)
 	}
-	return newReference(storageTransport{store: store, defaultUIDMap: s.defaultUIDMap, defaultGIDMap: s.defaultGIDMap}, refname, id, name, tag, sum), nil
+	return newReference(storageTransport{store: store, defaultUIDMap: s.defaultUIDMap, defaultGIDMap: s.defaultGIDMap}, refname, id, name), nil
 }
 
 func (s *storageTransport) GetStore() (storage.Store, error) {
@@ -251,14 +182,11 @@ func (s *storageTransport) GetStore() (storage.Store, error) {
 	return s.store, nil
 }
 
-// ParseReference takes a name and a tag or digest and/or ID
-// ("_name_"/"@_id_"/"_name_:_tag_"/"_name_:_tag_@_id_"/"_name_@_digest_"/"_name_@_digest_@_id_"),
+// ParseReference takes a name and/or an ID ("_name_"/"@_id_"/"_name_@_id_"),
 // possibly prefixed with a store specifier in the form "[_graphroot_]" or
 // "[_driver_@_graphroot_]" or "[_driver_@_graphroot_+_runroot_]" or
 // "[_driver_@_graphroot_:_options_]" or "[_driver_@_graphroot_+_runroot_:_options_]",
 // tries to figure out which it is, and returns it in a reference object.
-// If _id_ is the ID of an image that's present in local storage, it can be truncated, and
-// even be specified as if it were a _name_, value.
 func (s *storageTransport) ParseReference(reference string) (types.ImageReference, error) {
 	var store storage.Store
 	// Check if there's a store location prefix.  If there is, then it
@@ -337,23 +265,17 @@ func (s *storageTransport) ParseReference(reference string) (types.ImageReferenc
 
 func (s storageTransport) GetStoreImage(store storage.Store, ref types.ImageReference) (*storage.Image, error) {
 	dref := ref.DockerReference()
-	if dref != nil {
-		if img, err := store.Image(verboseName(dref)); err == nil {
-			return img, nil
-		}
-	}
-	if sref, ok := ref.(*storageReference); ok {
-		if sref.id != "" {
-			if img, err := store.Image(sref.id); err == nil {
-				return img, nil
+	if dref == nil {
+		if sref, ok := ref.(*storageReference); ok {
+			if sref.id != "" {
+				if img, err := store.Image(sref.id); err == nil {
+					return img, nil
+				}
 			}
 		}
-		tmpRef := *sref
-		if img, err := tmpRef.resolveImage(); err == nil {
-			return img, nil
-		}
+		return nil, ErrInvalidReference
 	}
-	return nil, storage.ErrImageUnknown
+	return store.Image(verboseName(dref))
 }
 
 func (s *storageTransport) GetImage(ref types.ImageReference) (*storage.Image, error) {
@@ -413,7 +335,7 @@ func (s storageTransport) ValidatePolicyConfigurationScope(scope string) error {
 		if err != nil {
 			return err
 		}
-		_, err = digest.Parse("sha256:" + scopeInfo[1])
+		_, err = ddigest.Parse("sha256:" + scopeInfo[1])
 		if err != nil {
 			return err
 		}
@@ -423,28 +345,11 @@ func (s storageTransport) ValidatePolicyConfigurationScope(scope string) error {
 	return nil
 }
 
-func verboseName(r reference.Reference) string {
-	if r == nil {
-		return ""
-	}
-	named, isNamed := r.(reference.Named)
-	digested, isDigested := r.(reference.Digested)
-	tagged, isTagged := r.(reference.Tagged)
-	name := ""
+func verboseName(name reference.Named) string {
+	name = reference.TagNameOnly(name)
 	tag := ""
-	sum := ""
-	if isNamed {
-		name = (reference.TrimNamed(named)).String()
+	if tagged, ok := name.(reference.NamedTagged); ok {
+		tag = ":" + tagged.Tag()
 	}
-	if isTagged {
-		if tagged.Tag() != "" {
-			tag = ":" + tagged.Tag()
-		}
-	}
-	if isDigested {
-		if digested.Digest().Validate() == nil {
-			sum = "@" + digested.Digest().String()
-		}
-	}
-	return name + tag + sum
+	return name.Name() + tag
 }

vendor/github.com/containers/image/tarball/doc.go

@@ -1,48 +0,0 @@
-// Package tarball provides a way to generate images using one or more layer
-// tarballs and an optional template configuration.
-//
-// An example:
-//	package main
-//
-//	import (
-//		"fmt"
-//
-//		cp "github.com/containers/image/copy"
-//		"github.com/containers/image/tarball"
-//		"github.com/containers/image/transports/alltransports"
-//
-//		imgspecv1 "github.com/containers/image/transports/alltransports"
-//	)
-//
-//	func imageFromTarball() {
-//		src, err := alltransports.ParseImageName("tarball:/var/cache/mock/fedora-26-x86_64/root_cache/cache.tar.gz")
-//		// - or -
-//		// src, err := tarball.Transport.ParseReference("/var/cache/mock/fedora-26-x86_64/root_cache/cache.tar.gz")
-//		if err != nil {
-//			panic(err)
-//		}
-//		updater, ok := src.(tarball.ConfigUpdater)
-//		if !ok {
-//			panic("unexpected: a tarball reference should implement tarball.ConfigUpdater")
-//		}
-//		config := imgspecv1.Image{
-//			Config: imgspecv1.ImageConfig{
-//				Cmd: []string{"/bin/bash"},
-//			},
-//		}
-//		annotations := make(map[string]string)
-//		annotations[imgspecv1.AnnotationDescription] = "test image built from a mock root cache"
-//		err = updater.ConfigUpdate(config, annotations)
-//		if err != nil {
-//			panic(err)
-//		}
-//		dest, err := alltransports.ParseImageName("docker-daemon:mock:latest")
-//		if err != nil {
-//			panic(err)
-//		}
-//		err = cp.Image(nil, dest, src, nil)
-//		if err != nil {
-//			panic(err)
-//		}
-//	}
-package tarball

vendor/github.com/containers/image/tarball/tarball_reference.go

@@ -1,93 +0,0 @@
-package tarball
-
-import (
-	"fmt"
-	"os"
-	"strings"
-
-	"github.com/containers/image/docker/reference"
-	"github.com/containers/image/image"
-	"github.com/containers/image/types"
-
-	imgspecv1 "github.com/opencontainers/image-spec/specs-go/v1"
-)
-
-// ConfigUpdater is an interface that ImageReferences for "tarball" images also
-// implement.  It can be used to set values for a configuration, and to set
-// image annotations which will be present in the images returned by the
-// reference's NewImage() or NewImageSource() methods.
-type ConfigUpdater interface {
-	ConfigUpdate(config imgspecv1.Image, annotations map[string]string) error
-}
-
-type tarballReference struct {
-	transport   types.ImageTransport
-	config      imgspecv1.Image
-	annotations map[string]string
-	filenames   []string
-	stdin       []byte
-}
-
-// ConfigUpdate updates the image's default configuration and adds annotations
-// which will be visible in source images created using this reference.
-func (r *tarballReference) ConfigUpdate(config imgspecv1.Image, annotations map[string]string) error {
-	r.config = config
-	if r.annotations == nil {
-		r.annotations = make(map[string]string)
-	}
-	for k, v := range annotations {
-		r.annotations[k] = v
-	}
-	return nil
-}
-
-func (r *tarballReference) Transport() types.ImageTransport {
-	return r.transport
-}
-
-func (r *tarballReference) StringWithinTransport() string {
-	return strings.Join(r.filenames, ":")
-}
-
-func (r *tarballReference) DockerReference() reference.Named {
-	return nil
-}
-
-func (r *tarballReference) PolicyConfigurationIdentity() string {
-	return ""
-}
-
-func (r *tarballReference) PolicyConfigurationNamespaces() []string {
-	return nil
-}
-
-// NewImage returns a types.ImageCloser for this reference, possibly specialized for this ImageTransport.
-// The caller must call .Close() on the returned ImageCloser.
-// NOTE: If any kind of signature verification should happen, build an UnparsedImage from the value returned by NewImageSource,
-// verify that UnparsedImage, and convert it into a real Image via image.FromUnparsedImage.
-// WARNING: This may not do the right thing for a manifest list, see image.FromSource for details.
-func (r *tarballReference) NewImage(ctx *types.SystemContext) (types.ImageCloser, error) {
-	src, err := r.NewImageSource(ctx)
-	if err != nil {
-		return nil, err
-	}
-	img, err := image.FromSource(ctx, src)
-	if err != nil {
-		src.Close()
-		return nil, err
-	}
-	return img, nil
-}
-
-func (r *tarballReference) DeleteImage(ctx *types.SystemContext) error {
-	for _, filename := range r.filenames {
-		if err := os.Remove(filename); err != nil && !os.IsNotExist(err) {
-			return fmt.Errorf("error removing %q: %v", filename, err)
-		}
-	}
-	return nil
-}
-
-func (r *tarballReference) NewImageDestination(ctx *types.SystemContext) (types.ImageDestination, error) {
-	return nil, fmt.Errorf("destination not implemented yet")
-}

vendor/github.com/containers/image/tarball/tarball_src.go

@@ -1,260 +0,0 @@
-package tarball
-
-import (
-	"bytes"
-	"compress/gzip"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/containers/image/types"
-
-	digest "github.com/opencontainers/go-digest"
-	imgspecs "github.com/opencontainers/image-spec/specs-go"
-	imgspecv1 "github.com/opencontainers/image-spec/specs-go/v1"
-)
-
-type tarballImageSource struct {
-	reference  tarballReference
-	filenames  []string
-	diffIDs    []digest.Digest
-	diffSizes  []int64
-	blobIDs    []digest.Digest
-	blobSizes  []int64
-	blobTypes  []string
-	config     []byte
-	configID   digest.Digest
-	configSize int64
-	manifest   []byte
-}
-
-func (r *tarballReference) NewImageSource(ctx *types.SystemContext) (types.ImageSource, error) {
-	// Gather up the digests, sizes, and date information for all of the files.
-	filenames := []string{}
-	diffIDs := []digest.Digest{}
-	diffSizes := []int64{}
-	blobIDs := []digest.Digest{}
-	blobSizes := []int64{}
-	blobTimes := []time.Time{}
-	blobTypes := []string{}
-	for _, filename := range r.filenames {
-		var file *os.File
-		var err error
-		var blobSize int64
-		var blobTime time.Time
-		var reader io.Reader
-		if filename == "-" {
-			blobSize = int64(len(r.stdin))
-			blobTime = time.Now()
-			reader = bytes.NewReader(r.stdin)
-		} else {
-			file, err = os.Open(filename)
-			if err != nil {
-				return nil, fmt.Errorf("error opening %q for reading: %v", filename, err)
-			}
-			defer file.Close()
-			reader = file
-			fileinfo, err := file.Stat()
-			if err != nil {
-				return nil, fmt.Errorf("error reading size of %q: %v", filename, err)
-			}
-			blobSize = fileinfo.Size()
-			blobTime = fileinfo.ModTime()
-		}
-
-		// Default to assuming the layer is compressed.
-		layerType := imgspecv1.MediaTypeImageLayerGzip
-
-		// Set up to digest the file as it is.
-		blobIDdigester := digest.Canonical.Digester()
-		reader = io.TeeReader(reader, blobIDdigester.Hash())
-
-		// Set up to digest the file after we maybe decompress it.
-		diffIDdigester := digest.Canonical.Digester()
-		uncompressed, err := gzip.NewReader(reader)
-		if err == nil {
-			// It is compressed, so the diffID is the digest of the uncompressed version
-			reader = io.TeeReader(uncompressed, diffIDdigester.Hash())
-		} else {
-			// It is not compressed, so the diffID and the blobID are going to be the same
-			diffIDdigester = blobIDdigester
-			layerType = imgspecv1.MediaTypeImageLayer
-			uncompressed = nil
-		}
-		n, err := io.Copy(ioutil.Discard, reader)
-		if err != nil {
-			return nil, fmt.Errorf("error reading %q: %v", filename, err)
-		}
-		if uncompressed != nil {
-			uncompressed.Close()
-		}
-
-		// Grab our uncompressed and possibly-compressed digests and sizes.
-		filenames = append(filenames, filename)
-		diffIDs = append(diffIDs, diffIDdigester.Digest())
-		diffSizes = append(diffSizes, n)
-		blobIDs = append(blobIDs, blobIDdigester.Digest())
-		blobSizes = append(blobSizes, blobSize)
-		blobTimes = append(blobTimes, blobTime)
-		blobTypes = append(blobTypes, layerType)
-	}
-
-	// Build the rootfs and history for the configuration blob.
-	rootfs := imgspecv1.RootFS{
-		Type:    "layers",
-		DiffIDs: diffIDs,
-	}
-	created := time.Time{}
-	history := []imgspecv1.History{}
-	// Pick up the layer comment from the configuration's history list, if one is set.
-	comment := "imported from tarball"
-	if len(r.config.History) > 0 && r.config.History[0].Comment != "" {
-		comment = r.config.History[0].Comment
-	}
-	for i := range diffIDs {
-		createdBy := fmt.Sprintf("/bin/sh -c #(nop) ADD file:%s in %c", diffIDs[i].Hex(), os.PathSeparator)
-		history = append(history, imgspecv1.History{
-			Created:   &blobTimes[i],
-			CreatedBy: createdBy,
-			Comment:   comment,
-		})
-		// Use the mtime of the most recently modified file as the image's creation time.
-		if created.Before(blobTimes[i]) {
-			created = blobTimes[i]
-		}
-	}
-
-	// Pick up other defaults from the config in the reference.
-	config := r.config
-	if config.Created == nil {
-		config.Created = &created
-	}
-	if config.Architecture == "" {
-		config.Architecture = runtime.GOARCH
-	}
-	if config.OS == "" {
-		config.OS = runtime.GOOS
-	}
-	config.RootFS = rootfs
-	config.History = history
-
-	// Encode and digest the image configuration blob.
-	configBytes, err := json.Marshal(&config)
-	if err != nil {
-		return nil, fmt.Errorf("error generating configuration blob for %q: %v", strings.Join(r.filenames, separator), err)
-	}
-	configID := digest.Canonical.FromBytes(configBytes)
-	configSize := int64(len(configBytes))
-
-	// Populate a manifest with the configuration blob and the file as the single layer.
-	layerDescriptors := []imgspecv1.Descriptor{}
-	for i := range blobIDs {
-		layerDescriptors = append(layerDescriptors, imgspecv1.Descriptor{
-			Digest:    blobIDs[i],
-			Size:      blobSizes[i],
-			MediaType: blobTypes[i],
-		})
-	}
-	annotations := make(map[string]string)
-	for k, v := range r.annotations {
-		annotations[k] = v
-	}
-	manifest := imgspecv1.Manifest{
-		Versioned: imgspecs.Versioned{
-			SchemaVersion: 2,
-		},
-		Config: imgspecv1.Descriptor{
-			Digest:    configID,
-			Size:      configSize,
-			MediaType: imgspecv1.MediaTypeImageConfig,
-		},
-		Layers:      layerDescriptors,
-		Annotations: annotations,
-	}
-
-	// Encode the manifest.
-	manifestBytes, err := json.Marshal(&manifest)
-	if err != nil {
-		return nil, fmt.Errorf("error generating manifest for %q: %v", strings.Join(r.filenames, separator), err)
-	}
-
-	// Return the image.
-	src := &tarballImageSource{
-		reference:  *r,
-		filenames:  filenames,
-		diffIDs:    diffIDs,
-		diffSizes:  diffSizes,
-		blobIDs:    blobIDs,
-		blobSizes:  blobSizes,
-		blobTypes:  blobTypes,
-		config:     configBytes,
-		configID:   configID,
-		configSize: configSize,
-		manifest:   manifestBytes,
-	}
-
-	return src, nil
-}
-
-func (is *tarballImageSource) Close() error {
-	return nil
-}
-
-func (is *tarballImageSource) GetBlob(blobinfo types.BlobInfo) (io.ReadCloser, int64, error) {
-	// We should only be asked about things in the manifest.  Maybe the configuration blob.
-	if blobinfo.Digest == is.configID {
-		return ioutil.NopCloser(bytes.NewBuffer(is.config)), is.configSize, nil
-	}
-	// Maybe one of the layer blobs.
-	for i := range is.blobIDs {
-		if blobinfo.Digest == is.blobIDs[i] {
-			// We want to read that layer: open the file or memory block and hand it back.
-			if is.filenames[i] == "-" {
-				return ioutil.NopCloser(bytes.NewBuffer(is.reference.stdin)), int64(len(is.reference.stdin)), nil
-			}
-			reader, err := os.Open(is.filenames[i])
-			if err != nil {
-				return nil, -1, fmt.Errorf("error opening %q: %v", is.filenames[i], err)
-			}
-			return reader, is.blobSizes[i], nil
-		}
-	}
-	return nil, -1, fmt.Errorf("no blob with digest %q found", blobinfo.Digest.String())
-}
-
-// GetManifest returns the image's manifest along with its MIME type (which may be empty when it can't be determined but the manifest is available).
-// It may use a remote (= slow) service.
-// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve (when the primary manifest is a manifest list);
-// this never happens if the primary manifest is not a manifest list (e.g. if the source never returns manifest lists).
-func (is *tarballImageSource) GetManifest(instanceDigest *digest.Digest) ([]byte, string, error) {
-	if instanceDigest != nil {
-		return nil, "", fmt.Errorf("manifest lists are not supported by the %q transport", transportName)
-	}
-	return is.manifest, imgspecv1.MediaTypeImageManifest, nil
-}
-
-// GetSignatures returns the image's signatures.  It may use a remote (= slow) service.
-// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve signatures for
-// (when the primary manifest is a manifest list); this never happens if the primary manifest is not a manifest list
-// (e.g. if the source never returns manifest lists).
-func (*tarballImageSource) GetSignatures(ctx context.Context, instanceDigest *digest.Digest) ([][]byte, error) {
-	if instanceDigest != nil {
-		return nil, fmt.Errorf("manifest lists are not supported by the %q transport", transportName)
-	}
-	return nil, nil
-}
-
-func (is *tarballImageSource) Reference() types.ImageReference {
-	return &is.reference
-}
-
-// LayerInfosForCopy() returns updated layer info that should be used when reading, in preference to values in the manifest, if specified.
-func (*tarballImageSource) LayerInfosForCopy() []types.BlobInfo {
-	return nil
-}

vendor/github.com/containers/image/tarball/tarball_transport.go

@@ -1,66 +0,0 @@
-package tarball
-
-import (
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"strings"
-
-	"github.com/containers/image/transports"
-	"github.com/containers/image/types"
-)
-
-const (
-	transportName = "tarball"
-	separator     = ":"
-)
-
-var (
-	// Transport implements the types.ImageTransport interface for "tarball:" images,
-	// which are makeshift images constructed using one or more possibly-compressed tar
-	// archives.
-	Transport = &tarballTransport{}
-)
-
-type tarballTransport struct {
-}
-
-func (t *tarballTransport) Name() string {
-	return transportName
-}
-
-func (t *tarballTransport) ParseReference(reference string) (types.ImageReference, error) {
-	var stdin []byte
-	var err error
-	filenames := strings.Split(reference, separator)
-	for _, filename := range filenames {
-		if filename == "-" {
-			stdin, err = ioutil.ReadAll(os.Stdin)
-			if err != nil {
-				return nil, fmt.Errorf("error buffering stdin: %v", err)
-			}
-			continue
-		}
-		f, err := os.Open(filename)
-		if err != nil {
-			return nil, fmt.Errorf("error opening %q: %v", filename, err)
-		}
-		f.Close()
-	}
-	ref := &tarballReference{
-		transport: t,
-		filenames: filenames,
-		stdin:     stdin,
-	}
-	return ref, nil
-}
-
-func (t *tarballTransport) ValidatePolicyConfigurationScope(scope string) error {
-	// See the explanation in daemonReference.PolicyConfigurationIdentity.
-	return errors.New(`tarball: does not support any scopes except the default "" one`)
-}
-
-func init() {
-	transports.Register(Transport)
-}

vendor/github.com/containers/image/transports/alltransports/alltransports.go

@@ -13,9 +13,8 @@ import (
 	_ "github.com/containers/image/oci/archive"
 	_ "github.com/containers/image/oci/layout"
 	_ "github.com/containers/image/openshift"
-	_ "github.com/containers/image/tarball"
 	// The ostree transport is registered by ostree*.go
-	// The storage transport is registered by storage*.go
+	_ "github.com/containers/image/storage"
 	"github.com/containers/image/transports"
 	"github.com/containers/image/types"
 	"github.com/pkg/errors"

vendor/github.com/containers/image/transports/alltransports/storage.go

@@ -1,8 +0,0 @@
-// +build !containers_image_storage_stub
-
-package alltransports
-
-import (
-	// Register the storage transport
-	_ "github.com/containers/image/storage"
-)

vendor/github.com/containers/image/transports/alltransports/storage_stub.go

@@ -1,9 +0,0 @@
-// +build containers_image_storage_stub
-
-package alltransports
-
-import "github.com/containers/image/transports"
-
-func init() {
-	transports.Register(transports.NewStubTransport("containers-storage"))
-}

vendor/github.com/containers/image/types/types.go

@@ -73,12 +73,11 @@ type ImageReference interface {
 	// and each following element to be a prefix of the element preceding it.
 	PolicyConfigurationNamespaces() []string
 
-	// NewImage returns a types.ImageCloser for this reference, possibly specialized for this ImageTransport.
-	// The caller must call .Close() on the returned ImageCloser.
+	// NewImage returns a types.Image for this reference, possibly specialized for this ImageTransport.
+	// The caller must call .Close() on the returned Image.
 	// NOTE: If any kind of signature verification should happen, build an UnparsedImage from the value returned by NewImageSource,
 	// verify that UnparsedImage, and convert it into a real Image via image.FromUnparsedImage.
-	// WARNING: This may not do the right thing for a manifest list, see image.FromSource for details.
-	NewImage(ctx *SystemContext) (ImageCloser, error)
+	NewImage(ctx *SystemContext) (Image, error)
 	// NewImageSource returns a types.ImageSource for this reference.
 	// The caller must call .Close() on the returned ImageSource.
 	NewImageSource(ctx *SystemContext) (ImageSource, error)
@@ -97,10 +96,9 @@ type BlobInfo struct {
 	Size        int64         // -1 if unknown
 	URLs        []string
 	Annotations map[string]string
-	MediaType   string
 }
 
-// ImageSource is a service, possibly remote (= slow), to download components of a single image or a named image set (manifest list).
+// ImageSource is a service, possibly remote (= slow), to download components of a single image.
 // This is primarily useful for copying images around; for examining their properties, Image (below)
 // is usually more useful.
 // Each ImageSource should eventually be closed by calling Close().
@@ -115,21 +113,15 @@ type ImageSource interface {
 	Close() error
 	// GetManifest returns the image's manifest along with its MIME type (which may be empty when it can't be determined but the manifest is available).
 	// It may use a remote (= slow) service.
-	// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve (when the primary manifest is a manifest list);
-	// this never happens if the primary manifest is not a manifest list (e.g. if the source never returns manifest lists).
-	GetManifest(instanceDigest *digest.Digest) ([]byte, string, error)
+	GetManifest() ([]byte, string, error)
+	// GetTargetManifest returns an image's manifest given a digest. This is mainly used to retrieve a single image's manifest
+	// out of a manifest list.
+	GetTargetManifest(digest digest.Digest) ([]byte, string, error)
 	// GetBlob returns a stream for the specified blob, and the blob’s size (or -1 if unknown).
-	// The Digest field in BlobInfo is guaranteed to be provided, Size may be -1 and MediaType may be optionally provided.
+	// The Digest field in BlobInfo is guaranteed to be provided; Size may be -1.
 	GetBlob(BlobInfo) (io.ReadCloser, int64, error)
 	// GetSignatures returns the image's signatures.  It may use a remote (= slow) service.
-	// If instanceDigest is not nil, it contains a digest of the specific manifest instance to retrieve signatures for
-	// (when the primary manifest is a manifest list); this never happens if the primary manifest is not a manifest list
-	// (e.g. if the source never returns manifest lists).
-	GetSignatures(ctx context.Context, instanceDigest *digest.Digest) ([][]byte, error)
-	// LayerInfosForCopy returns either nil (meaning the values in the manifest are fine), or updated values for the layer blobsums that are listed in the image's manifest.
-	// The Digest field is guaranteed to be provided; Size may be -1.
-	// WARNING: The list may contain duplicates, and they are semantically relevant.
-	LayerInfosForCopy() []BlobInfo
+	GetSignatures(context.Context) ([][]byte, error)
 }
 
 // ImageDestination is a service, possibly remote (= slow), to store components of a single image.
@@ -161,10 +153,9 @@ type ImageDestination interface {
 	AcceptsForeignLayerURLs() bool
 	// MustMatchRuntimeOS returns true iff the destination can store only images targeted for the current runtime OS. False otherwise.
 	MustMatchRuntimeOS() bool
-	// PutBlob writes contents of stream and returns data representing the result.
+	// PutBlob writes contents of stream and returns data representing the result (with all data filled in).
 	// inputInfo.Digest can be optionally provided if known; it is not mandatory for the implementation to verify it.
 	// inputInfo.Size is the expected length of stream, if known.
-	// inputInfo.MediaType describes the blob format, if known.
 	// WARNING: The contents of stream are being verified on the fly.  Until stream.Read() returns io.EOF, the contents of the data SHOULD NOT be available
 	// to any other readers for download using the supplied digest.
 	// If stream.Read() at any time, ESPECIALLY at end of input, returns an error, PutBlob MUST 1) fail, and 2) delete any data stored so far.
@@ -203,35 +194,28 @@ func (e ManifestTypeRejectedError) Error() string {
 // Thus, an UnparsedImage can be created from an ImageSource simply by fetching blobs without interpreting them,
 // allowing cryptographic signature verification to happen first, before even fetching the manifest, or parsing anything else.
 // This also makes the UnparsedImage→Image conversion an explicitly visible step.
-//
-// An UnparsedImage is a pair of (ImageSource, instance digest); it can represent either a manifest list or a single image instance.
-//
-// The UnparsedImage must not be used after the underlying ImageSource is Close()d.
+// Each UnparsedImage should eventually be closed by calling Close().
 type UnparsedImage interface {
 	// Reference returns the reference used to set up this source, _as specified by the user_
 	// (not as the image itself, or its underlying storage, claims).  This can be used e.g. to determine which public keys are trusted for this image.
 	Reference() ImageReference
+	// Close removes resources associated with an initialized UnparsedImage, if any.
+	Close() error
 	// Manifest is like ImageSource.GetManifest, but the result is cached; it is OK to call this however often you need.
 	Manifest() ([]byte, string, error)
 	// Signatures is like ImageSource.GetSignatures, but the result is cached; it is OK to call this however often you need.
 	Signatures(ctx context.Context) ([][]byte, error)
-	// LayerInfosForCopy returns either nil (meaning the values in the manifest are fine), or updated values for the layer blobsums that are listed in the image's manifest.
-	// The Digest field is guaranteed to be provided, Size may be -1 and MediaType may be optionally provided.
-	// WARNING: The list may contain duplicates, and they are semantically relevant.
-	LayerInfosForCopy() []BlobInfo
 }
 
 // Image is the primary API for inspecting properties of images.
-// An Image is based on a pair of (ImageSource, instance digest); it can represent either a manifest list or a single image instance.
-//
-// The Image must not be used after the underlying ImageSource is Close()d.
+// Each Image should eventually be closed by calling Close().
 type Image interface {
 	// Note that Reference may return nil in the return value of UpdatedImage!
 	UnparsedImage
 	// ConfigInfo returns a complete BlobInfo for the separate config object, or a BlobInfo{Digest:""} if there isn't a separate object.
 	// Note that the config object may not exist in the underlying storage in the return value of UpdatedImage! Use ConfigBlob() below.
 	ConfigInfo() BlobInfo
-	// ConfigBlob returns the blob described by ConfigInfo, if ConfigInfo().Digest != ""; nil otherwise.
+	// ConfigBlob returns the blob described by ConfigInfo, iff ConfigInfo().Digest != ""; nil otherwise.
 	// The result is cached; it is OK to call this however often you need.
 	ConfigBlob() ([]byte, error)
 	// OCIConfig returns the image configuration as per OCI v1 image-spec. Information about
@@ -239,7 +223,7 @@ type Image interface {
 	// old image manifests work (docker v2s1 especially).
 	OCIConfig() (*v1.Image, error)
 	// LayerInfos returns a list of BlobInfos of layers referenced by this image, in order (the root layer first, and then successive layered layers).
-	// The Digest field is guaranteed to be provided, Size may be -1 and MediaType may be optionally provided.
+	// The Digest field is guaranteed to be provided; Size may be -1.
 	// WARNING: The list may contain duplicates, and they are semantically relevant.
 	LayerInfos() []BlobInfo
 	// EmbeddedDockerReferenceConflicts whether a Docker reference embedded in the manifest, if any, conflicts with destination ref.
@@ -256,23 +240,16 @@ type Image interface {
 	// Everything in options.InformationOnly should be provided, other fields should be set only if a modification is desired.
 	// This does not change the state of the original Image object.
 	UpdatedImage(options ManifestUpdateOptions) (Image, error)
+	// IsMultiImage returns true if the image's manifest is a list of images, false otherwise.
+	IsMultiImage() bool
 	// Size returns an approximation of the amount of disk space which is consumed by the image in its current
 	// location.  If the size is not known, -1 will be returned.
 	Size() (int64, error)
 }
 
-// ImageCloser is an Image with a Close() method which must be called by the user.
-// This is returned by ImageReference.NewImage, which transparently instantiates a types.ImageSource,
-// to ensure that the ImageSource is closed.
-type ImageCloser interface {
-	Image
-	// Close removes resources associated with an initialized ImageCloser.
-	Close() error
-}
-
 // ManifestUpdateOptions is a way to pass named optional arguments to Image.UpdatedManifest
 type ManifestUpdateOptions struct {
-	LayerInfos              []BlobInfo // Complete BlobInfos (size+digest+urls+annotations) which should replace the originals, in order (the root layer first, and then successive layered layers). BlobInfos' MediaType fields are ignored.
+	LayerInfos              []BlobInfo // Complete BlobInfos (size+digest+urls) which should replace the originals, in order (the root layer first, and then successive layered layers)
 	EmbeddedDockerReference reference.Named
 	ManifestMIMEType        string
 	// The values below are NOT requests to modify the image; they provide optional context which may or may not be used.
@@ -306,7 +283,7 @@ type DockerAuthConfig struct {
 	Password string
 }
 
-// SystemContext allows parameterizing access to implicitly-accessed resources,
+// SystemContext allows parametrizing access to implicitly-accessed resources,
 // like configuration files in /etc and users' login state in their home directory.
 // Various components can share the same field only if their semantics is exactly
 // the same; if in doubt, add a new field.
@@ -329,10 +306,6 @@ type SystemContext struct {
 	SystemRegistriesConfPath string
 	// If not "", overrides the default path for the authentication file
 	AuthFilePath string
-	// If not "", overrides the use of platform.GOARCH when choosing an image or verifying architecture match.
-	ArchitectureChoice string
-	// If not "", overrides the use of platform.GOOS when choosing an image or verifying OS match.
-	OSChoice string
 
 	// === OCI.Transport overrides ===
 	// If not "", a directory containing a CA certificate (ending with ".crt"),
@@ -341,8 +314,6 @@ type SystemContext struct {
 	OCICertPath string
 	// Allow downloading OCI image layers over HTTP, or HTTPS with failed TLS verification. Note that this does not affect other TLS connections.
 	OCIInsecureSkipTLSVerify bool
-	// If not "", use a shared directory for storing blobs rather than within OCI layouts
-	OCISharedBlobDirPath string
 
 	// === docker.Transport overrides ===
 	// If not "", a directory containing a CA certificate (ending with ".crt"),
@@ -351,9 +322,8 @@ type SystemContext struct {
 	DockerCertPath string
 	// If not "", overrides the system’s default path for a directory containing host[:port] subdirectories with the same structure as DockerCertPath above.
 	// Ignored if DockerCertPath is non-empty.
-	DockerPerHostCertDirPath string
-	// Allow contacting docker registries over HTTP, or HTTPS with failed TLS verification. Note that this does not affect other TLS connections.
-	DockerInsecureSkipTLSVerify bool
+	DockerPerHostCertDirPath    string
+	DockerInsecureSkipTLSVerify bool // Allow contacting docker registries over HTTP, or HTTPS with failed TLS verification. Note that this does not affect other TLS connections.
 	// if nil, the library tries to parse ~/.docker/config.json to retrieve credentials
 	DockerAuthConfig *DockerAuthConfig
 	// if not "", an User-Agent header is added to each request when contacting a registry.
@@ -364,20 +334,6 @@ type SystemContext struct {
 	DockerDisableV1Ping bool
 	// Directory to use for OSTree temporary files
 	OSTreeTmpDirPath string
-
-	// === docker/daemon.Transport overrides ===
-	// A directory containing a CA certificate (ending with ".crt"),
-	// a client certificate (ending with ".cert") and a client certificate key
-	// (ending with ".key") used when talking to a Docker daemon.
-	DockerDaemonCertPath string
-	// The hostname or IP to the Docker daemon. If not set (aka ""), client.DefaultDockerHost is assumed.
-	DockerDaemonHost string
-	// Used to skip TLS verification, off by default. To take effect DockerDaemonCertPath needs to be specified as well.
-	DockerDaemonInsecureSkipTLSVerify bool
-
-	// === dir.Transport overrides ===
-	// DirForceCompress compresses the image layers if set to true
-	DirForceCompress bool
 }
 
 // ProgressProperties is used to pass information from the copy code to a monitor which