Merge pull request #1202 from containers/skopeo_v1.2.2_try2

Skopeo v1.2.2

.cirrus.yml

@@ -1,209 +0,0 @@
----
-
-# Main collection of env. vars to set for all tasks and scripts.
-env:
-    ####
-    #### Global variables used for all tasks
-    ####
-    # Name of the ultimate destination branch for this CI run, PR or post-merge.
-    DEST_BRANCH: "main"
-    # Overrides default location (/tmp/cirrus) for repo clone
-    GOPATH: &gopath "/var/tmp/go"
-    GOBIN: "${GOPATH}/bin"
-    GOCACHE: "${GOPATH}/cache"
-    GOSRC: &gosrc "/var/tmp/go/src/github.com/containers/skopeo"
-    # Required for consistency with containers/image CI
-    SKOPEO_PATH: *gosrc
-    CIRRUS_WORKING_DIR: *gosrc
-    # The default is 'sh' if unspecified
-    CIRRUS_SHELL: "/bin/bash"
-    # Save a little typing (path relative to $CIRRUS_WORKING_DIR)
-    SCRIPT_BASE: "./contrib/cirrus"
-
-    ####
-    #### Cache-image names to test with (double-quotes around names are critical)
-    ####
-    FEDORA_NAME: "fedora-34"
-    PRIOR_FEDORA_NAME: "fedora-33"
-    UBUNTU_NAME: "ubuntu-2104"
-
-    # Google-cloud VM Images
-    IMAGE_SUFFIX: "c6431352024203264"
-    FEDORA_CACHE_IMAGE_NAME: "fedora-${IMAGE_SUFFIX}"
-    PRIOR_FEDORA_CACHE_IMAGE_NAME: "prior-fedora-${IMAGE_SUFFIX}"
-    UBUNTU_CACHE_IMAGE_NAME: "ubuntu-${IMAGE_SUFFIX}"
-
-    # Container FQIN's
-    FEDORA_CONTAINER_FQIN: "quay.io/libpod/fedora_podman:${IMAGE_SUFFIX}"
-    PRIOR_FEDORA_CONTAINER_FQIN: "quay.io/libpod/prior-fedora_podman:${IMAGE_SUFFIX}"
-    UBUNTU_CONTAINER_FQIN: "quay.io/libpod/ubuntu_podman:${IMAGE_SUFFIX}"
-
-    # Built along with the standard PR-based workflow in c/automation_images
-    SKOPEO_CIDEV_CONTAINER_FQIN: "quay.io/libpod/skopeo_cidev:${IMAGE_SUFFIX}"
-
-
-# Default timeout for each task
-timeout_in: 45m
-
-
-gcp_credentials: ENCRYPTED[52d9e807b531b37ab14e958cb5a72499460663f04c8d73e22ad608c027a31118420f1c80f0be0882fbdf96f49d8f9ac0]
-
-
-validate_task:
-    # The git-validation tool doesn't work well on branch or tag push,
-    # under Cirrus-CI, due to challenges obtaining the starting commit ID.
-    # Only do validation for PRs.
-    only_if: $CIRRUS_PR != ''
-    container:
-        image: '${SKOPEO_CIDEV_CONTAINER_FQIN}'
-        cpu: 4
-        memory: 8
-    script: |
-        make validate-local
-        make vendor && hack/tree_status.sh
-
-doccheck_task:
-    only_if: $CIRRUS_PR != ''
-    depends_on:
-      - validate
-    container:
-        image: "${FEDORA_CONTAINER_FQIN}"
-        cpu: 4
-        memory: 8
-    env:
-        BUILDTAGS: &withopengpg 'btrfs_noversion libdm_no_deferred_remove containers_image_openpgp'
-    script: |
-      # TODO: Can't use 'runner.sh setup' inside container.  However,
-      # removing the pre-installed package is the only necessary step
-      # at the time of this comment.
-      dnf erase -y skopeo  # Guarantee non-interference
-      "${SKOPEO_PATH}/${SCRIPT_BASE}/runner.sh" build
-      "${SKOPEO_PATH}/${SCRIPT_BASE}/runner.sh" doccheck
-
-osx_task:
-    only_if: &not_docs $CIRRUS_CHANGE_TITLE !=~ '.*CI:DOCS.*'
-    depends_on:
-        - validate
-    macos_instance:
-        image: catalina-xcode
-    setup_script: |
-        export PATH=$GOPATH/bin:$PATH
-        brew update
-        brew install gpgme go go-md2man
-        go get -u golang.org/x/lint/golint
-    test_script: |
-        export PATH=$GOPATH/bin:$PATH
-        go version
-        go env
-        make validate-local test-unit-local bin/skopeo
-        sudo make install
-        /usr/local/bin/skopeo -v
-
-
-cross_task:
-    alias: cross
-    only_if: *not_docs
-    depends_on:
-        - validate
-    gce_instance:
-        image_project: libpod-218412
-        zone: "us-central1-f"
-        cpu: 2
-        memory: "4Gb"
-        # Required to be 200gig, do not modify - has i/o performance impact
-        # according to gcloud CLI tool warning messages.
-        disk: 200
-        image_name: ${FEDORA_CACHE_IMAGE_NAME}
-    env:
-        BUILDTAGS: *withopengpg
-    setup_script: >-
-        "${GOSRC}/${SCRIPT_BASE}/runner.sh" setup
-    cross_script: >-
-        "${GOSRC}/${SCRIPT_BASE}/runner.sh" cross
-
-
-#####
-##### NOTE: This task is subtantially duplicated in the containers/image
-##### repository's `.cirrus.yml`.  Changes made here should be fully merged
-##### prior to being manually duplicated and maintained in containers/image.
-#####
-test_skopeo_task:
-    alias: test_skopeo
-    only_if: *not_docs
-    depends_on:
-        - validate
-    gce_instance:
-        image_project: libpod-218412
-        zone: "us-central1-f"
-        cpu: 2
-        memory: "4Gb"
-        # Required to be 200gig, do not modify - has i/o performance impact
-        # according to gcloud CLI tool warning messages.
-        disk: 200
-        image_name: ${FEDORA_CACHE_IMAGE_NAME}
-    matrix:
-        - name: "Skopeo Test"  # N/B: Name ref. by hack/get_fqin.sh
-          env:
-              BUILDTAGS: 'btrfs_noversion libdm_no_deferred_remove'
-        - name: "Skopeo Test w/ opengpg"
-          env:
-              BUILDTAGS: *withopengpg
-    setup_script: >-
-        "${GOSRC}/${SCRIPT_BASE}/runner.sh" setup
-    vendor_script: >-
-        "${SKOPEO_PATH}/${SCRIPT_BASE}/runner.sh" vendor
-    build_script: >-
-        "${SKOPEO_PATH}/${SCRIPT_BASE}/runner.sh" build
-    unit_script: >-
-        "${SKOPEO_PATH}/${SCRIPT_BASE}/runner.sh" unit
-    integration_script: >-
-        "${SKOPEO_PATH}/${SCRIPT_BASE}/runner.sh" integration
-    system_script: >
-        "${SKOPEO_PATH}/${SCRIPT_BASE}/runner.sh" system
-
-
-# This task is critical.  It updates the "last-used by" timestamp stored
-# in metadata for all VM images.  This mechanism functions in tandem with
-# an out-of-band pruning operation to remove disused VM images.
-meta_task:
-    name: "VM img. keepalive"
-    alias: meta
-    container: &smallcontainer
-        cpu: 2
-        memory: 2
-        image: quay.io/libpod/imgts:$IMAGE_SUFFIX
-    env:
-        # Space-separated list of images used by this repository state
-        IMGNAMES: >-
-            ${FEDORA_CACHE_IMAGE_NAME}
-            ${PRIOR_FEDORA_CACHE_IMAGE_NAME}
-            ${UBUNTU_CACHE_IMAGE_NAME}
-        BUILDID: "${CIRRUS_BUILD_ID}"
-        REPOREF: "${CIRRUS_REPO_NAME}"
-        GCPJSON: ENCRYPTED[6867b5a83e960e7c159a98fe6c8360064567a071c6f4b5e7d532283ecd870aa65c94ccd74bdaa9bf7aadac9d42e20a67]
-        GCPNAME: ENCRYPTED[1cf558ae125e3c39ec401e443ad76452b25d790c45eb73d77c83eb059a0f7fd5085ef7e2f7e410b04ea6e83b0aab2eb1]
-        GCPPROJECT: libpod-218412
-    clone_script: &noop mkdir -p "$CIRRUS_WORKING_DIR"
-    script: /usr/local/bin/entrypoint.sh
-
-
-# Status aggregator for all tests.  This task simply ensures a defined
-# set of tasks all passed, and allows confirming that based on the status
-# of this task.
-success_task:
-    name: "Total Success"
-    alias: success
-    # N/B: ALL tasks must be listed here, minus their '_task' suffix.
-    depends_on:
-        - validate
-        - doccheck
-        - osx
-        - cross
-        - test_skopeo
-        - meta
-    container: *smallcontainer
-    env:
-        CTR_FQIN: ${FEDORA_CONTAINER_FQIN}
-        TEST_ENVIRON: container
-    clone_script: *noop
-    script: /bin/true

.github/dependabot.yml

@@ -1,10 +0,0 @@
-version: 2
-updates:
-- package-ecosystem: gomod
-  directory: "/"
-  schedule:
-    interval: daily
-    time: "10:00"
-    timezone: Europe/Berlin
-  open-pull-requests-limit: 10
-

.github/workflows/check_cirrus_cron.yml

@@ -1,93 +0,0 @@
----
-
-# See also:
-# https://github.com/containers/podman/blob/main/.github/workflows/check_cirrus_cron.yml
-
-# Format Ref: https://docs.github.com/en/free-pro-team@latest/actions/reference/workflow-syntax-for-github-actions
-
-# Required to un-FUBAR default ${{github.workflow}} value
-name: check_cirrus_cron
-
-on:
-    # Note: This only applies to the default branch.
-    schedule:
-        # N/B: This should correspond to a period slightly after
-        # the last job finishes running.  See job defs. at:
-        # https://cirrus-ci.com/settings/repository/6706677464432640
-        - cron:  '59 23 * * 1-5'
-    # Debug: Allow triggering job manually in github-actions WebUI
-    workflow_dispatch: {}
-
-env:
-    # Debug-mode can reveal secrets, only enable by a secret value.
-    # Ref: https://help.github.com/en/actions/configuring-and-managing-workflows/managing-a-workflow-run#enabling-step-debug-logging
-    ACTIONS_STEP_DEBUG: '${{ secrets.ACTIONS_STEP_DEBUG }}'
-    # Use same destination addresses from podman repository
-    FAILMAILCSV: './_podman/contrib/cirrus/cron-fail_addrs.csv'
-    # Filename for table of cron-name to build-id data
-    # (must be in $GITHUB_WORKSPACE/artifacts/)
-    NAME_ID_FILEPATH: './artifacts/name_id.txt'
-
-jobs:
-    cron_failures:
-        runs-on: ubuntu-latest
-        steps:
-            - uses: actions/checkout@v2
-              with:
-                  persist-credentials: false
-
-            # Avoid duplicating cron_failures.sh in skopeo repo.
-            - uses: actions/checkout@v2
-              with:
-                  repository: containers/podman
-                  path: '_podman'
-                  persist-credentials: false
-
-            - name: Get failed cron names and Build IDs
-              id: cron
-              run: './_podman/.github/actions/${{ github.workflow }}/${{ github.job }}.sh'
-
-            - if: steps.cron.outputs.failures > 0
-              shell: bash
-              # Must be inline, since context expressions are used.
-              # Ref: https://docs.github.com/en/free-pro-team@latest/actions/reference/context-and-expression-syntax-for-github-actions
-              run: |
-                set -eo pipefail
-                (
-                echo "Detected one or more Cirrus-CI cron-triggered jobs have failed recently:"
-                echo ""
-
-                while read -r NAME BID; do
-                    echo "Cron build '$NAME' Failed: https://cirrus-ci.com/build/$BID"
-                done < "$NAME_ID_FILEPATH"
-
-                echo ""
-                echo "# Source: ${{ github.workflow }} workflow on ${{ github.repository }}."
-                # Separate content from sendgrid.com automatic footer.
-                echo ""
-                echo ""
-                ) > ./artifacts/email_body.txt
-
-            - if: steps.cron.outputs.failures > 0
-              id: mailto
-              run: printf "::set-output name=csv::%s\n" $(cat "$FAILMAILCSV")
-
-            - if: steps.mailto.outputs.csv != ''
-              name: Send failure notification e-mail
-              # Ref: https://github.com/dawidd6/action-send-mail
-              uses: dawidd6/action-send-mail@v2.2.2
-              with:
-                server_address: ${{secrets.ACTION_MAIL_SERVER}}
-                server_port: 465
-                username: ${{secrets.ACTION_MAIL_USERNAME}}
-                password: ${{secrets.ACTION_MAIL_PASSWORD}}
-                subject: Cirrus-CI cron build failures on ${{github.repository}}
-                to: ${{steps.mailto.outputs.csv}}
-                from: ${{secrets.ACTION_MAIL_SENDER}}
-                body: file://./artifacts/email_body.txt
-
-            - if: always()
-              uses: actions/upload-artifact@v2
-              with:
-                  name: ${{ github.job }}_artifacts
-                  path: artifacts/*

.github/workflows/multi-arch-build.yaml

@@ -1,209 +0,0 @@
----
-
-# Please see contrib/<reponame>image/README.md for details on the intentions
-# of this workflow.
-#
-# BIG FAT WARNING:  This workflow is duplicated across containers/skopeo,
-#                   containers/buildah, and containers/podman.  ANY AND
-#                   ALL CHANGES MADE HERE MUST BE MANUALLY DUPLICATED
-#                   TO THE OTHER REPOS.
-
-name: build multi-arch images
-
-on:
-  # Upstream tends to be very active, with many merges per day.
-  # Only run this daily via cron schedule, or manually, not by branch push.
-  schedule:
-    - cron:  '0 8 * * *'
-  # allows to run this workflow manually from the Actions tab
-  workflow_dispatch:
-
-jobs:
-  multi:
-    name: multi-arch image build
-    env:
-      REPONAME: skopeo  # No easy way to parse this out of $GITHUB_REPOSITORY
-      # Server/namespace value used to format FQIN
-      REPONAME_QUAY_REGISTRY: quay.io/skopeo
-      CONTAINERS_QUAY_REGISTRY: quay.io/containers
-      # list of architectures for build
-      PLATFORMS: linux/amd64,linux/s390x,linux/ppc64le,linux/arm64
-      # Command to execute in container to obtain project version number
-      VERSION_CMD: "--version"  # skopeo is the entrypoint
-
-    # build several images (upstream, testing, stable) in parallel
-    strategy:
-      # By default, failure of one matrix item cancels all others
-      fail-fast: false
-      matrix:
-        # Builds are located under contrib/<reponame>image/<source> directory
-        source:
-          - upstream
-          - testing
-          - stable
-    runs-on: ubuntu-latest
-    # internal registry caches build for inspection before push
-    services:
-      registry:
-        image: quay.io/libpod/registry:2
-        ports:
-          - 5000:5000
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-        with:
-          driver-opts: network=host
-          install: true
-
-      - name: Build and locally push image
-        uses: docker/build-push-action@v2
-        with:
-          context: contrib/${{ env.REPONAME }}image/${{ matrix.source }}
-          file: ./contrib/${{ env.REPONAME }}image/${{ matrix.source }}/Dockerfile
-          platforms: ${{ env.PLATFORMS }}
-          push: true
-          tags: localhost:5000/${{ env.REPONAME }}/${{ matrix.source }}
-
-      # Simple verification that stable images work, and
-      # also grab version number use in forming the FQIN.
-      - name: amd64 container sniff test
-        if: matrix.source == 'stable'
-        id: sniff_test
-        run: |
-          podman pull --tls-verify=false \
-                            localhost:5000/$REPONAME/${{ matrix.source }}
-          VERSION_OUTPUT=$(podman run \
-                           localhost:5000/$REPONAME/${{ matrix.source }} \
-                           $VERSION_CMD)
-          echo "$VERSION_OUTPUT"
-          VERSION=$(awk -r -e "/^${REPONAME} version /"'{print $3}' <<<"$VERSION_OUTPUT")
-          test -n "$VERSION"
-          echo "::set-output name=version::$VERSION"
-
-      - name: Generate image FQIN(s) to push
-        id: reponame_reg
-        run: |
-          if [[ "${{ matrix.source }}" == 'stable' ]]; then
-            # The command version in image just built
-            VERSION='v${{ steps.sniff_test.outputs.version }}'
-            # workaround vim syntax-highlight bug: '
-            # Push both new|updated version-tag and latest-tag FQINs
-            FQIN="$REPONAME_QUAY_REGISTRY/stable:$VERSION,$REPONAME_QUAY_REGISTRY/stable:latest"
-          elif [[ "${{ matrix.source }}" == 'testing' ]]; then
-            # Assume some contents changed, always push latest testing.
-            FQIN="$REPONAME_QUAY_REGISTRY/testing:latest"
-          elif [[ "${{ matrix.source }}" == 'upstream' ]]; then
-            # Assume some contents changed, always push latest upstream.
-            FQIN="$REPONAME_QUAY_REGISTRY/upstream:latest"
-          else
-            echo "::error::Unknown matrix item '${{ matrix.source }}'"
-            exit 1
-          fi
-          echo "::warning::Pushing $FQIN"
-          echo "::set-output name=fqin::${FQIN}"
-          echo '::set-output name=push::true'
-
-      # This is substantially similar to the above logic,
-      # but only handles $CONTAINERS_QUAY_REGISTRY for
-      # the stable "latest" and named-version tagged images.
-      - name: Generate containers reg. image FQIN(s)
-        if: matrix.source == 'stable'
-        id: containers_reg
-        run: |
-          VERSION='v${{ steps.sniff_test.outputs.version }}'
-          # workaround vim syntax-highlight bug: '
-          # Push both new|updated version-tag and latest-tag FQINs
-          FQIN="$CONTAINERS_QUAY_REGISTRY/$REPONAME:$VERSION,$CONTAINERS_QUAY_REGISTRY/$REPONAME:latest"
-          echo "::warning::Pushing $FQIN"
-          echo "::set-output name=fqin::${FQIN}"
-          echo '::set-output name=push::true'
-
-      - name: Define LABELS multi-line env. var. value
-        run: |
-          # This is a really hacky/strange workflow idiom, required
-          # for setting multi-line $LABELS value for consumption in
-          # a future step.  There is literally no cleaner way to do this :<
-          # https://docs.github.com/en/actions/reference/workflow-commands-for-github-actions#multiline-strings
-          function set_labels() {
-            echo 'LABELS<<DELIMITER' >> "$GITHUB_ENV"
-            for line; do
-                echo "$line" | tee -a "$GITHUB_ENV"
-            done
-            echo "DELIMITER" >> "$GITHUB_ENV"
-          }
-
-          declare -a lines
-          lines=(\
-            "org.opencontainers.image.source=https://github.com/${GITHUB_REPOSITORY}.git"
-            "org.opencontainers.image.revision=${GITHUB_SHA}"
-            "org.opencontainers.image.created=$(date -u --iso-8601=seconds)"
-          )
-
-          # Only the 'stable' matrix source obtains $VERSION
-          if [[ "${{ matrix.source }}" == "stable" ]]; then
-            lines+=(\
-              "org.opencontainers.image.version=${{ steps.sniff_test.outputs.version }}"
-            )
-          fi
-
-          set_labels "${lines[@]}"
-
-      # Separate steps to login and push for $REPONAME_QUAY_REGISTRY and
-      # $CONTAINERS_QUAY_REGISTRY are required, because 2 sets of credentials
-      # are used and namespaced within the registry.  At the same time, reuse
-      # of non-shell steps is not supported by Github Actions nor are YAML
-      # anchors/aliases, nor composite actions.
-
-      # Push to $REPONAME_QUAY_REGISTRY for stable, testing. and upstream
-      - name: Login to ${{ env.REPONAME_QUAY_REGISTRY }}
-        uses: docker/login-action@v1
-        if: steps.reponame_reg.outputs.push == 'true'
-        with:
-          registry: ${{ env.REPONAME_QUAY_REGISTRY }}
-          # N/B: Secrets are not passed to workflows that are triggered
-          #      by a pull request from a fork
-          username: ${{ secrets.REPONAME_QUAY_USERNAME }}
-          password: ${{ secrets.REPONAME_QUAY_PASSWORD }}
-
-      - name: Push images to ${{ steps.reponame_reg.outputs.fqin }}
-        uses: docker/build-push-action@v2
-        if: steps.reponame_reg.outputs.push == 'true'
-        with:
-          cache-from: type=registry,ref=localhost:5000/${{ env.REPONAME }}/${{ matrix.source }}
-          cache-to: type=inline
-          context: contrib/${{ env.REPONAME }}image/${{ matrix.source }}
-          file: ./contrib/${{ env.REPONAME }}image/${{ matrix.source }}/Dockerfile
-          platforms: ${{ env.PLATFORMS }}
-          push: true
-          tags: ${{ steps.reponame_reg.outputs.fqin }}
-          labels: |
-            ${{ env.LABELS }}
-
-      # Push to $CONTAINERS_QUAY_REGISTRY only stable
-      - name: Login to ${{ env.CONTAINERS_QUAY_REGISTRY }}
-        if: steps.containers_reg.outputs.push == 'true'
-        uses: docker/login-action@v1
-        with:
-          registry: ${{ env.CONTAINERS_QUAY_REGISTRY}}
-          username: ${{ secrets.CONTAINERS_QUAY_USERNAME }}
-          password: ${{ secrets.CONTAINERS_QUAY_PASSWORD }}
-
-      - name: Push images to ${{ steps.containers_reg.outputs.fqin }}
-        if: steps.containers_reg.outputs.push == 'true'
-        uses: docker/build-push-action@v2
-        with:
-          cache-from: type=registry,ref=localhost:5000/${{ env.REPONAME }}/${{ matrix.source }}
-          cache-to: type=inline
-          context: contrib/${{ env.REPONAME }}image/${{ matrix.source }}
-          file: ./contrib/${{ env.REPONAME }}image/${{ matrix.source }}/Dockerfile
-          platforms: ${{ env.PLATFORMS }}
-          push: true
-          tags: ${{ steps.containers_reg.outputs.fqin }}
-          labels: |
-            ${{ env.LABELS }}

.github/workflows/stale.yml

@@ -1,25 +0,0 @@
-name: Mark stale issues and pull requests
-
-# Please refer to https://github.com/actions/stale/blob/master/action.yml
-# to see all config knobs of the stale action.
-
-on:
-  schedule:
-  - cron: "0 0 * * *"
-
-jobs:
-  stale:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/stale@v1
-      with:
-        repo-token: ${{ secrets.GITHUB_TOKEN }}
-        stale-issue-message: 'A friendly reminder that this issue had no activity for 30 days.'
-        stale-pr-message: 'A friendly reminder that this PR had no activity for 30 days.'
-        stale-issue-label: 'stale-issue'
-        stale-pr-label: 'stale-pr'
-        days-before-stale: 30
-        days-before-close: 365
-        remove-stale-when-updated: true

.gitignore

@@ -5,6 +5,3 @@ result
 
 # ignore JetBrains IDEs (GoLand) config folder
 .idea
-
-# Ignore the bin directory
-bin

.travis.yml

@@ -0,0 +1,101 @@
+language: go
+
+go:
+  - 1.15.x
+
+notifications:
+  email: false
+
+env:
+  global:
+    # Multiarch manifest will support architectures from this list. It should be the same architectures, as ones in image-build-push step in this Travis config
+    - MULTIARCH_MANIFEST_ARCHITECTURES="amd64 s390x ppc64le"
+    # env variables for stable image build
+    - STABLE_IMAGE=quay.io/skopeo/stable:v1.2.0
+    - EXTRA_STABLE_IMAGE=quay.io/containers/skopeo:v1.2.0
+    # env variable for upstream image build
+    - UPSTREAM_IMAGE=quay.io/skopeo/upstream:master
+
+# Just declaration of the image-build-push step with script actions to execute
+x_base_steps:
+  - &image-build-push
+    services:
+      - docker
+    os: linux
+    dist: focal
+    script:
+      # skopeo upstream image build
+      - make -f release/Makefile build-image/upstream
+      # Push image in case if build is started via cron job or code is pushed to master
+      - if [ "$TRAVIS_EVENT_TYPE" == "push" ] || [ "$TRAVIS_EVENT_TYPE" == "cron" ]; then
+           make -f release/Makefile push-image/upstream ;
+        fi
+
+      # skopeo stable image build
+      - make -f release/Makefile build-image/stable
+      # Push image in case if build is started via cron job or code is pushed to master
+      - if [ "$TRAVIS_EVENT_TYPE" == "push" ] || [ "$TRAVIS_EVENT_TYPE" == "cron" ]; then
+           make -f release/Makefile push-image/stable ;
+        fi
+
+# Just declaration of stage order to run
+stages:
+  # Test for local build
+  - local-build
+  # Build and push image for 1 architecture
+  - name: image-build-push
+    if: branch = master
+  # Create and push image manifest to have multiarch image on top of architecture specific images
+  - name: manifest-multiarch-push
+    if: (type IN (push, cron)) AND branch = master
+
+# Actual execution of steps
+jobs:
+  include:
+    # Run 2 local-build steps in parallel for osx and linux/amd64 platforms
+    - stage: local-build
+      <<: *local-build
+      name: local build for osx
+      os: osx
+      osx_image: xcode11.3
+      install:
+        # Ideally, the (brew update) should not be necessary and Travis would have fairly
+        # frequently updated OS images; that's not been the case historically.
+        # In particular, explicitly unlink python@2, which has been removed from Homebrew
+        # since the last OS image build (as of July 2020), but the Travis OS still
+        # contains it, and it prevents updating of Python 3.
+      - brew update && brew unlink python@2 && brew install gpgme
+      script:
+      - hack/travis_osx.sh
+    - stage: local-build
+      <<: *local-build
+      name: local build for linux
+      os: linux
+      services:
+      - docker
+      script: 
+      - make vendor && ./hack/tree_status.sh && make local-cross && make check
+
+    # Run 3 image-build-push tasks in parallel for linux/amd64, linux/s390x and linux/ppc64le platforms (for upstream and stable)
+    - stage: image-build-push
+      <<: *image-build-push
+      name: images for amd64
+      arch: amd64
+
+    - stage: image-build-push
+      <<: *image-build-push
+      name: images for s390x
+      arch: s390x
+
+    - stage: image-build-push
+      <<: *image-build-push
+      name: images for ppc64le
+      arch: ppc64le
+
+    # Run final task to generate multi-arch image manifests (for upstream and stable)
+    - stage: manifest-multiarch-push
+      os: linux
+      dist: focal
+      script:
+      - make -f release/Makefile push-manifest-multiarch/upstream
+      - make -f release/Makefile push-manifest-multiarch/stable

CODE-OF-CONDUCT.md

@@ -1,3 +1,3 @@
 ## The skopeo Project Community Code of Conduct
 
-The skopeo project follows the [Containers Community Code of Conduct](https://github.com/containers/common/blob/main/CODE-OF-CONDUCT.md).
+The skopeo project follows the [Containers Community Code of Conduct](https://github.com/containers/common/blob/master/CODE-OF-CONDUCT.md).

CONTRIBUTING.md

@@ -117,31 +117,29 @@ commit automatically with `git commit -s`.
 
 ### Dependencies management
 
-Dependencies are managed via [standard go modules](https://golang.org/ref/mod).
+Make sure [`vndr`](https://github.com/LK4D4/vndr) is installed.
 
 In order to add a new dependency to this project:
 
-- use `go get -d path/to/dep@version` to add a new line to `go.mod`
+- add a new line to `vendor.conf` according to `vndr` rules (e.g. `github.com/pkg/errors master`)
 - run `make vendor`
 
 In order to update an existing dependency:
 
-- use `go get -d -u path/to/dep@version` to update the relevant dependency line in `go.mod`
+- update the relevant dependency line in `vendor.conf`
 - run `make vendor`
 
 When new PRs for [containers/image](https://github.com/containers/image) break `skopeo` (i.e. `containers/image` tests fail in `make test-skopeo`):
 
 - create out a new branch in your `skopeo` checkout and switch to it
-- find out the version of `containers/image` you want to use and note its commit ID. You might also want to use a fork of `containers/image`, in that case note its repo
-- use `go get -d github.com/$REPO/image/v5@$COMMIT_ID` to download the right version. The command will fetch the dependency and then fail because of a conflict in `go.mod`, this is expected. Note the pseudo-version (eg. `v5.13.1-0.20210707123201-50afbf0a326`)
-- use `go mod edit -replace=github.com/containers/image/v5=github.com/$REPO/image/v5@$PSEUDO_VERSION` to add a replacement line to `go.mod` (e.g. `replace github.com/containers/image/v5 => github.com/moio/image/v5 v5.13.1-0.20210707123201-50afbf0a3262`)
+- update `vendor.conf`. Find out the `containers/image` dependency; update it to vendor from your own branch and your own repository fork (e.g. `github.com/containers/image my-branch https://github.com/runcom/image`)
 - run `make vendor`
 - make any other necessary changes in the skopeo repo (e.g. add other dependencies now required by `containers/image`, or update skopeo for changed `containers/image` API)
 - optionally add new integration tests to the skopeo repo
 - submit the resulting branch as a skopeo PR, marked “DO NOT MERGE”
 - iterate until tests pass and the PR is reviewed
 - then the original `containers/image` PR can be merged, disregarding its `make test-skopeo` failure
-- as soon as possible after that, in the skopeo PR, use `go mod edit -dropreplace=github.com/containers/image` to remove the `replace` line in `go.mod`
+- as soon as possible after that, in the skopeo PR, restore the `containers/image` line in `vendor.conf` to use `containers/image:master`
 - run `make vendor`
 - update the skopeo PR with the result, drop the “DO NOT MERGE” marking
 - after tests complete successfully again, merge the skopeo PR

Dockerfile

@@ -0,0 +1,53 @@
+FROM fedora
+
+RUN dnf -y update && dnf install -y make git golang golang-github-cpuguy83-md2man \
+	# storage deps
+	btrfs-progs-devel \
+	device-mapper-devel \
+	# gpgme bindings deps
+	libassuan-devel gpgme-devel \
+	gnupg \
+	# htpasswd for system tests
+	httpd-tools \
+	# OpenShift deps
+	which tar wget hostname util-linux bsdtar socat ethtool device-mapper iptables tree findutils nmap-ncat e2fsprogs xfsprogs lsof docker iproute \
+        bats jq podman runc \
+	golint \
+	openssl \
+	&& dnf clean all
+
+# Install two versions of the registry. The first is an older version that
+# only supports schema1 manifests. The second is a newer version that supports
+# both. This allows integration-cli tests to cover push/pull with both schema1
+# and schema2 manifests.
+RUN set -x \
+	&& REGISTRY_COMMIT_SCHEMA1=ec87e9b6971d831f0eff752ddb54fb64693e51cd \
+	&& REGISTRY_COMMIT=47a064d4195a9b56133891bbb13620c3ac83a827 \
+	&& export GOPATH="$(mktemp -d)" \
+	&& git clone https://github.com/docker/distribution.git "$GOPATH/src/github.com/docker/distribution" \
+	&& (cd "$GOPATH/src/github.com/docker/distribution" && git checkout -q "$REGISTRY_COMMIT") \
+	&& GOPATH="$GOPATH/src/github.com/docker/distribution/Godeps/_workspace:$GOPATH" \
+		go build -o /usr/local/bin/registry-v2 github.com/docker/distribution/cmd/registry \
+	&& (cd "$GOPATH/src/github.com/docker/distribution" && git checkout -q "$REGISTRY_COMMIT_SCHEMA1") \
+	&& GOPATH="$GOPATH/src/github.com/docker/distribution/Godeps/_workspace:$GOPATH" \
+		go build -o /usr/local/bin/registry-v2-schema1 github.com/docker/distribution/cmd/registry \
+	&& rm -rf "$GOPATH"
+
+RUN set -x \
+	&& export GOPATH=$(mktemp -d) \
+	&& git clone --depth 1 -b v1.5.0-alpha.3 git://github.com/openshift/origin "$GOPATH/src/github.com/openshift/origin" \
+	# The sed edits out a "go < 1.5" check which works incorrectly with go ≥ 1.10. \
+	&& sed -i -e 's/\[\[ "\${go_version\[2]}" < "go1.5" ]]/false/' "$GOPATH/src/github.com/openshift/origin/hack/common.sh" \
+	&& (cd "$GOPATH/src/github.com/openshift/origin" && make clean build && make all WHAT=cmd/dockerregistry) \
+	&& cp -a "$GOPATH/src/github.com/openshift/origin/_output/local/bin/linux"/*/* /usr/local/bin \
+	&& cp "$GOPATH/src/github.com/openshift/origin/images/dockerregistry/config.yml" /atomic-registry-config.yml \
+	&& rm -rf "$GOPATH" \
+	&& mkdir /registry
+
+ENV GOPATH /usr/share/gocode:/go
+ENV PATH $GOPATH/bin:/usr/share/gocode/bin:$PATH
+RUN go version
+WORKDIR /go/src/github.com/containers/skopeo
+COPY . /go/src/github.com/containers/skopeo
+
+#ENTRYPOINT ["hack/dind"]

Dockerfile.build

@@ -0,0 +1,9 @@
+FROM golang:1.14-buster
+
+RUN apt-get update && \
+    apt-get install -y \
+        libdevmapper-dev \
+        libgpgme11-dev
+
+ENV GOPATH=/
+WORKDIR /src/github.com/containers/skopeo

Makefile

@@ -1,24 +1,27 @@
-.PHONY: all binary docs docs-in-container build-local clean install install-binary install-completions shell test-integration .install.vndr vendor vendor-in-container
+.PHONY: all binary build-container docs docs-in-container build-local clean install install-binary install-completions shell test-integration .install.vndr vendor vendor-in-container
 
 export GOPROXY=https://proxy.golang.org
 
-# On some platforms (eg. macOS, FreeBSD) gpgme is installed in /usr/local/ but /usr/local/include/ is
-# not in the default search path. Rather than hard-code this directory, use gpgme-config.
-# Sadly that must be done at the top-level user instead of locally in the gpgme subpackage, because cgo
-# supports only pkg-config, not general shell scripts, and gpgme does not install a pkg-config file.
+ifeq ($(shell uname),Darwin)
+PREFIX ?= ${DESTDIR}/usr/local
+DARWIN_BUILD_TAG=
+# On macOS, (brew install gpgme) installs it within /usr/local, but /usr/local/include is not in the default search path.
+# Rather than hard-code this directory, use gpgme-config. Sadly that must be done at the top-level user
+# instead of locally in the gpgme subpackage, because cgo supports only pkg-config, not general shell scripts,
+# and gpgme does not install a pkg-config file.
 # If gpgme is not installed or gpgme-config can’t be found for other reasons, the error is silently ignored
 # (and the user will probably find out because the cgo compilation will fail).
 GPGME_ENV := CGO_CFLAGS="$(shell gpgme-config --cflags 2>/dev/null)" CGO_LDFLAGS="$(shell gpgme-config --libs 2>/dev/null)"
+else
+PREFIX ?= ${DESTDIR}/usr
+endif
 
-# The following variables very roughly follow https://www.gnu.org/prep/standards/standards.html#Makefile-Conventions .
-DESTDIR ?=
-PREFIX ?= /usr/local
-CONTAINERSCONFDIR ?= /etc/containers
-REGISTRIESDDIR ?= ${CONTAINERSCONFDIR}/registries.d
-SIGSTOREDIR ?= /var/lib/containers/sigstore
-BINDIR ?= ${PREFIX}/bin
-MANDIR ?= ${PREFIX}/share/man
-BASHCOMPLETIONSDIR ?= ${PREFIX}/share/bash-completion/completions
+INSTALLDIR=${PREFIX}/bin
+MANINSTALLDIR=${PREFIX}/share/man
+CONTAINERSSYSCONFIGDIR=${DESTDIR}/etc/containers
+REGISTRIESDDIR=${CONTAINERSSYSCONFIGDIR}/registries.d
+SIGSTOREDIR=${DESTDIR}/var/lib/containers/sigstore
+BASHINSTALLDIR=${PREFIX}/share/bash-completion/completions
 
 GO ?= go
 GOBIN := $(shell $(GO) env GOBIN)
@@ -29,10 +32,8 @@ ifeq ($(GOBIN),)
 GOBIN := $(GOPATH)/bin
 endif
 
-# Multiple scripts are sensitive to this value, make sure it's exported/available
-# N/B: Need to use 'command -v' here for compatibility with MacOS.
-export CONTAINER_RUNTIME ?= $(if $(shell command -v podman),podman,docker)
-GOMD2MAN ?= $(if $(shell command -v go-md2man),go-md2man,$(GOBIN)/go-md2man)
+CONTAINER_RUNTIME := $(shell command -v podman 2> /dev/null || echo docker)
+GOMD2MAN ?= $(shell command -v go-md2man || echo '$(GOBIN)/go-md2man')
 
 # Go module support: set `-mod=vendor` to use the vendored sources.
 # See also hack/make.sh.
@@ -52,32 +53,9 @@ ifeq ($(GOOS), linux)
 endif
 
 GIT_BRANCH := $(shell git rev-parse --abbrev-ref HEAD 2>/dev/null)
-
-# If $TESTFLAGS is set, it is passed as extra arguments to 'go test'.
-# You can increase test output verbosity with the option '-test.vv'.
-# You can select certain tests to run, with `-test.run <regex>` for example:
-#
-#     make test-unit TESTFLAGS='-test.run ^TestManifestDigest$'
-#
-# For integration test, we use [gocheck](https://labix.org/gocheck).
-# You can increase test output verbosity with the option '-check.vv'.
-# You can limit test selection with `-check.f <regex>`, for example:
-#
-#     make test-integration TESTFLAGS='-check.f CopySuite.TestCopy.*'
-export TESTFLAGS ?= -v -check.v -test.timeout=15m
-
-# This is assumed to be set non-empty when operating inside a CI/automation environment
-CI ?=
-
-# This env. var. is interpreted by some tests as a permission to
-# modify local configuration files and services.
-export SKOPEO_CONTAINER_TESTS ?= $(if $(CI),1,0)
-
-# This is a compromise, we either use a container for this or require
-# the local user to have a compatible python3 development environment.
-# Define it as a "resolve on use" variable to avoid calling out when possible
-SKOPEO_CIDEV_CONTAINER_FQIN ?= $(shell hack/get_fqin.sh)
-CONTAINER_CMD ?= ${CONTAINER_RUNTIME} run --rm -i -e TESTFLAGS="$(TESTFLAGS)" -e CI=$(CI) -e SKOPEO_CONTAINER_TESTS=1
+IMAGE := skopeo-dev$(if $(GIT_BRANCH),:$(GIT_BRANCH))
+# set env like gobuildtag?
+CONTAINER_CMD := ${CONTAINER_RUNTIME} run --rm -i -e TESTFLAGS="$(TESTFLAGS)" #$(CONTAINER_ENVS)
 # if this session isn't interactive, then we don't want to allocate a
 # TTY, which would fail, but if it is interactive, we do want to attach
 # so that the user can send e.g. ^C through.
@@ -85,8 +63,7 @@ INTERACTIVE := $(shell [ -t 0 ] && echo 1 || echo 0)
 ifeq ($(INTERACTIVE), 1)
 	CONTAINER_CMD += -t
 endif
-CONTAINER_GOSRC = /src/github.com/containers/skopeo
-CONTAINER_RUN ?= $(CONTAINER_CMD) --security-opt label=disable -v $(CURDIR):$(CONTAINER_GOSRC) -w $(CONTAINER_GOSRC) $(SKOPEO_CIDEV_CONTAINER_FQIN)
+CONTAINER_RUN := $(CONTAINER_CMD) "$(IMAGE)"
 
 GIT_COMMIT := $(shell git rev-parse HEAD 2> /dev/null || true)
 
@@ -98,8 +75,7 @@ MANPAGES ?= $(MANPAGES_MD:%.md=%)
 
 BTRFS_BUILD_TAG = $(shell hack/btrfs_tag.sh) $(shell hack/btrfs_installed_tag.sh)
 LIBDM_BUILD_TAG = $(shell hack/libdm_tag.sh)
-LIBSUBID_BUILD_TAG = $(shell hack/libsubid_tag.sh)
-LOCAL_BUILD_TAGS = $(BTRFS_BUILD_TAG) $(LIBDM_BUILD_TAG) $(LIBSUBID_BUILD_TAG)
+LOCAL_BUILD_TAGS = $(BTRFS_BUILD_TAG) $(LIBDM_BUILD_TAG) $(DARWIN_BUILD_TAG)
 BUILDTAGS += $(LOCAL_BUILD_TAGS)
 
 ifeq ($(DISABLE_CGO), 1)
@@ -119,6 +95,7 @@ help:
 	@echo
 	@echo " * 'install' - Install binaries and documents to system locations"
 	@echo " * 'binary' - Build skopeo with a container"
+	@echo " * 'static' - Build statically linked binary"
 	@echo " * 'bin/skopeo' - Build skopeo locally"
 	@echo " * 'test-unit' - Execute unit tests"
 	@echo " * 'test-integration' - Execute integration tests"
@@ -127,9 +104,25 @@ help:
 	@echo " * 'shell' - Run the built image and attach to a shell"
 	@echo " * 'clean' - Clean artifacts"
 
-# Do the build and the output (skopeo) should appear in current dir
+# Build a container image (skopeobuild) that has everything we need to build.
+# Then do the build and the output (skopeo) should appear in current dir
 binary: cmd/skopeo
-	$(CONTAINER_RUN) make bin/skopeo $(if $(DEBUG),DEBUG=$(DEBUG)) BUILDTAGS='$(BUILDTAGS)'
+	${CONTAINER_RUNTIME} build ${BUILD_ARGS} -f Dockerfile.build -t skopeobuildimage .
+	${CONTAINER_RUNTIME} run --rm --security-opt label=disable -v $$(pwd):/src/github.com/containers/skopeo \
+		skopeobuildimage make bin/skopeo $(if $(DEBUG),DEBUG=$(DEBUG)) BUILDTAGS='$(BUILDTAGS)'
+
+# Update nix/nixpkgs.json its latest stable commit
+.PHONY: nixpkgs
+nixpkgs:
+	@nix run -f channel:nixos-20.09 nix-prefetch-git -c nix-prefetch-git \
+		--no-deepClone https://github.com/nixos/nixpkgs > nix/nixpkgs.json
+
+# Build statically linked binary
+.PHONY: static
+static:
+	@nix build -f nix/
+	mkdir -p ./bin
+	cp -rfp ./result/bin/* ./bin/
 
 # Build w/o using containers
 .PHONY: bin/skopeo
@@ -139,91 +132,75 @@ bin/skopeo.%:
 	GOOS=$(word 2,$(subst ., ,$@)) GOARCH=$(word 3,$(subst ., ,$@)) $(GO) build $(MOD_VENDOR) ${SKOPEO_LDFLAGS} -tags "containers_image_openpgp $(BUILDTAGS)" -o $@ ./cmd/skopeo
 local-cross: bin/skopeo.darwin.amd64 bin/skopeo.linux.arm bin/skopeo.linux.arm64 bin/skopeo.windows.386.exe bin/skopeo.windows.amd64.exe
 
+build-container:
+	${CONTAINER_RUNTIME} build ${BUILD_ARGS} -t "$(IMAGE)" .
+
 $(MANPAGES): %: %.md
-ifneq ($(DISABLE_DOCS), 1)
 	sed -e 's/\((skopeo.*\.md)\)//' -e 's/\[\(skopeo.*\)\]/\1/' $<  | $(GOMD2MAN) -in /dev/stdin -out $@
-endif
 
 docs: $(MANPAGES)
 
 docs-in-container:
-	${CONTAINER_RUN} $(MAKE) docs $(if $(DEBUG),DEBUG=$(DEBUG))
+	${CONTAINER_RUNTIME} build ${BUILD_ARGS} -f Dockerfile.build -t skopeobuildimage .
+	${CONTAINER_RUNTIME} run --rm --security-opt label=disable -v $$(pwd):/src/github.com/containers/skopeo \
+		skopeobuildimage make docs $(if $(DEBUG),DEBUG=$(DEBUG)) BUILDTAGS='$(BUILDTAGS)'
 
 clean:
 	rm -rf bin docs/*.1
 
 install: install-binary install-docs install-completions
-	install -d -m 755 ${DESTDIR}${SIGSTOREDIR}
-	install -d -m 755 ${DESTDIR}${CONTAINERSCONFDIR}
-	install -m 644 default-policy.json ${DESTDIR}${CONTAINERSCONFDIR}/policy.json
-	install -d -m 755 ${DESTDIR}${REGISTRIESDDIR}
-	install -m 644 default.yaml ${DESTDIR}${REGISTRIESDDIR}/default.yaml
+	install -d -m 755 ${SIGSTOREDIR}
+	install -d -m 755 ${CONTAINERSSYSCONFIGDIR}
+	install -m 644 default-policy.json ${CONTAINERSSYSCONFIGDIR}/policy.json
+	install -d -m 755 ${REGISTRIESDDIR}
+	install -m 644 default.yaml ${REGISTRIESDDIR}/default.yaml
 
 install-binary: bin/skopeo
-	install -d -m 755 ${DESTDIR}${BINDIR}
-	install -m 755 bin/skopeo ${DESTDIR}${BINDIR}/skopeo
+	install -d -m 755 ${INSTALLDIR}
+	install -m 755 bin/skopeo ${INSTALLDIR}/skopeo
 
 install-docs: docs
-ifneq ($(DISABLE_DOCS), 1)
-	install -d -m 755 ${DESTDIR}${MANDIR}/man1
-	install -m 644 docs/*.1 ${DESTDIR}${MANDIR}/man1
-endif
+	install -d -m 755 ${MANINSTALLDIR}/man1
+	install -m 644 docs/*.1 ${MANINSTALLDIR}/man1/
 
 install-completions:
-	install -m 755 -d ${DESTDIR}${BASHCOMPLETIONSDIR}
-	install -m 644 completions/bash/skopeo ${DESTDIR}${BASHCOMPLETIONSDIR}/skopeo
+	install -m 755 -d ${BASHINSTALLDIR}
+	install -m 644 completions/bash/skopeo ${BASHINSTALLDIR}/skopeo
 
-shell:
+shell: build-container
 	$(CONTAINER_RUN) bash
 
 check: validate test-unit test-integration test-system
 
-test-integration:
-	$(CONTAINER_RUN) $(MAKE) test-integration-local
-
-
-# Intended for CI, assumed to be running in quay.io/libpod/skopeo_cidev container.
-test-integration-local: bin/skopeo
-	hack/make.sh test-integration
+# The tests can run out of entropy and block in containers, so replace /dev/random.
+test-integration: build-container
+	$(CONTAINER_RUN) bash -c 'rm -f /dev/random; ln -sf /dev/urandom /dev/random; SKOPEO_CONTAINER_TESTS=1 BUILDTAGS="$(BUILDTAGS)" hack/make.sh test-integration'
 
 # complicated set of options needed to run podman-in-podman
-# TODO: The $(RM) command will likely fail w/o `podman unshare`
-test-system:
+test-system: build-container
 	DTEMP=$(shell mktemp -d --tmpdir=/var/tmp podman-tmp.XXXXXX); \
 	$(CONTAINER_CMD) --privileged \
-		-v $(CURDIR):$(CONTAINER_GOSRC) -w $(CONTAINER_GOSRC) \
-		-v $$DTEMP:/var/lib/containers:Z -v /run/systemd/journal/socket:/run/systemd/journal/socket \
-		"$(SKOPEO_CIDEV_CONTAINER_FQIN)" \
-			$(MAKE) test-system-local; \
+	    -v $$DTEMP:/var/lib/containers:Z -v /run/systemd/journal/socket:/run/systemd/journal/socket \
+            "$(IMAGE)" \
+            bash -c 'BUILDTAGS="$(BUILDTAGS)" hack/make.sh test-system'; \
 	rc=$$?; \
-	-$(RM) -rf $$DTEMP; \
+	$(RM) -rf $$DTEMP; \
 	exit $$rc
 
-# Intended for CI, assumed to already be running in quay.io/libpod/skopeo_cidev container.
-test-system-local: bin/skopeo
-	hack/make.sh test-system
-
-test-unit:
+test-unit: build-container
 	# Just call (make test unit-local) here instead of worrying about environment differences
-	$(CONTAINER_RUN) $(MAKE) test-unit-local
+	$(CONTAINER_RUN) make test-unit-local BUILDTAGS='$(BUILDTAGS)'
 
-validate:
-	$(CONTAINER_RUN) $(MAKE) validate-local
+validate: build-container
+	$(CONTAINER_RUN) hack/make.sh validate-git-marks validate-gofmt validate-lint validate-vet
 
 # This target is only intended for development, e.g. executing it from an IDE. Use (make test) for CI or pre-release testing.
-test-all-local: validate-local validate-docs test-unit-local
+test-all-local: validate-local test-unit-local
 
-.PHONY: validate-local
 validate-local:
-	BUILDTAGS="${BUILDTAGS}" hack/make.sh validate-git-marks validate-gofmt validate-lint validate-vet
+	hack/make.sh validate-git-marks validate-gofmt validate-lint validate-vet
 
-# This invokes bin/skopeo, hence cannot be run as part of validate-local
-.PHONY: validate-docs
-validate-docs:
-	hack/man-page-checker
-	hack/xref-helpmsgs-manpages
-
-test-unit-local: bin/skopeo
+test-unit-local:
 	$(GPGME_ENV) $(GO) test $(MOD_VENDOR) -tags "$(BUILDTAGS)" $$($(GO) list $(MOD_VENDOR) -tags "$(BUILDTAGS)" -e ./... | grep -v '^github\.com/containers/skopeo/\(integration\|vendor/.*\)$$')
 
 vendor:
@@ -232,4 +209,4 @@ vendor:
 	$(GO) mod verify
 
 vendor-in-container:
-	podman run --privileged --rm --env HOME=/root -v $(CURDIR):/src -w /src quay.io/libpod/golang:1.16 $(MAKE) vendor
+	podman run --privileged --rm --env HOME=/root -v `pwd`:/src -w /src docker.io/library/golang:1.13 make vendor

OWNERS

@@ -1,17 +0,0 @@
-approvers:
-  - mtrmac
-  - lsm5
-  - TomSweeneyRedHat
-  - rhatdan
-  - vrothberg
-reviewers:
-  - ashley-cui
-  - giuseppe
-  - containers/image-maintainers
-  - lsm5
-  - mtrmac
-  - QiWang19
-  - rhatdan
-  - runcom
-  - TomSweeneyRedHat
-  - vrothberg

README.md

@@ -166,11 +166,11 @@ $ skopeo sync --src docker --dest dir registry.example.com/busybox /media/usb
 skopeo uses credentials from the --creds (for skopeo inspect|delete) or --src-creds|--dest-creds (for skopeo copy) flags, if set; otherwise it uses configuration set by skopeo login, podman login, buildah login, or docker login.
 
 ```console
-$ skopeo login --username USER myregistrydomain.com:5000
+$ skopeo login --username USER docker://myregistrydomain.com:5000
 Password:
 $ skopeo inspect docker://myregistrydomain.com:5000/busybox
 {"Tag":"latest","Digest":"sha256:473bb2189d7b913ed7187a33d11e743fdc2f88931122a44d91a301b64419f092","RepoTags":["latest"],"Comment":"","Created":"2016-01-15T18:06:41.282540103Z","ContainerConfig":{"Hostname":"aded96b43f48","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":["/bin/sh","-c","#(nop) CMD [\"sh\"]"],"Image":"9e77fef7a1c9f989988c06620dabc4020c607885b959a2cbd7c2283c91da3e33","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"DockerVersion":"1.8.3","Author":"","Config":{"Hostname":"aded96b43f48","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":["sh"],"Image":"9e77fef7a1c9f989988c06620dabc4020c607885b959a2cbd7c2283c91da3e33","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"Architecture":"amd64","Os":"linux"}
-$ skopeo logout myregistrydomain.com:5000
+$ skopeo logout docker://myregistrydomain.com:5000
 ```
 
 #### Using --creds directly

SECURITY.md

@@ -1,3 +1,3 @@
 ## Security and Disclosure Information Policy for the skopeo Project
 
-The skopeo Project follows the [Security and Disclosure Information Policy](https://github.com/containers/common/blob/main/SECURITY.md) for the Containers Projects.
+The skopeo Project follows the [Security and Disclosure Information Policy](https://github.com/containers/common/blob/master/SECURITY.md) for the Containers Projects.

cmd/skopeo/cgo_pthread_ordering_workaround.go

@@ -1,4 +1,3 @@
-//go:build !containers_image_openpgp
 // +build !containers_image_openpgp
 
 package main

cmd/skopeo/copy.go

@@ -4,50 +4,46 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"strings"
 
-	commonFlag "github.com/containers/common/pkg/flag"
 	"github.com/containers/common/pkg/retry"
 	"github.com/containers/image/v5/copy"
 	"github.com/containers/image/v5/docker/reference"
 	"github.com/containers/image/v5/manifest"
 	"github.com/containers/image/v5/transports"
 	"github.com/containers/image/v5/transports/alltransports"
+	"github.com/spf13/cobra"
+
 	encconfig "github.com/containers/ocicrypt/config"
 	enchelpers "github.com/containers/ocicrypt/helpers"
-	"github.com/spf13/cobra"
+	imgspecv1 "github.com/opencontainers/image-spec/specs-go/v1"
 )
 
 type copyOptions struct {
-	global              *globalOptions
-	deprecatedTLSVerify *deprecatedTLSVerifyOption
-	srcImage            *imageOptions
-	destImage           *imageDestOptions
-	retryOpts           *retry.RetryOptions
-	additionalTags      []string                  // For docker-archive: destinations, in addition to the name:tag specified as destination, also add these
-	removeSignatures    bool                      // Do not copy signatures from the source image
-	signByFingerprint   string                    // Sign the image using a GPG key with the specified fingerprint
-	digestFile          string                    // Write digest to this file
-	format              commonFlag.OptionalString // Force conversion of the image to a specified format
-	quiet               bool                      // Suppress output information when copying images
-	all                 bool                      // Copy all of the images if the source is a list
-	encryptLayer        []int                     // The list of layers to encrypt
-	encryptionKeys      []string                  // Keys needed to encrypt the image
-	decryptionKeys      []string                  // Keys needed to decrypt the image
+	global            *globalOptions
+	srcImage          *imageOptions
+	destImage         *imageDestOptions
+	retryOpts         *retry.RetryOptions
+	additionalTags    []string       // For docker-archive: destinations, in addition to the name:tag specified as destination, also add these
+	removeSignatures  bool           // Do not copy signatures from the source image
+	signByFingerprint string         // Sign the image using a GPG key with the specified fingerprint
+	format            optionalString // Force conversion of the image to a specified format
+	quiet             bool           // Suppress output information when copying images
+	all               bool           // Copy all of the images if the source is a list
+	encryptLayer      []int          // The list of layers to encrypt
+	encryptionKeys    []string       // Keys needed to encrypt the image
+	decryptionKeys    []string       // Keys needed to decrypt the image
 }
 
 func copyCmd(global *globalOptions) *cobra.Command {
 	sharedFlags, sharedOpts := sharedImageFlags()
-	deprecatedTLSVerifyFlags, deprecatedTLSVerifyOpt := deprecatedTLSVerifyFlags()
-	srcFlags, srcOpts := imageFlags(global, sharedOpts, deprecatedTLSVerifyOpt, "src-", "screds")
-	destFlags, destOpts := imageDestFlags(global, sharedOpts, deprecatedTLSVerifyOpt, "dest-", "dcreds")
+	srcFlags, srcOpts := imageFlags(global, sharedOpts, "src-", "screds")
+	destFlags, destOpts := imageDestFlags(global, sharedOpts, "dest-", "dcreds")
 	retryFlags, retryOpts := retryFlags()
 	opts := copyOptions{global: global,
-		deprecatedTLSVerify: deprecatedTLSVerifyOpt,
-		srcImage:            srcOpts,
-		destImage:           destOpts,
-		retryOpts:           retryOpts,
+		srcImage:  srcOpts,
+		destImage: destOpts,
+		retryOpts: retryOpts,
 	}
 	cmd := &cobra.Command{
 		Use:   "copy [command options] SOURCE-IMAGE DESTINATION-IMAGE",
@@ -65,7 +61,6 @@ See skopeo(1) section "IMAGE NAMES" for the expected format
 	adjustUsage(cmd)
 	flags := cmd.Flags()
 	flags.AddFlagSet(&sharedFlags)
-	flags.AddFlagSet(&deprecatedTLSVerifyFlags)
 	flags.AddFlagSet(&srcFlags)
 	flags.AddFlagSet(&destFlags)
 	flags.AddFlagSet(&retryFlags)
@@ -74,8 +69,7 @@ See skopeo(1) section "IMAGE NAMES" for the expected format
 	flags.BoolVarP(&opts.all, "all", "a", false, "Copy all images if SOURCE-IMAGE is a list")
 	flags.BoolVar(&opts.removeSignatures, "remove-signatures", false, "Do not copy signatures from SOURCE-IMAGE")
 	flags.StringVar(&opts.signByFingerprint, "sign-by", "", "Sign the image using a GPG key with the specified `FINGERPRINT`")
-	flags.StringVar(&opts.digestFile, "digestfile", "", "Write the digest of the pushed image to the specified file")
-	flags.VarP(commonFlag.NewOptionalStringValue(&opts.format), "format", "f", `MANIFEST TYPE (oci, v2s1, or v2s2) to use in the destination (default is manifest type of source, with fallbacks)`)
+	flags.VarP(newOptionalStringValue(&opts.format), "format", "f", `MANIFEST TYPE (oci, v2s1, or v2s2) to use when saving image to directory using the 'dir:' transport (default is manifest type of source)`)
 	flags.StringSliceVar(&opts.encryptionKeys, "encryption-key", []string{}, "*Experimental* key with the encryption protocol to use needed to encrypt the image (e.g. jwe:/path/to/key.pem)")
 	flags.IntSliceVar(&opts.encryptLayer, "encrypt-layer", []int{}, "*Experimental* the 0-indexed layer indices, with support for negative indexing (e.g. 0 is the first layer, -1 is the last layer)")
 	flags.StringSliceVar(&opts.decryptionKeys, "decryption-key", []string{}, "*Experimental* key needed to decrypt the image")
@@ -86,7 +80,6 @@ func (opts *copyOptions) run(args []string, stdout io.Writer) error {
 	if len(args) != 2 {
 		return errorShouldDisplayUsage{errors.New("Exactly two arguments expected")}
 	}
-	opts.deprecatedTLSVerify.warnIfUsed([]string{"--src-tls-verify", "--dest-tls-verify"})
 	imageNames := args
 
 	if err := reexecIfNecessaryForImages(imageNames...); err != nil {
@@ -118,10 +111,16 @@ func (opts *copyOptions) run(args []string, stdout io.Writer) error {
 	}
 
 	var manifestType string
-	if opts.format.Present() {
-		manifestType, err = parseManifestFormat(opts.format.Value())
-		if err != nil {
-			return err
+	if opts.format.present {
+		switch opts.format.value {
+		case "oci":
+			manifestType = imgspecv1.MediaTypeImageManifest
+		case "v2s1":
+			manifestType = manifest.DockerV2Schema1SignedMediaType
+		case "v2s2":
+			manifestType = manifest.DockerV2Schema2MediaType
+		default:
+			return fmt.Errorf("unknown format %q. Choose one of the supported formats: 'oci', 'v2s1', or 'v2s2'", opts.format.value)
 		}
 	}
 
@@ -185,7 +184,7 @@ func (opts *copyOptions) run(args []string, stdout io.Writer) error {
 	}
 
 	return retry.RetryIfNecessary(ctx, func() error {
-		manifestBytes, err := copy.Image(ctx, policyContext, destRef, srcRef, &copy.Options{
+		_, err = copy.Image(ctx, policyContext, destRef, srcRef, &copy.Options{
 			RemoveSignatures:      opts.removeSignatures,
 			SignBy:                opts.signByFingerprint,
 			ReportWriter:          stdout,
@@ -197,18 +196,6 @@ func (opts *copyOptions) run(args []string, stdout io.Writer) error {
 			OciEncryptLayers:      encLayers,
 			OciEncryptConfig:      encConfig,
 		})
-		if err != nil {
-			return err
-		}
-		if opts.digestFile != "" {
-			manifestDigest, err := manifest.Digest(manifestBytes)
-			if err != nil {
-				return err
-			}
-			if err = ioutil.WriteFile(opts.digestFile, []byte(manifestDigest.String()), 0644); err != nil {
-				return fmt.Errorf("Failed to write digest to file %q: %w", opts.digestFile, err)
-			}
-		}
-		return nil
+		return err
 	}, opts.retryOpts)
 }

cmd/skopeo/delete.go

@@ -20,7 +20,7 @@ type deleteOptions struct {
 
 func deleteCmd(global *globalOptions) *cobra.Command {
 	sharedFlags, sharedOpts := sharedImageFlags()
-	imageFlags, imageOpts := imageFlags(global, sharedOpts, nil, "", "")
+	imageFlags, imageOpts := imageFlags(global, sharedOpts, "", "")
 	retryFlags, retryOpts := retryFlags()
 	opts := deleteOptions{
 		global:    global,

cmd/skopeo/flag.go

@@ -1,4 +1,4 @@
-package flag
+package main
 
 import (
 	"strconv"
@@ -6,45 +6,31 @@ import (
 	"github.com/spf13/pflag"
 )
 
-// OptionalBool is a boolean with a separate presence flag and value.
-type OptionalBool struct {
+// optionalBool is a boolean with a separate presence flag.
+type optionalBool struct {
 	present bool
 	value   bool
 }
 
-// Present returns the bool's presence flag.
-func (ob *OptionalBool) Present() bool {
-	return ob.present
-}
-
-// Present returns the bool's value. Should only be used if Present() is true.
-func (ob *OptionalBool) Value() bool {
-	return ob.value
-}
-
 // optionalBool is a cli.Generic == flag.Value implementation equivalent to
 // the one underlying flag.Bool, except that it records whether the flag has been set.
 // This is distinct from optionalBool to (pretend to) force callers to use
 // optionalBoolFlag
-type optionalBoolValue OptionalBool
+type optionalBoolValue optionalBool
 
-// OptionalBoolFlag creates new flag for an optional in the specified flag with
-// the specified name and usage.
-func OptionalBoolFlag(fs *pflag.FlagSet, p *OptionalBool, name, usage string) *pflag.Flag {
+func optionalBoolFlag(fs *pflag.FlagSet, p *optionalBool, name, usage string) *pflag.Flag {
 	flag := fs.VarPF(internalNewOptionalBoolValue(p), name, "", usage)
 	flag.NoOptDefVal = "true"
-	flag.DefValue = "false"
 	return flag
 }
 
 // WARNING: Do not directly use this method to define optionalBool flag.
 // Caller should use optionalBoolFlag
-func internalNewOptionalBoolValue(p *OptionalBool) pflag.Value {
+func internalNewOptionalBoolValue(p *optionalBool) pflag.Value {
 	p.present = false
 	return (*optionalBoolValue)(p)
 }
 
-// Set parses the string to a bool and sets it.
 func (ob *optionalBoolValue) Set(s string) error {
 	v, err := strconv.ParseBool(s)
 	if err != nil {
@@ -55,7 +41,6 @@ func (ob *optionalBoolValue) Set(s string) error {
 	return nil
 }
 
-// String returns the string representation of the string.
 func (ob *optionalBoolValue) String() string {
 	if !ob.present {
 		return "" // This is, sadly, not round-trip safe: --flag is interpreted as --flag=true
@@ -63,52 +48,37 @@ func (ob *optionalBoolValue) String() string {
 	return strconv.FormatBool(ob.value)
 }
 
-// Type returns the type.
 func (ob *optionalBoolValue) Type() string {
 	return "bool"
 }
 
-// IsBoolFlag indicates that it's a bool flag.
 func (ob *optionalBoolValue) IsBoolFlag() bool {
 	return true
 }
 
-// OptionalString is a string with a separate presence flag.
-type OptionalString struct {
+// optionalString is a string with a separate presence flag.
+type optionalString struct {
 	present bool
 	value   string
 }
 
-// Present returns the strings's presence flag.
-func (os *OptionalString) Present() bool {
-	return os.present
-}
-
-// Present returns the string's value. Should only be used if Present() is true.
-func (os *OptionalString) Value() string {
-	return os.value
-}
-
 // optionalString is a cli.Generic == flag.Value implementation equivalent to
 // the one underlying flag.String, except that it records whether the flag has been set.
 // This is distinct from optionalString to (pretend to) force callers to use
 // newoptionalString
-type optionalStringValue OptionalString
+type optionalStringValue optionalString
 
-// NewOptionalStringValue returns a pflag.Value fo the string.
-func NewOptionalStringValue(p *OptionalString) pflag.Value {
+func newOptionalStringValue(p *optionalString) pflag.Value {
 	p.present = false
 	return (*optionalStringValue)(p)
 }
 
-// Set sets the string.
 func (ob *optionalStringValue) Set(s string) error {
 	ob.value = s
 	ob.present = true
 	return nil
 }
 
-// String returns the string if present.
 func (ob *optionalStringValue) String() string {
 	if !ob.present {
 		return "" // This is, sadly, not round-trip safe: --flag= is interpreted as {present:true, value:""}
@@ -116,40 +86,27 @@ func (ob *optionalStringValue) String() string {
 	return ob.value
 }
 
-// Type returns the string type.
 func (ob *optionalStringValue) Type() string {
 	return "string"
 }
 
-// OptionalInt is a int with a separate presence flag.
-type OptionalInt struct {
+// optionalInt is a int with a separate presence flag.
+type optionalInt struct {
 	present bool
 	value   int
 }
 
-// Present returns the int's presence flag.
-func (oi *OptionalInt) Present() bool {
-	return oi.present
-}
-
-// Present returns the int's value. Should only be used if Present() is true.
-func (oi *OptionalInt) Value() int {
-	return oi.value
-}
-
 // optionalInt is a cli.Generic == flag.Value implementation equivalent to
 // the one underlying flag.Int, except that it records whether the flag has been set.
 // This is distinct from optionalInt to (pretend to) force callers to use
 // newoptionalIntValue
-type optionalIntValue OptionalInt
+type optionalIntValue optionalInt
 
-// NewOptionalIntValue returns the pflag.Value of the int.
-func NewOptionalIntValue(p *OptionalInt) pflag.Value {
+func newOptionalIntValue(p *optionalInt) pflag.Value {
 	p.present = false
 	return (*optionalIntValue)(p)
 }
 
-// Set parses the string to an int and sets it.
 func (ob *optionalIntValue) Set(s string) error {
 	v, err := strconv.ParseInt(s, 0, strconv.IntSize)
 	if err != nil {
@@ -160,7 +117,6 @@ func (ob *optionalIntValue) Set(s string) error {
 	return nil
 }
 
-// String returns the string representation of the int.
 func (ob *optionalIntValue) String() string {
 	if !ob.present {
 		return "" // If the value is not present, just return an empty string, any other value wouldn't make sense.
@@ -168,7 +124,6 @@ func (ob *optionalIntValue) String() string {
 	return strconv.Itoa(int(ob.value))
 }
 
-// Type returns the int's type.
 func (ob *optionalIntValue) Type() string {
 	return "int"
 }

cmd/skopeo/flag_test.go

@@ -0,0 +1,222 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestOptionalBoolSet(t *testing.T) {
+	for _, c := range []struct {
+		input    string
+		accepted bool
+		value    bool
+	}{
+		// Valid inputs documented for strconv.ParseBool == flag.BoolVar
+		{"1", true, true},
+		{"t", true, true},
+		{"T", true, true},
+		{"TRUE", true, true},
+		{"true", true, true},
+		{"True", true, true},
+		{"0", true, false},
+		{"f", true, false},
+		{"F", true, false},
+		{"FALSE", true, false},
+		{"false", true, false},
+		{"False", true, false},
+		// A few invalid inputs
+		{"", false, false},
+		{"yes", false, false},
+		{"no", false, false},
+		{"2", false, false},
+	} {
+		var ob optionalBool
+		v := internalNewOptionalBoolValue(&ob)
+		require.False(t, ob.present)
+		err := v.Set(c.input)
+		if c.accepted {
+			assert.NoError(t, err, c.input)
+			assert.Equal(t, c.value, ob.value)
+		} else {
+			assert.Error(t, err, c.input)
+			assert.False(t, ob.present) // Just to be extra paranoid.
+		}
+	}
+
+	// Nothing actually explicitly says that .Set() is never called when the flag is not present on the command line;
+	// so, check that it is not being called, at least in the straightforward case (it's not possible to test that it
+	// is not called in any possible situation).
+	var globalOB, commandOB optionalBool
+	actionRun := false
+	app := &cobra.Command{
+		Use: "app",
+	}
+	optionalBoolFlag(app.PersistentFlags(), &globalOB, "global-OB", "")
+	cmd := &cobra.Command{
+		Use: "cmd",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			assert.False(t, globalOB.present)
+			assert.False(t, commandOB.present)
+			actionRun = true
+			return nil
+		},
+	}
+	optionalBoolFlag(cmd.Flags(), &commandOB, "command-OB", "")
+	app.AddCommand(cmd)
+	app.SetArgs([]string{"cmd"})
+	err := app.Execute()
+	require.NoError(t, err)
+	assert.True(t, actionRun)
+}
+
+func TestOptionalBoolString(t *testing.T) {
+	for _, c := range []struct {
+		input    optionalBool
+		expected string
+	}{
+		{optionalBool{present: true, value: true}, "true"},
+		{optionalBool{present: true, value: false}, "false"},
+		{optionalBool{present: false, value: true}, ""},
+		{optionalBool{present: false, value: false}, ""},
+	} {
+		var ob optionalBool
+		v := internalNewOptionalBoolValue(&ob)
+		ob = c.input
+		res := v.String()
+		assert.Equal(t, c.expected, res)
+	}
+}
+
+func TestOptionalBoolIsBoolFlag(t *testing.T) {
+	// IsBoolFlag means that the argument value must either be part of the same argument, with =;
+	// if there is no =, the value is set to true.
+	// This differs form other flags, where the argument is required and may be either separated with = or supplied in the next argument.
+	for _, c := range []struct {
+		input        []string
+		expectedOB   optionalBool
+		expectedArgs []string
+	}{
+		{[]string{"1", "2"}, optionalBool{present: false}, []string{"1", "2"}},                                       // Flag not present
+		{[]string{"--OB=true", "1", "2"}, optionalBool{present: true, value: true}, []string{"1", "2"}},              // --OB=true
+		{[]string{"--OB=false", "1", "2"}, optionalBool{present: true, value: false}, []string{"1", "2"}},            // --OB=false
+		{[]string{"--OB", "true", "1", "2"}, optionalBool{present: true, value: true}, []string{"true", "1", "2"}},   // --OB true
+		{[]string{"--OB", "false", "1", "2"}, optionalBool{present: true, value: true}, []string{"false", "1", "2"}}, // --OB false
+	} {
+		var ob optionalBool
+		actionRun := false
+		app := &cobra.Command{Use: "app"}
+		cmd := &cobra.Command{
+			Use: "cmd",
+			RunE: func(cmd *cobra.Command, args []string) error {
+				assert.Equal(t, c.expectedOB, ob)
+				assert.Equal(t, c.expectedArgs, args)
+				actionRun = true
+				return nil
+			},
+		}
+		optionalBoolFlag(cmd.Flags(), &ob, "OB", "")
+		app.AddCommand(cmd)
+
+		app.SetArgs(append([]string{"cmd"}, c.input...))
+		err := app.Execute()
+		require.NoError(t, err)
+		assert.True(t, actionRun)
+	}
+}
+
+func TestOptionalStringSet(t *testing.T) {
+	// Really just a smoke test, but differentiating between not present and empty.
+	for _, c := range []string{"", "hello"} {
+		var os optionalString
+		v := newOptionalStringValue(&os)
+		require.False(t, os.present)
+		err := v.Set(c)
+		assert.NoError(t, err, c)
+		assert.Equal(t, c, os.value)
+	}
+
+	// Nothing actually explicitly says that .Set() is never called when the flag is not present on the command line;
+	// so, check that it is not being called, at least in the straightforward case (it's not possible to test that it
+	// is not called in any possible situation).
+	var globalOS, commandOS optionalString
+	actionRun := false
+	app := &cobra.Command{
+		Use: "app",
+	}
+	app.PersistentFlags().Var(newOptionalStringValue(&globalOS), "global-OS", "")
+	cmd := &cobra.Command{
+		Use: "cmd",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			assert.False(t, globalOS.present)
+			assert.False(t, commandOS.present)
+			actionRun = true
+			return nil
+		},
+	}
+	cmd.Flags().Var(newOptionalStringValue(&commandOS), "command-OS", "")
+	app.AddCommand(cmd)
+	app.SetArgs([]string{"cmd"})
+	err := app.Execute()
+	require.NoError(t, err)
+	assert.True(t, actionRun)
+}
+
+func TestOptionalStringString(t *testing.T) {
+	for _, c := range []struct {
+		input    optionalString
+		expected string
+	}{
+		{optionalString{present: true, value: "hello"}, "hello"},
+		{optionalString{present: true, value: ""}, ""},
+		{optionalString{present: false, value: "hello"}, ""},
+		{optionalString{present: false, value: ""}, ""},
+	} {
+		var os optionalString
+		v := newOptionalStringValue(&os)
+		os = c.input
+		res := v.String()
+		assert.Equal(t, c.expected, res)
+	}
+}
+
+func TestOptionalStringIsBoolFlag(t *testing.T) {
+	// NOTE: optionalStringValue does not implement IsBoolFlag!
+	// IsBoolFlag means that the argument value must either be part of the same argument, with =;
+	// if there is no =, the value is set to true.
+	// This differs form other flags, where the argument is required and may be either separated with = or supplied in the next argument.
+	for _, c := range []struct {
+		input        []string
+		expectedOS   optionalString
+		expectedArgs []string
+	}{
+		{[]string{"1", "2"}, optionalString{present: false}, []string{"1", "2"}},                                 // Flag not present
+		{[]string{"--OS=hello", "1", "2"}, optionalString{present: true, value: "hello"}, []string{"1", "2"}},    // --OS=true
+		{[]string{"--OS=", "1", "2"}, optionalString{present: true, value: ""}, []string{"1", "2"}},              // --OS=false
+		{[]string{"--OS", "hello", "1", "2"}, optionalString{present: true, value: "hello"}, []string{"1", "2"}}, // --OS true
+		{[]string{"--OS", "", "1", "2"}, optionalString{present: true, value: ""}, []string{"1", "2"}},           // --OS false
+	} {
+		var os optionalString
+		actionRun := false
+		app := &cobra.Command{
+			Use: "app",
+		}
+		cmd := &cobra.Command{
+			Use: "cmd",
+			RunE: func(cmd *cobra.Command, args []string) error {
+				assert.Equal(t, c.expectedOS, os)
+				assert.Equal(t, c.expectedArgs, args)
+				actionRun = true
+				return nil
+			},
+		}
+		cmd.Flags().Var(newOptionalStringValue(&os), "OS", "")
+		app.AddCommand(cmd)
+		app.SetArgs(append([]string{"cmd"}, c.input...))
+		err := app.Execute()
+		require.NoError(t, err)
+		assert.True(t, actionRun)
+	}
+}

cmd/skopeo/inspect.go

@@ -24,18 +24,17 @@ import (
 )
 
 type inspectOptions struct {
-	global        *globalOptions
-	image         *imageOptions
-	retryOpts     *retry.RetryOptions
-	format        string
-	raw           bool // Output the raw manifest instead of parsing information about the image
-	config        bool // Output the raw config blob instead of parsing information about the image
-	doNotListTags bool // Do not list all tags available in the same repository
+	global    *globalOptions
+	image     *imageOptions
+	retryOpts *retry.RetryOptions
+	format    string
+	raw       bool // Output the raw manifest instead of parsing information about the image
+	config    bool // Output the raw config blob instead of parsing information about the image
 }
 
 func inspectCmd(global *globalOptions) *cobra.Command {
 	sharedFlags, sharedOpts := sharedImageFlags()
-	imageFlags, imageOpts := imageFlags(global, sharedOpts, nil, "", "")
+	imageFlags, imageOpts := imageFlags(global, sharedOpts, "", "")
 	retryFlags, retryOpts := retryFlags()
 	opts := inspectOptions{
 		global:    global,
@@ -61,7 +60,6 @@ See skopeo(1) section "IMAGE NAMES" for the expected format
 	flags.BoolVar(&opts.raw, "raw", false, "output raw manifest or configuration")
 	flags.BoolVar(&opts.config, "config", false, "output configuration")
 	flags.StringVarP(&opts.format, "format", "f", "", "Format the output to a Go template")
-	flags.BoolVarP(&opts.doNotListTags, "no-tags", "n", false, "Do not list the available tags from the repository in the output")
 	flags.AddFlagSet(&sharedFlags)
 	flags.AddFlagSet(&imageFlags)
 	flags.AddFlagSet(&retryFlags)
@@ -194,7 +192,7 @@ func (opts *inspectOptions) run(args []string, stdout io.Writer) (retErr error)
 	if dockerRef := img.Reference().DockerReference(); dockerRef != nil {
 		outputData.Name = dockerRef.Name()
 	}
-	if !opts.doNotListTags && img.Reference().Transport() == docker.Transport {
+	if img.Reference().Transport() == docker.Transport {
 		sys, err := opts.image.newSystemContext()
 		if err != nil {
 			return err
@@ -224,6 +222,13 @@ func (opts *inspectOptions) run(args []string, stdout io.Writer) (retErr error)
 	return printTmpl(row, data)
 }
 
+func inspectNormalize(row string) string {
+	r := strings.NewReplacer(
+		".ImageID", ".Image",
+	)
+	return r.Replace(row)
+}
+
 func printTmpl(row string, data []interface{}) error {
 	t, err := template.New("skopeo inspect").Parse(row)
 	if err != nil {

cmd/skopeo/layers.go

@@ -25,7 +25,7 @@ type layersOptions struct {
 
 func layersCmd(global *globalOptions) *cobra.Command {
 	sharedFlags, sharedOpts := sharedImageFlags()
-	imageFlags, imageOpts := imageFlags(global, sharedOpts, nil, "", "")
+	imageFlags, imageOpts := imageFlags(global, sharedOpts, "", "")
 	retryFlags, retryOpts := retryFlags()
 	opts := layersOptions{
 		global:    global,

cmd/skopeo/list_tags.go

@@ -30,7 +30,7 @@ type tagsOptions struct {
 
 func tagsCmd(global *globalOptions) *cobra.Command {
 	sharedFlags, sharedOpts := sharedImageFlags()
-	imageFlags, imageOpts := dockerImageFlags(global, sharedOpts, nil, "", "")
+	imageFlags, imageOpts := dockerImageFlags(global, sharedOpts, "", "")
 	retryFlags, retryOpts := retryFlags()
 
 	opts := tagsOptions{

cmd/skopeo/list_tags_test.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/containers/image/v5/transports/alltransports"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 // Tests the kinds of inputs allowed and expected to the command
@@ -18,10 +17,10 @@ func TestDockerRepositoryReferenceParser(t *testing.T) {
 	} {
 
 		ref, err := parseDockerRepositoryReference(test[0])
-		require.NoError(t, err)
 		expected, err := alltransports.ParseImageName(test[0])
-		require.NoError(t, err)
-		assert.Equal(t, expected.DockerReference().Name(), ref.DockerReference().Name(), "Mismatched parse result for input %v", test[0])
+		if assert.NoError(t, err, "Could not parse, got error on %v", test[0]) {
+			assert.Equal(t, expected.DockerReference().Name(), ref.DockerReference().Name(), "Mismatched parse result for input %v", test[0])
+		}
 	}
 
 	for _, test := range [][]string{

cmd/skopeo/login.go

@@ -5,7 +5,6 @@ import (
 	"os"
 
 	"github.com/containers/common/pkg/auth"
-	commonFlag "github.com/containers/common/pkg/flag"
 	"github.com/containers/image/v5/types"
 	"github.com/spf13/cobra"
 )
@@ -13,7 +12,8 @@ import (
 type loginOptions struct {
 	global    *globalOptions
 	loginOpts auth.LoginOptions
-	tlsVerify commonFlag.OptionalBool
+	getLogin  optionalBool
+	tlsVerify optionalBool
 }
 
 func loginCmd(global *globalOptions) *cobra.Command {
@@ -21,7 +21,7 @@ func loginCmd(global *globalOptions) *cobra.Command {
 		global: global,
 	}
 	cmd := &cobra.Command{
-		Use:     "login [command options] REGISTRY",
+		Use:     "login",
 		Short:   "Login to a container registry",
 		Long:    "Login to a container registry on a specified server.",
 		RunE:    commandAction(opts.run),
@@ -29,7 +29,7 @@ func loginCmd(global *globalOptions) *cobra.Command {
 	}
 	adjustUsage(cmd)
 	flags := cmd.Flags()
-	commonFlag.OptionalBoolFlag(flags, &opts.tlsVerify, "tls-verify", "require HTTPS and verify certificates when accessing the registry")
+	optionalBoolFlag(flags, &opts.tlsVerify, "tls-verify", "require HTTPS and verify certificates when accessing the registry")
 	flags.AddFlagSet(auth.GetLoginFlags(&opts.loginOpts))
 	return cmd
 }
@@ -39,10 +39,9 @@ func (opts *loginOptions) run(args []string, stdout io.Writer) error {
 	defer cancel()
 	opts.loginOpts.Stdout = stdout
 	opts.loginOpts.Stdin = os.Stdin
-	opts.loginOpts.AcceptRepositories = true
 	sys := opts.global.newSystemContext()
-	if opts.tlsVerify.Present() {
-		sys.DockerInsecureSkipTLSVerify = types.NewOptionalBool(!opts.tlsVerify.Value())
+	if opts.tlsVerify.present {
+		sys.DockerInsecureSkipTLSVerify = types.NewOptionalBool(!opts.tlsVerify.value)
 	}
 	return auth.Login(ctx, sys, &opts.loginOpts, args)
 }

cmd/skopeo/logout.go

@@ -4,15 +4,12 @@ import (
 	"io"
 
 	"github.com/containers/common/pkg/auth"
-	commonFlag "github.com/containers/common/pkg/flag"
-	"github.com/containers/image/v5/types"
 	"github.com/spf13/cobra"
 )
 
 type logoutOptions struct {
 	global     *globalOptions
 	logoutOpts auth.LogoutOptions
-	tlsVerify  commonFlag.OptionalBool
 }
 
 func logoutCmd(global *globalOptions) *cobra.Command {
@@ -20,25 +17,19 @@ func logoutCmd(global *globalOptions) *cobra.Command {
 		global: global,
 	}
 	cmd := &cobra.Command{
-		Use:     "logout [command options] REGISTRY",
+		Use:     "logout",
 		Short:   "Logout of a container registry",
 		Long:    "Logout of a container registry on a specified server.",
 		RunE:    commandAction(opts.run),
 		Example: `skopeo logout quay.io`,
 	}
 	adjustUsage(cmd)
-	flags := cmd.Flags()
-	commonFlag.OptionalBoolFlag(flags, &opts.tlsVerify, "tls-verify", "require HTTPS and verify certificates when accessing the registry")
-	flags.AddFlagSet(auth.GetLogoutFlags(&opts.logoutOpts))
+	cmd.Flags().AddFlagSet(auth.GetLogoutFlags(&opts.logoutOpts))
 	return cmd
 }
 
 func (opts *logoutOptions) run(args []string, stdout io.Writer) error {
 	opts.logoutOpts.Stdout = stdout
-	opts.logoutOpts.AcceptRepositories = true
 	sys := opts.global.newSystemContext()
-	if opts.tlsVerify.Present() {
-		sys.DockerInsecureSkipTLSVerify = types.NewOptionalBool(!opts.tlsVerify.Value())
-	}
 	return auth.Logout(sys, &opts.logoutOpts, args)
 }

cmd/skopeo/main.go

@@ -3,10 +3,8 @@ package main
 import (
 	"context"
 	"fmt"
-	"strings"
 	"time"
 
-	commonFlag "github.com/containers/common/pkg/flag"
 	"github.com/containers/image/v5/signature"
 	"github.com/containers/image/v5/types"
 	"github.com/containers/skopeo/version"
@@ -19,35 +17,18 @@ import (
 // and will be populated by the Makefile
 var gitCommit = ""
 
-var defaultUserAgent = "skopeo/" + version.Version
-
 type globalOptions struct {
-	debug              bool                    // Enable debug output
-	tlsVerify          commonFlag.OptionalBool // Require HTTPS and verify certificates (for docker: and docker-daemon:)
-	policyPath         string                  // Path to a signature verification policy file
-	insecurePolicy     bool                    // Use an "allow everything" signature verification policy
-	registriesDirPath  string                  // Path to a "registries.d" registry configuration directory
-	overrideArch       string                  // Architecture to use for choosing images, instead of the runtime one
-	overrideOS         string                  // OS to use for choosing images, instead of the runtime one
-	overrideVariant    string                  // Architecture variant to use for choosing images, instead of the runtime one
-	commandTimeout     time.Duration           // Timeout for the command execution
-	registriesConfPath string                  // Path to the "registries.conf" file
-	tmpDir             string                  // Path to use for big temporary files
-}
-
-// requireSubcommand returns an error if no sub command is provided
-// This was copied from podman: `github.com/containers/podman/cmd/podman/validate/args.go
-// Some small style changes to match skopeo were applied, but try to apply any
-// bugfixes there first.
-func requireSubcommand(cmd *cobra.Command, args []string) error {
-	if len(args) > 0 {
-		suggestions := cmd.SuggestionsFor(args[0])
-		if len(suggestions) == 0 {
-			return fmt.Errorf("Unrecognized command `%[1]s %[2]s`\nTry '%[1]s --help' for more information", cmd.CommandPath(), args[0])
-		}
-		return fmt.Errorf("Unrecognized command `%[1]s %[2]s`\n\nDid you mean this?\n\t%[3]s\n\nTry '%[1]s --help' for more information", cmd.CommandPath(), args[0], strings.Join(suggestions, "\n\t"))
-	}
-	return fmt.Errorf("Missing command '%[1]s COMMAND'\nTry '%[1]s --help' for more information", cmd.CommandPath())
+	debug              bool          // Enable debug output
+	tlsVerify          optionalBool  // Require HTTPS and verify certificates (for docker: and docker-daemon:)
+	policyPath         string        // Path to a signature verification policy file
+	insecurePolicy     bool          // Use an "allow everything" signature verification policy
+	registriesDirPath  string        // Path to a "registries.d" registry configuration directory
+	overrideArch       string        // Architecture to use for choosing images, instead of the runtime one
+	overrideOS         string        // OS to use for choosing images, instead of the runtime one
+	overrideVariant    string        // Architecture variant to use for choosing images, instead of the runtime one
+	commandTimeout     time.Duration // Timeout for the command execution
+	registriesConfPath string        // Path to the "registries.conf" file
+	tmpDir             string        // Path to use for big temporary files
 }
 
 // createApp returns a cobra.Command, and the underlying globalOptions object, to be run or tested.
@@ -57,23 +38,11 @@ func createApp() (*cobra.Command, *globalOptions) {
 	rootCommand := &cobra.Command{
 		Use:  "skopeo",
 		Long: "Various operations with container images and container image registries",
-		RunE: requireSubcommand,
 		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
 			return opts.before(cmd)
 		},
 		SilenceUsage:  true,
 		SilenceErrors: true,
-		// Currently, skopeo uses manually written completions.  Cobra allows
-		// for auto-generating completions for various shells.  Podman is
-		// already making us of that.  If Skopeo decides to follow, please
-		// remove the line below (and hide the `completion` command).
-		CompletionOptions: cobra.CompletionOptions{DisableDefaultCmd: true},
-		// This is documented to parse "local" (non-PersistentFlags) flags of parent commands before
-		// running subcommands and handling their options. We don't really run into such cases,
-		// because all of our flags on rootCommand are in PersistentFlags, except for the deprecated --tls-verify;
-		// in that case we need TraverseChildren so that we can distinguish between
-		// (skopeo --tls-verify inspect) (causes a warning) and (skopeo inspect --tls-verify) (no warning).
-		TraverseChildren: true,
 	}
 	if gitCommit != "" {
 		rootCommand.Version = fmt.Sprintf("%s commit: %s", version.Version, gitCommit)
@@ -84,6 +53,8 @@ func createApp() (*cobra.Command, *globalOptions) {
 	var dummyVersion bool
 	rootCommand.Flags().BoolVarP(&dummyVersion, "version", "v", false, "Version for Skopeo")
 	rootCommand.PersistentFlags().BoolVar(&opts.debug, "debug", false, "enable debug output")
+	flag := optionalBoolFlag(rootCommand.PersistentFlags(), &opts.tlsVerify, "tls-verify", "Require HTTPS and verify certificates when accessing the registry")
+	flag.Hidden = true
 	rootCommand.PersistentFlags().StringVar(&opts.policyPath, "policy", "", "Path to a trust policy file")
 	rootCommand.PersistentFlags().BoolVar(&opts.insecurePolicy, "insecure-policy", false, "run the tool without any policy check")
 	rootCommand.PersistentFlags().StringVar(&opts.registriesDirPath, "registries.d", "", "use registry configuration files in `DIR` (e.g. for container signature storage)")
@@ -96,8 +67,6 @@ func createApp() (*cobra.Command, *globalOptions) {
 		logrus.Fatal("unable to mark registries-conf flag as hidden")
 	}
 	rootCommand.PersistentFlags().StringVar(&opts.tmpDir, "tmpdir", "", "directory used to store temporary files")
-	flag := commonFlag.OptionalBoolFlag(rootCommand.Flags(), &opts.tlsVerify, "tls-verify", "Require HTTPS and verify certificates when accessing the registry")
-	flag.Hidden = true
 	rootCommand.AddCommand(
 		copyCmd(&opts),
 		deleteCmd(&opts),
@@ -106,7 +75,6 @@ func createApp() (*cobra.Command, *globalOptions) {
 		loginCmd(&opts),
 		logoutCmd(&opts),
 		manifestDigestCmd(),
-		proxyCmd(&opts),
 		syncCmd(&opts),
 		standaloneSignCmd(),
 		standaloneVerifyCmd(),
@@ -121,7 +89,7 @@ func (opts *globalOptions) before(cmd *cobra.Command) error {
 	if opts.debug {
 		logrus.SetLevel(logrus.DebugLevel)
 	}
-	if opts.tlsVerify.Present() {
+	if opts.tlsVerify.present {
 		logrus.Warn("'--tls-verify' is deprecated, please set this on the specific subcommand")
 	}
 	return nil
@@ -175,11 +143,10 @@ func (opts *globalOptions) newSystemContext() *types.SystemContext {
 		VariantChoice:            opts.overrideVariant,
 		SystemRegistriesConfPath: opts.registriesConfPath,
 		BigFilesTemporaryDir:     opts.tmpDir,
-		DockerRegistryUserAgent:  defaultUserAgent,
 	}
 	// DEPRECATED: We support this for backward compatibility, but override it if a per-image flag is provided.
-	if opts.tlsVerify.Present() {
-		ctx.DockerInsecureSkipTLSVerify = types.NewOptionalBool(!opts.tlsVerify.Value())
+	if opts.tlsVerify.present {
+		ctx.DockerInsecureSkipTLSVerify = types.NewOptionalBool(!opts.tlsVerify.value)
 	}
 	return ctx
 }

cmd/skopeo/main_test.go

@@ -23,10 +23,7 @@ func TestGlobalOptionsNewSystemContext(t *testing.T) {
 	// Default state
 	opts, _ := fakeGlobalOptions(t, []string{})
 	res := opts.newSystemContext()
-	assert.Equal(t, &types.SystemContext{
-		// User-Agent is set by default.
-		DockerRegistryUserAgent: defaultUserAgent,
-	}, res)
+	assert.Equal(t, &types.SystemContext{}, res)
 	// Set everything to non-default values.
 	opts, _ = fakeGlobalOptions(t, []string{
 		"--registries.d", "/srv/registries.d",
@@ -46,6 +43,5 @@ func TestGlobalOptionsNewSystemContext(t *testing.T) {
 		BigFilesTemporaryDir:        "/srv",
 		SystemRegistriesConfPath:    "/srv/registries.conf",
 		DockerInsecureSkipTLSVerify: types.OptionalBoolTrue,
-		DockerRegistryUserAgent:     defaultUserAgent,
 	}, res)
 }

cmd/skopeo/manifest.go

@@ -16,7 +16,7 @@ type manifestDigestOptions struct {
 func manifestDigestCmd() *cobra.Command {
 	var opts manifestDigestOptions
 	cmd := &cobra.Command{
-		Use:     "manifest-digest MANIFEST-FILE",
+		Use:     "manifest-digest MANIFEST",
 		Short:   "Compute a manifest digest of a file",
 		RunE:    commandAction(opts.run),
 		Example: "skopeo manifest-digest manifest.json",

cmd/skopeo/proxy.go

@@ -1,606 +0,0 @@
-//go:build !windows
-// +build !windows
-
-package main
-
-/*
-  This code is currently only intended to be used by ostree
-  to fetch content via containers.  The API is subject
-  to change.  A goal however is to stabilize the API
-  eventually as a full out-of-process interface to the
-  core containers/image library functionality.
-
-  To use this command, in a parent process create a
-  `socketpair()` of type `SOCK_SEQPACKET`.  Fork
-  off this command, and pass one half of the socket
-  pair to the child.  Providing it on stdin (fd 0)
-  is the expected default.
-
-  The protocol is JSON for the control layer,
-  and  a read side of a `pipe()` passed for large data.
-
- Base JSON protocol:
-
- request: { method: "MethodName": args: [arguments] }
- reply: { success: bool, value: JSVAL, pipeid: number, error: string }
-
- For any non-metadata i.e. payload data from `GetManifest`
- and `GetBlob` the server will pass back the read half of a `pipe(2)` via FD passing,
- along with a `pipeid` integer.
-
- The expected flow looks like this:
-
-  - Initialize
-    And validate the returned protocol version versus
-	what your client supports.
-  - OpenImage docker://quay.io/someorg/example:latest
-    (returns an imageid)
-  - GetManifest imageid (and associated <pipeid>)
-  (Streaming read data from pipe)
-  - FinishPipe <pipeid>
-  - GetBlob imageid sha256:...
-  (Streaming read data from pipe)
-  - FinishPipe <pipeid>
-  - GetBlob imageid sha256:...
-  (Streaming read data from pipe)
-  - FinishPipe <pipeid>
-  - CloseImage imageid
-
- You may interleave invocations of these methods, e.g. one
- can also invoke `OpenImage` multiple times, as well as
- starting multiple GetBlob requests before calling `FinishPipe`
- on them.  The server will stream data into the pipefd
- until `FinishPipe` is invoked.
-
- Note that the pipe will not be closed by the server until
- the client has invoked `FinishPipe`.  This is to ensure
- that the client checks for errors.  For example, `GetBlob`
- performs digest (e.g. sha256) verification and this must
- be checked after all data has been written.
-*/
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net"
-	"os"
-	"sync"
-	"syscall"
-
-	"github.com/containers/image/v5/image"
-	"github.com/containers/image/v5/manifest"
-	"github.com/containers/image/v5/pkg/blobinfocache"
-	"github.com/containers/image/v5/transports/alltransports"
-	"github.com/containers/image/v5/types"
-	"github.com/opencontainers/go-digest"
-	imgspecv1 "github.com/opencontainers/image-spec/specs-go/v1"
-	"github.com/spf13/cobra"
-)
-
-// protocolVersion is semantic version of the protocol used by this proxy.
-// The first version of the protocol has major version 0.2 to signify a
-// departure from the original code which used HTTP.  The minor version is 1
-// instead of 0 to help exercise semver parsers.
-const protocolVersion = "0.2.1"
-
-// maxMsgSize is the current limit on a packet size.
-// Note that all non-metadata (i.e. payload data) is sent over a pipe.
-const maxMsgSize = 32 * 1024
-
-// maxJSONFloat is ECMA Number.MAX_SAFE_INTEGER
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER
-// We hard error if the input JSON numbers we expect to be
-// integers are above this.
-const maxJSONFloat = float64(1<<53 - 1)
-
-// request is the JSON serialization of a function call
-type request struct {
-	// Method is the name of the function
-	Method string `json:"method"`
-	// Args is the arguments (parsed inside the fuction)
-	Args []interface{} `json:"args"`
-}
-
-// reply is serialized to JSON as the return value from a function call.
-type reply struct {
-	// Success is true if and only if the call succeeded.
-	Success bool `json:"success"`
-	// Value is an arbitrary value (or values, as array/map) returned from the call.
-	Value interface{} `json:"value"`
-	// PipeID is an index into open pipes, and should be passed to FinishPipe
-	PipeID uint32 `json:"pipeid"`
-	// Error should be non-empty if Success == false
-	Error string `json:"error"`
-}
-
-// replyBuf is our internal deserialization of reply plus optional fd
-type replyBuf struct {
-	// value will be converted to a reply Value
-	value interface{}
-	// fd is the read half of a pipe, passed back to the client
-	fd *os.File
-	// pipeid will be provided to the client as PipeID, an index into our open pipes
-	pipeid uint32
-}
-
-// activePipe is an open pipe to the client.
-// It contains an error value
-type activePipe struct {
-	// w is the write half of the pipe
-	w *os.File
-	// wg is completed when our worker goroutine is done
-	wg sync.WaitGroup
-	// err may be set in our worker goroutine
-	err error
-}
-
-// openImage is an opened image reference
-type openImage struct {
-	// id is an opaque integer handle
-	id  uint32
-	src types.ImageSource
-	img types.Image
-}
-
-// proxyHandler is the state associated with our socket.
-type proxyHandler struct {
-	// lock protects everything else in this structure.
-	lock sync.Mutex
-	// opts is CLI options
-	opts   *proxyOptions
-	sysctx *types.SystemContext
-	cache  types.BlobInfoCache
-
-	// imageSerial is a counter for open images
-	imageSerial uint32
-	// images holds our opened images
-	images map[uint32]*openImage
-	// activePipes maps from "pipeid" to a pipe + goroutine pair
-	activePipes map[uint32]*activePipe
-}
-
-// Initialize performs one-time initialization, and returns the protocol version
-func (h *proxyHandler) Initialize(args []interface{}) (replyBuf, error) {
-	h.lock.Lock()
-	defer h.lock.Unlock()
-
-	var ret replyBuf
-
-	if len(args) != 0 {
-		return ret, fmt.Errorf("invalid request, expecting zero arguments")
-	}
-
-	if h.sysctx != nil {
-		return ret, fmt.Errorf("already initialized")
-	}
-
-	sysctx, err := h.opts.imageOpts.newSystemContext()
-	if err != nil {
-		return ret, err
-	}
-	h.sysctx = sysctx
-	h.cache = blobinfocache.DefaultCache(sysctx)
-
-	r := replyBuf{
-		value: protocolVersion,
-	}
-	return r, nil
-}
-
-// OpenImage accepts a string image reference i.e. TRANSPORT:REF - like `skopeo copy`.
-// The return value is an opaque integer handle.
-func (h *proxyHandler) OpenImage(args []interface{}) (replyBuf, error) {
-	h.lock.Lock()
-	defer h.lock.Unlock()
-	var ret replyBuf
-
-	if h.sysctx == nil {
-		return ret, fmt.Errorf("Must invoke Initialize")
-	}
-	if len(args) != 1 {
-		return ret, fmt.Errorf("invalid request, expecting one argument")
-	}
-	imageref, ok := args[0].(string)
-	if !ok {
-		return ret, fmt.Errorf("Expecting string imageref, not %T", args[0])
-	}
-
-	imgRef, err := alltransports.ParseImageName(imageref)
-	if err != nil {
-		return ret, err
-	}
-	imgsrc, err := imgRef.NewImageSource(context.Background(), h.sysctx)
-	if err != nil {
-		return ret, err
-	}
-	img, err := image.FromUnparsedImage(context.Background(), h.sysctx, image.UnparsedInstance(imgsrc, nil))
-	if err != nil {
-		return ret, fmt.Errorf("failed to load image: %w", err)
-	}
-
-	h.imageSerial++
-	openimg := &openImage{
-		id:  h.imageSerial,
-		src: imgsrc,
-		img: img,
-	}
-	h.images[openimg.id] = openimg
-	ret.value = openimg.id
-
-	return ret, nil
-}
-
-func (h *proxyHandler) CloseImage(args []interface{}) (replyBuf, error) {
-	h.lock.Lock()
-	defer h.lock.Unlock()
-	var ret replyBuf
-
-	if h.sysctx == nil {
-		return ret, fmt.Errorf("Must invoke Initialize")
-	}
-	if len(args) != 1 {
-		return ret, fmt.Errorf("invalid request, expecting one argument")
-	}
-	imgref, err := h.parseImageFromID(args[0])
-	if err != nil {
-		return ret, err
-	}
-	imgref.src.Close()
-	delete(h.images, imgref.id)
-
-	return ret, nil
-}
-
-func parseImageID(v interface{}) (uint32, error) {
-	imgidf, ok := v.(float64)
-	if !ok {
-		return 0, fmt.Errorf("Expecting integer imageid, not %T", v)
-	}
-	return uint32(imgidf), nil
-}
-
-// parseUint64 validates that a number fits inside a JavaScript safe integer
-func parseUint64(v interface{}) (uint64, error) {
-	f, ok := v.(float64)
-	if !ok {
-		return 0, fmt.Errorf("Expecting numeric, not %T", v)
-	}
-	if f > maxJSONFloat {
-		return 0, fmt.Errorf("Out of range integer for numeric %f", f)
-	}
-	return uint64(f), nil
-}
-
-func (h *proxyHandler) parseImageFromID(v interface{}) (*openImage, error) {
-	imgid, err := parseImageID(v)
-	if err != nil {
-		return nil, err
-	}
-	imgref, ok := h.images[imgid]
-	if !ok {
-		return nil, fmt.Errorf("No image %v", imgid)
-	}
-	return imgref, nil
-}
-
-func (h *proxyHandler) allocPipe() (*os.File, *activePipe, error) {
-	piper, pipew, err := os.Pipe()
-	if err != nil {
-		return nil, nil, err
-	}
-	f := activePipe{
-		w: pipew,
-	}
-	h.activePipes[uint32(pipew.Fd())] = &f
-	f.wg.Add(1)
-	return piper, &f, nil
-}
-
-// GetManifest returns a copy of the manifest, converted to OCI format, along with the original digest.
-func (h *proxyHandler) GetManifest(args []interface{}) (replyBuf, error) {
-	h.lock.Lock()
-	defer h.lock.Unlock()
-
-	var ret replyBuf
-
-	if h.sysctx == nil {
-		return ret, fmt.Errorf("Must invoke Initialize")
-	}
-	if len(args) != 1 {
-		return ret, fmt.Errorf("invalid request, expecting one argument")
-	}
-	imgref, err := h.parseImageFromID(args[0])
-	if err != nil {
-		return ret, err
-	}
-
-	ctx := context.TODO()
-	rawManifest, manifestType, err := imgref.img.Manifest(ctx)
-	if err != nil {
-		return ret, err
-	}
-	// We only support OCI and docker2schema2.  We know docker2schema2 can be easily+cheaply
-	// converted into OCI, so consumers only need to see OCI.
-	switch manifestType {
-	case imgspecv1.MediaTypeImageManifest, manifest.DockerV2Schema2MediaType:
-		break
-	// Explicitly reject e.g. docker schema 1 type with a "legacy" note
-	case manifest.DockerV2Schema1MediaType, manifest.DockerV2Schema1SignedMediaType:
-		return ret, fmt.Errorf("Unsupported legacy manifest MIME type: %s", manifestType)
-	default:
-		return ret, fmt.Errorf("Unsupported manifest MIME type: %s", manifestType)
-	}
-
-	// We always return the original digest, as that's what clients need to do pull-by-digest
-	// and in general identify the image.
-	digest, err := manifest.Digest(rawManifest)
-	if err != nil {
-		return ret, err
-	}
-	var serialized []byte
-	// But, we convert to OCI format on the wire if it's not already.  The idea here is that by reusing the containers/image
-	// stack, clients to this proxy can pretend the world is OCI only, and not need to care about e.g.
-	// docker schema and MIME types.
-	if manifestType != imgspecv1.MediaTypeImageManifest {
-		manifestUpdates := types.ManifestUpdateOptions{ManifestMIMEType: imgspecv1.MediaTypeImageManifest}
-		ociImage, err := imgref.img.UpdatedImage(ctx, manifestUpdates)
-		if err != nil {
-			return ret, err
-		}
-
-		ociSerialized, _, err := ociImage.Manifest(ctx)
-		if err != nil {
-			return ret, err
-		}
-		serialized = ociSerialized
-	} else {
-		serialized = rawManifest
-	}
-	piper, f, err := h.allocPipe()
-	if err != nil {
-		return ret, err
-	}
-
-	go func() {
-		// Signal completion when we return
-		defer f.wg.Done()
-		_, err = io.Copy(f.w, bytes.NewReader(serialized))
-		if err != nil {
-			f.err = err
-		}
-	}()
-
-	ret.value = digest.String()
-	ret.fd = piper
-	ret.pipeid = uint32(f.w.Fd())
-	return ret, nil
-}
-
-// GetBlob fetches a blob, performing digest verification.
-func (h *proxyHandler) GetBlob(args []interface{}) (replyBuf, error) {
-	h.lock.Lock()
-	defer h.lock.Unlock()
-
-	var ret replyBuf
-
-	if h.sysctx == nil {
-		return ret, fmt.Errorf("Must invoke Initialize")
-	}
-	if len(args) != 3 {
-		return ret, fmt.Errorf("found %d args, expecting (imgid, digest, size)", len(args))
-	}
-	imgref, err := h.parseImageFromID(args[0])
-	if err != nil {
-		return ret, err
-	}
-	digestStr, ok := args[1].(string)
-	if !ok {
-		return ret, fmt.Errorf("expecting string blobid")
-	}
-	size, err := parseUint64(args[2])
-	if err != nil {
-		return ret, err
-	}
-
-	ctx := context.TODO()
-	d, err := digest.Parse(digestStr)
-	if err != nil {
-		return ret, err
-	}
-	blobr, blobSize, err := imgref.src.GetBlob(ctx, types.BlobInfo{Digest: d, Size: int64(size)}, h.cache)
-	if err != nil {
-		return ret, err
-	}
-
-	piper, f, err := h.allocPipe()
-	if err != nil {
-		return ret, err
-	}
-	go func() {
-		// Signal completion when we return
-		defer f.wg.Done()
-		verifier := d.Verifier()
-		tr := io.TeeReader(blobr, verifier)
-		n, err := io.Copy(f.w, tr)
-		if err != nil {
-			f.err = err
-			return
-		}
-		if n != int64(size) {
-			f.err = fmt.Errorf("Expected %d bytes in blob, got %d", size, n)
-		}
-		if !verifier.Verified() {
-			f.err = fmt.Errorf("corrupted blob, expecting %s", d.String())
-		}
-	}()
-
-	ret.value = blobSize
-	ret.fd = piper
-	ret.pipeid = uint32(f.w.Fd())
-	return ret, nil
-}
-
-// FinishPipe waits for the worker goroutine to finish, and closes the write side of the pipe.
-func (h *proxyHandler) FinishPipe(args []interface{}) (replyBuf, error) {
-	h.lock.Lock()
-	defer h.lock.Unlock()
-
-	var ret replyBuf
-
-	pipeidf, ok := args[0].(float64)
-	if !ok {
-		return ret, fmt.Errorf("finishpipe: expecting pipeid, not %T", args[0])
-	}
-	pipeid := uint32(pipeidf)
-
-	f, ok := h.activePipes[pipeid]
-	if !ok {
-		return ret, fmt.Errorf("finishpipe: no active pipe %d", pipeid)
-	}
-
-	// Wait for the goroutine to complete
-	f.wg.Wait()
-	// And only now do we close the write half; this forces the client to call this API
-	f.w.Close()
-	// Propagate any errors from the goroutine worker
-	err := f.err
-	delete(h.activePipes, pipeid)
-	return ret, err
-}
-
-// send writes a reply buffer to the socket
-func (buf replyBuf) send(conn *net.UnixConn, err error) error {
-	replyToSerialize := reply{
-		Success: err == nil,
-		Value:   buf.value,
-		PipeID:  buf.pipeid,
-	}
-	if err != nil {
-		replyToSerialize.Error = err.Error()
-	}
-	serializedReply, err := json.Marshal(&replyToSerialize)
-	if err != nil {
-		return err
-	}
-	// We took ownership of the FD - close it when we're done.
-	defer func() {
-		if buf.fd != nil {
-			buf.fd.Close()
-		}
-	}()
-	// Copy the FD number to the socket ancillary buffer
-	fds := make([]int, 0)
-	if buf.fd != nil {
-		fds = append(fds, int(buf.fd.Fd()))
-	}
-	oob := syscall.UnixRights(fds...)
-	n, oobn, err := conn.WriteMsgUnix(serializedReply, oob, nil)
-	if err != nil {
-		return err
-	}
-	// Validate that we sent the full packet
-	if n != len(serializedReply) || oobn != len(oob) {
-		return io.ErrShortWrite
-	}
-	return nil
-}
-
-type proxyOptions struct {
-	global    *globalOptions
-	imageOpts *imageOptions
-	sockFd    int
-}
-
-func proxyCmd(global *globalOptions) *cobra.Command {
-	sharedFlags, sharedOpts := sharedImageFlags()
-	imageFlags, imageOpts := imageFlags(global, sharedOpts, nil, "", "")
-	opts := proxyOptions{global: global, imageOpts: imageOpts}
-	cmd := &cobra.Command{
-		Use:   "experimental-image-proxy [command options] IMAGE",
-		Short: "Interactive proxy for fetching container images (EXPERIMENTAL)",
-		Long:  `Run skopeo as a proxy, supporting HTTP requests to fetch manifests and blobs.`,
-		RunE:  commandAction(opts.run),
-		Args:  cobra.ExactArgs(0),
-		// Not stabilized yet
-		Hidden:  true,
-		Example: `skopeo experimental-image-proxy --sockfd 3`,
-	}
-	adjustUsage(cmd)
-	flags := cmd.Flags()
-	flags.AddFlagSet(&sharedFlags)
-	flags.AddFlagSet(&imageFlags)
-	flags.IntVar(&opts.sockFd, "sockfd", 0, "Serve on opened socket pair (default 0/stdin)")
-	return cmd
-}
-
-// processRequest dispatches a remote request.
-// replyBuf is the result of the invocation.
-// terminate should be true if processing of requests should halt.
-func (h *proxyHandler) processRequest(req request) (rb replyBuf, terminate bool, err error) {
-	// Dispatch on the method
-	switch req.Method {
-	case "Initialize":
-		rb, err = h.Initialize(req.Args)
-	case "OpenImage":
-		rb, err = h.OpenImage(req.Args)
-	case "CloseImage":
-		rb, err = h.CloseImage(req.Args)
-	case "GetManifest":
-		rb, err = h.GetManifest(req.Args)
-	case "GetBlob":
-		rb, err = h.GetBlob(req.Args)
-	case "FinishPipe":
-		rb, err = h.FinishPipe(req.Args)
-	case "Shutdown":
-		terminate = true
-	default:
-		err = fmt.Errorf("unknown method: %s", req.Method)
-	}
-	return
-}
-
-// Implementation of podman experimental-image-proxy
-func (opts *proxyOptions) run(args []string, stdout io.Writer) error {
-	handler := &proxyHandler{
-		opts:        opts,
-		images:      make(map[uint32]*openImage),
-		activePipes: make(map[uint32]*activePipe),
-	}
-
-	// Convert the socket FD passed by client into a net.FileConn
-	fd := os.NewFile(uintptr(opts.sockFd), "sock")
-	fconn, err := net.FileConn(fd)
-	if err != nil {
-		return err
-	}
-	conn := fconn.(*net.UnixConn)
-
-	// Allocate a buffer to copy the packet into
-	buf := make([]byte, maxMsgSize)
-	for {
-		n, _, err := conn.ReadFrom(buf)
-		if err != nil {
-			if errors.Is(err, io.EOF) {
-				return nil
-			}
-			return fmt.Errorf("reading socket: %v", err)
-		}
-		// Parse the request JSON
-		readbuf := buf[0:n]
-		var req request
-		if err := json.Unmarshal(readbuf, &req); err != nil {
-			rb := replyBuf{}
-			rb.send(conn, fmt.Errorf("invalid request: %v", err))
-		}
-
-		rb, terminate, err := handler.processRequest(req)
-		if terminate {
-			return nil
-		}
-		rb.send(conn, err)
-	}
-}

cmd/skopeo/proxy_windows.go

@@ -1,30 +0,0 @@
-//go:build windows
-// +build windows
-
-package main
-
-import (
-	"fmt"
-	"io"
-
-	"github.com/spf13/cobra"
-)
-
-type proxyOptions struct {
-	global *globalOptions
-}
-
-func proxyCmd(global *globalOptions) *cobra.Command {
-	opts := proxyOptions{global: global}
-	cmd := &cobra.Command{
-		RunE: commandAction(opts.run),
-		Args: cobra.ExactArgs(0),
-		// Not stabilized yet
-		Hidden: true,
-	}
-	return cmd
-}
-
-func (opts *proxyOptions) run(args []string, stdout io.Writer) error {
-	return fmt.Errorf("This command is not supported on Windows")
-}

cmd/skopeo/signing.go

@@ -18,7 +18,7 @@ type standaloneSignOptions struct {
 func standaloneSignCmd() *cobra.Command {
 	opts := standaloneSignOptions{}
 	cmd := &cobra.Command{
-		Use:   "standalone-sign [command options] MANIFEST DOCKER-REFERENCE KEY-FINGERPRINT --output|-o SIGNATURE",
+		Use:   "standalone-sign [command options] MANIFEST DOCKER-REFERENCE KEY-FINGERPRINT",
 		Short: "Create a signature using local files",
 		RunE:  commandAction(opts.run),
 	}

cmd/skopeo/sync.go

@@ -11,7 +11,6 @@ import (
 	"regexp"
 	"strings"
 
-	commonFlag "github.com/containers/common/pkg/flag"
 	"github.com/containers/common/pkg/retry"
 	"github.com/containers/image/v5/copy"
 	"github.com/containers/image/v5/directory"
@@ -28,19 +27,16 @@ import (
 
 // syncOptions contains information retrieved from the skopeo sync command line.
 type syncOptions struct {
-	global              *globalOptions // Global (not command dependent) skopeo options
-	deprecatedTLSVerify *deprecatedTLSVerifyOption
-	srcImage            *imageOptions     // Source image options
-	destImage           *imageDestOptions // Destination image options
-	retryOpts           *retry.RetryOptions
-	removeSignatures    bool                      // Do not copy signatures from the source image
-	signByFingerprint   string                    // Sign the image using a GPG key with the specified fingerprint
-	format              commonFlag.OptionalString // Force conversion of the image to a specified format
-	source              string                    // Source repository name
-	destination         string                    // Destination registry name
-	scoped              bool                      // When true, namespace copied images at destination using the source repository name
-	all                 bool                      // Copy all of the images if an image in the source is a list
-	keepGoing           bool                      // Whether or not to abort the sync if there are any errors during syncing the images
+	global            *globalOptions    // Global (not command dependent) skopeo options
+	srcImage          *imageOptions     // Source image options
+	destImage         *imageDestOptions // Destination image options
+	retryOpts         *retry.RetryOptions
+	removeSignatures  bool   // Do not copy signatures from the source image
+	signByFingerprint string // Sign the image using a GPG key with the specified fingerprint
+	source            string // Source repository name
+	destination       string // Destination registry name
+	scoped            bool   // When true, namespace copied images at destination using the source repository name
+	all               bool   // Copy all of the images if an image in the source is a list
 }
 
 // repoDescriptor contains information of a single repository used as a sync source.
@@ -50,7 +46,7 @@ type repoDescriptor struct {
 	Context     *types.SystemContext   // SystemContext for the sync command
 }
 
-// tlsVerifyConfig is an implementation of the Unmarshaler interface, used to
+// tlsVerify is an implementation of the Unmarshaler interface, used to
 // customize the unmarshaling behaviour of the tls-verify YAML key.
 type tlsVerifyConfig struct {
 	skip types.OptionalBool // skip TLS verification check (false by default)
@@ -71,29 +67,27 @@ type sourceConfig map[string]registrySyncConfig
 
 func syncCmd(global *globalOptions) *cobra.Command {
 	sharedFlags, sharedOpts := sharedImageFlags()
-	deprecatedTLSVerifyFlags, deprecatedTLSVerifyOpt := deprecatedTLSVerifyFlags()
-	srcFlags, srcOpts := dockerImageFlags(global, sharedOpts, deprecatedTLSVerifyOpt, "src-", "screds")
-	destFlags, destOpts := dockerImageFlags(global, sharedOpts, deprecatedTLSVerifyOpt, "dest-", "dcreds")
+	srcFlags, srcOpts := dockerImageFlags(global, sharedOpts, "src-", "screds")
+	destFlags, destOpts := dockerImageFlags(global, sharedOpts, "dest-", "dcreds")
 	retryFlags, retryOpts := retryFlags()
 
 	opts := syncOptions{
-		global:              global,
-		deprecatedTLSVerify: deprecatedTLSVerifyOpt,
-		srcImage:            srcOpts,
-		destImage:           &imageDestOptions{imageOptions: destOpts},
-		retryOpts:           retryOpts,
+		global:    global,
+		srcImage:  srcOpts,
+		destImage: &imageDestOptions{imageOptions: destOpts},
+		retryOpts: retryOpts,
 	}
 
 	cmd := &cobra.Command{
-		Use:   "sync [command options] --src TRANSPORT --dest TRANSPORT SOURCE DESTINATION",
+		Use:   "sync [command options] --src SOURCE-LOCATION --dest DESTINATION-LOCATION SOURCE DESTINATION",
 		Short: "Synchronize one or more images from one location to another",
-		Long: `Copy all the images from a SOURCE to a DESTINATION.
+		Long: fmt.Sprint(`Copy all the images from a SOURCE to a DESTINATION.
 
 Allowed SOURCE transports (specified with --src): docker, dir, yaml.
 Allowed DESTINATION transports (specified with --dest): docker, dir.
 
 See skopeo-sync(1) for details.
-`,
+`),
 		RunE:    commandAction(opts.run),
 		Example: `skopeo sync --src docker --dest dir --scoped registry.example.com/busybox /media/usb`,
 	}
@@ -101,21 +95,18 @@ See skopeo-sync(1) for details.
 	flags := cmd.Flags()
 	flags.BoolVar(&opts.removeSignatures, "remove-signatures", false, "Do not copy signatures from SOURCE images")
 	flags.StringVar(&opts.signByFingerprint, "sign-by", "", "Sign the image using a GPG key with the specified `FINGERPRINT`")
-	flags.VarP(commonFlag.NewOptionalStringValue(&opts.format), "format", "f", `MANIFEST TYPE (oci, v2s1, or v2s2) to use when syncing image(s) to a destination (default is manifest type of source, with fallbacks)`)
 	flags.StringVarP(&opts.source, "src", "s", "", "SOURCE transport type")
 	flags.StringVarP(&opts.destination, "dest", "d", "", "DESTINATION transport type")
 	flags.BoolVar(&opts.scoped, "scoped", false, "Images at DESTINATION are prefix using the full source image path as scope")
 	flags.BoolVarP(&opts.all, "all", "a", false, "Copy all images if SOURCE-IMAGE is a list")
-	flags.BoolVarP(&opts.keepGoing, "keep-going", "", false, "Do not abort the sync if any image copy fails")
 	flags.AddFlagSet(&sharedFlags)
-	flags.AddFlagSet(&deprecatedTLSVerifyFlags)
 	flags.AddFlagSet(&srcFlags)
 	flags.AddFlagSet(&destFlags)
 	flags.AddFlagSet(&retryFlags)
 	return cmd
 }
 
-// UnmarshalYAML is the implementation of the Unmarshaler interface method
+// unmarshalYAML is the implementation of the Unmarshaler interface method
 // method for the tlsVerifyConfig type.
 // It unmarshals the 'tls-verify' YAML key so that, when they key is not
 // specified, tls verification is enforced.
@@ -214,6 +205,7 @@ func getImageTags(ctx context.Context, sysCtx *types.SystemContext, repoRef refe
 		// Some registries may decide to block the "list all tags" endpoint.
 		// Gracefully allow the sync to continue in this case.
 		logrus.Warnf("Registry disallows tag list retrieval: %s", err)
+		break
 	default:
 		return tags, errors.Wrapf(err, "Error determining repository tags for image %s", name)
 	}
@@ -246,7 +238,7 @@ func imagesToCopyFromRepo(sys *types.SystemContext, repoRef reference.Named) ([]
 	return sourceReferences, nil
 }
 
-// imagesToCopyFromDir builds a list of image references from the images found
+// imagesTopCopyFromDir builds a list of image references from the images found
 // in the source directory.
 // It returns an image reference slice with as many elements as the images found
 // and any error encountered.
@@ -276,7 +268,7 @@ func imagesToCopyFromDir(dirPath string) ([]types.ImageReference, error) {
 	return sourceReferences, nil
 }
 
-// imagesToCopyFromRegistry builds a list of repository descriptors from the images
+// imagesTopCopyFromDir builds a list of repository descriptors from the images
 // in a registry configuration.
 // It returns a repository descriptors slice with as many elements as the images
 // found and any error encountered. Each element of the slice is a list of
@@ -499,7 +491,6 @@ func (opts *syncOptions) run(args []string, stdout io.Writer) error {
 	if len(args) != 2 {
 		return errorShouldDisplayUsage{errors.New("Exactly two arguments expected")}
 	}
-	opts.deprecatedTLSVerify.warnIfUsed([]string{"--src-tls-verify", "--dest-tls-verify"})
 
 	policyContext, err := opts.global.getPolicyContext()
 	if err != nil {
@@ -545,14 +536,6 @@ func (opts *syncOptions) run(args []string, stdout io.Writer) error {
 		return err
 	}
 
-	var manifestType string
-	if opts.format.Present() {
-		manifestType, err = parseManifestFormat(opts.format.Value())
-		if err != nil {
-			return err
-		}
-	}
-
 	ctx, cancel := opts.global.commandTimeoutContext()
 	defer cancel()
 
@@ -571,17 +554,15 @@ func (opts *syncOptions) run(args []string, stdout io.Writer) error {
 		return err
 	}
 
-	options := copy.Options{
-		RemoveSignatures:                      opts.removeSignatures,
-		SignBy:                                opts.signByFingerprint,
-		ReportWriter:                          os.Stdout,
-		DestinationCtx:                        destinationCtx,
-		ImageListSelection:                    imageListSelection,
-		OptimizeDestinationImageAlreadyExists: true,
-		ForceManifestMIMEType:                 manifestType,
-	}
-	errorsPresent := false
 	imagesNumber := 0
+	options := copy.Options{
+		RemoveSignatures:   opts.removeSignatures,
+		SignBy:             opts.signByFingerprint,
+		ReportWriter:       os.Stdout,
+		DestinationCtx:     destinationCtx,
+		ImageListSelection: imageListSelection,
+	}
+
 	for _, srcRepo := range srcRepoList {
 		options.SourceCtx = srcRepo.Context
 		for counter, ref := range srcRepo.ImageRefs {
@@ -617,22 +598,12 @@ func (opts *syncOptions) run(args []string, stdout io.Writer) error {
 				_, err = copy.Image(ctx, policyContext, destRef, ref, &options)
 				return err
 			}, opts.retryOpts); err != nil {
-				if !opts.keepGoing {
-					return errors.Wrapf(err, "Error copying ref %q", transports.ImageName(ref))
-				}
-				// log the error, keep a note that there was a failure and move on to the next
-				// image ref
-				errorsPresent = true
-				logrus.WithError(err).Errorf("Error copying ref %q", transports.ImageName(ref))
-				continue
+				return errors.Wrapf(err, "Error copying ref %q", transports.ImageName(ref))
 			}
 			imagesNumber++
 		}
 	}
 
 	logrus.Infof("Synced %d images from %d sources", imagesNumber, len(srcRepoList))
-	if !errorsPresent {
-		return nil
-	}
-	return errors.New("Sync failed due to previous reported error(s) for one or more images")
+	return nil
 }

cmd/skopeo/unshare.go

@@ -1,8 +1,11 @@
-//go:build !linux
 // +build !linux
 
 package main
 
+func maybeReexec() error {
+	return nil
+}
+
 func reexecIfNecessaryForImages(inputImageNames ...string) error {
 	return nil
 }

cmd/skopeo/utils.go

@@ -2,20 +2,15 @@ package main
 
 import (
 	"context"
-	"fmt"
 	"io"
 	"os"
 	"strings"
 
-	commonFlag "github.com/containers/common/pkg/flag"
 	"github.com/containers/common/pkg/retry"
-	"github.com/containers/image/v5/manifest"
 	"github.com/containers/image/v5/pkg/compression"
 	"github.com/containers/image/v5/transports/alltransports"
 	"github.com/containers/image/v5/types"
-	imgspecv1 "github.com/opencontainers/image-spec/specs-go/v1"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 )
@@ -40,35 +35,6 @@ func commandAction(handler func(args []string, stdout io.Writer) error) func(cmd
 	}
 }
 
-// deprecatedTLSVerifyOption represents a deprecated --tls-verify option,
-// which was accepted for all subcommands, for a time.
-// Every user should call deprecatedTLSVerifyOption.warnIfUsed() as part of handling the CLI,
-// whether or not the value actually ends up being used.
-// DO NOT ADD ANY NEW USES OF THIS; just call dockerImageFlags with an appropriate, possibly empty, flagPrefix.
-type deprecatedTLSVerifyOption struct {
-	tlsVerify commonFlag.OptionalBool // FIXME FIXME: Warn if this is used, or even if it is ignored.
-}
-
-// warnIfUsed warns if tlsVerify was set by the user, and suggests alternatives (which should
-// start with "--").
-// Every user should call this as part of handling the CLI, whether or not the value actually
-// ends up being used.
-func (opts *deprecatedTLSVerifyOption) warnIfUsed(alternatives []string) {
-	if opts.tlsVerify.Present() {
-		logrus.Warnf("'--tls-verify' is deprecated, instead use: %s", strings.Join(alternatives, ", "))
-	}
-}
-
-// deprecatedTLSVerifyFlags prepares the CLI flag writing into deprecatedTLSVerifyOption, and the managed deprecatedTLSVerifyOption structure.
-// DO NOT ADD ANY NEW USES OF THIS; just call dockerImageFlags with an appropriate, possibly empty, flagPrefix.
-func deprecatedTLSVerifyFlags() (pflag.FlagSet, *deprecatedTLSVerifyOption) {
-	opts := deprecatedTLSVerifyOption{}
-	fs := pflag.FlagSet{}
-	flag := commonFlag.OptionalBoolFlag(&fs, &opts.tlsVerify, "tls-verify", "require HTTPS and verify certificates when accessing the container registry")
-	flag.Hidden = true
-	return fs, &opts
-}
-
 // sharedImageOptions collects CLI flags which are image-related, but do not change across images.
 // This really should be a part of globalOptions, but that would break existing users of (skopeo copy --authfile=).
 type sharedImageOptions struct {
@@ -87,17 +53,14 @@ func sharedImageFlags() (pflag.FlagSet, *sharedImageOptions) {
 // the same across subcommands, but may be different for each image
 // (e.g. may differ between the source and destination of a copy)
 type dockerImageOptions struct {
-	global              *globalOptions             // May be shared across several imageOptions instances.
-	shared              *sharedImageOptions        // May be shared across several imageOptions instances.
-	deprecatedTLSVerify *deprecatedTLSVerifyOption // May be shared across several imageOptions instances, or nil.
-	authFilePath        commonFlag.OptionalString  // Path to a */containers/auth.json (prefixed version to override shared image option).
-	credsOption         commonFlag.OptionalString  // username[:password] for accessing a registry
-	userName            commonFlag.OptionalString  // username for accessing a registry
-	password            commonFlag.OptionalString  // password for accessing a registry
-	registryToken       commonFlag.OptionalString  // token to be used directly as a Bearer token when accessing the registry
-	dockerCertPath      string                     // A directory using Docker-like *.{crt,cert,key} files for connecting to a registry or a daemon
-	tlsVerify           commonFlag.OptionalBool    // Require HTTPS and verify certificates (for docker: and docker-daemon:)
-	noCreds             bool                       // Access the registry anonymously
+	global         *globalOptions      // May be shared across several imageOptions instances.
+	shared         *sharedImageOptions // May be shared across several imageOptions instances.
+	authFilePath   optionalString      // Path to a */containers/auth.json (prefixed version to override shared image option).
+	credsOption    optionalString      // username[:password] for accessing a registry
+	registryToken  optionalString      // token to be used directly as a Bearer token when accessing the registry
+	dockerCertPath string              // A directory using Docker-like *.{crt,cert,key} files for connecting to a registry or a daemon
+	tlsVerify      optionalBool        // Require HTTPS and verify certificates (for docker: and docker-daemon:)
+	noCreds        bool                // Access the registry anonymously
 }
 
 // imageOptions collects CLI flags which are the same across subcommands, but may be different for each image
@@ -110,39 +73,36 @@ type imageOptions struct {
 
 // dockerImageFlags prepares a collection of docker-transport specific CLI flags
 // writing into imageOptions, and the managed imageOptions structure.
-func dockerImageFlags(global *globalOptions, shared *sharedImageOptions, deprecatedTLSVerify *deprecatedTLSVerifyOption, flagPrefix, credsOptionAlias string) (pflag.FlagSet, *imageOptions) {
+func dockerImageFlags(global *globalOptions, shared *sharedImageOptions, flagPrefix, credsOptionAlias string) (pflag.FlagSet, *imageOptions) {
 	flags := imageOptions{
 		dockerImageOptions: dockerImageOptions{
-			global:              global,
-			shared:              shared,
-			deprecatedTLSVerify: deprecatedTLSVerify,
+			global: global,
+			shared: shared,
 		},
 	}
 
 	fs := pflag.FlagSet{}
 	if flagPrefix != "" {
 		// the non-prefixed flag is handled by a shared flag.
-		fs.Var(commonFlag.NewOptionalStringValue(&flags.authFilePath), flagPrefix+"authfile", "path of the authentication file. Default is ${XDG_RUNTIME_DIR}/containers/auth.json")
+		fs.Var(newOptionalStringValue(&flags.authFilePath), flagPrefix+"authfile", "path of the authentication file. Default is ${XDG_RUNTIME_DIR}/containers/auth.json")
 	}
-	fs.Var(commonFlag.NewOptionalStringValue(&flags.credsOption), flagPrefix+"creds", "Use `USERNAME[:PASSWORD]` for accessing the registry")
-	fs.Var(commonFlag.NewOptionalStringValue(&flags.userName), flagPrefix+"username", "Username for accessing the registry")
-	fs.Var(commonFlag.NewOptionalStringValue(&flags.password), flagPrefix+"password", "Password for accessing the registry")
+	fs.Var(newOptionalStringValue(&flags.credsOption), flagPrefix+"creds", "Use `USERNAME[:PASSWORD]` for accessing the registry")
 	if credsOptionAlias != "" {
 		// This is horribly ugly, but we need to support the old option forms of (skopeo copy) for compatibility.
 		// Don't add any more cases like this.
-		f := fs.VarPF(commonFlag.NewOptionalStringValue(&flags.credsOption), credsOptionAlias, "", "Use `USERNAME[:PASSWORD]` for accessing the registry")
+		f := fs.VarPF(newOptionalStringValue(&flags.credsOption), credsOptionAlias, "", "Use `USERNAME[:PASSWORD]` for accessing the registry")
 		f.Hidden = true
 	}
-	fs.Var(commonFlag.NewOptionalStringValue(&flags.registryToken), flagPrefix+"registry-token", "Provide a Bearer token for accessing the registry")
+	fs.Var(newOptionalStringValue(&flags.registryToken), flagPrefix+"registry-token", "Provide a Bearer token for accessing the registry")
 	fs.StringVar(&flags.dockerCertPath, flagPrefix+"cert-dir", "", "use certificates at `PATH` (*.crt, *.cert, *.key) to connect to the registry or daemon")
-	commonFlag.OptionalBoolFlag(&fs, &flags.tlsVerify, flagPrefix+"tls-verify", "require HTTPS and verify certificates when talking to the container registry or daemon")
+	optionalBoolFlag(&fs, &flags.tlsVerify, flagPrefix+"tls-verify", "require HTTPS and verify certificates when talking to the container registry or daemon (defaults to true)")
 	fs.BoolVar(&flags.noCreds, flagPrefix+"no-creds", false, "Access the registry anonymously")
 	return fs, &flags
 }
 
 // imageFlags prepares a collection of CLI flags writing into imageOptions, and the managed imageOptions structure.
-func imageFlags(global *globalOptions, shared *sharedImageOptions, deprecatedTLSVerify *deprecatedTLSVerifyOption, flagPrefix, credsOptionAlias string) (pflag.FlagSet, *imageOptions) {
-	dockerFlags, opts := dockerImageFlags(global, shared, deprecatedTLSVerify, flagPrefix, credsOptionAlias)
+func imageFlags(global *globalOptions, shared *sharedImageOptions, flagPrefix, credsOptionAlias string) (pflag.FlagSet, *imageOptions) {
+	dockerFlags, opts := dockerImageFlags(global, shared, flagPrefix, credsOptionAlias)
 
 	fs := pflag.FlagSet{}
 	fs.StringVar(&opts.sharedBlobDir, flagPrefix+"shared-blob-dir", "", "`DIRECTORY` to use to share blobs across OCI repositories")
@@ -151,6 +111,10 @@ func imageFlags(global *globalOptions, shared *sharedImageOptions, deprecatedTLS
 	return fs, opts
 }
 
+type retryOptions struct {
+	maxRetry int // The number of times to possibly retry
+}
+
 func retryFlags() (pflag.FlagSet, *retry.RetryOptions) {
 	opts := retry.RetryOptions{}
 	fs := pflag.FlagSet{}
@@ -169,49 +133,27 @@ func (opts *imageOptions) newSystemContext() (*types.SystemContext, error) {
 	ctx.AuthFilePath = opts.shared.authFilePath
 	ctx.DockerDaemonHost = opts.dockerDaemonHost
 	ctx.DockerDaemonCertPath = opts.dockerCertPath
-	if opts.dockerImageOptions.authFilePath.Present() {
-		ctx.AuthFilePath = opts.dockerImageOptions.authFilePath.Value()
+	if opts.dockerImageOptions.authFilePath.present {
+		ctx.AuthFilePath = opts.dockerImageOptions.authFilePath.value
 	}
-	if opts.deprecatedTLSVerify != nil && opts.deprecatedTLSVerify.tlsVerify.Present() {
-		// If both this deprecated option and a non-deprecated option is present, we use the latter value.
-		ctx.DockerInsecureSkipTLSVerify = types.NewOptionalBool(!opts.deprecatedTLSVerify.tlsVerify.Value())
+	if opts.tlsVerify.present {
+		ctx.DockerDaemonInsecureSkipTLSVerify = !opts.tlsVerify.value
 	}
-	if opts.tlsVerify.Present() {
-		ctx.DockerDaemonInsecureSkipTLSVerify = !opts.tlsVerify.Value()
+	if opts.tlsVerify.present {
+		ctx.DockerInsecureSkipTLSVerify = types.NewOptionalBool(!opts.tlsVerify.value)
 	}
-	if opts.tlsVerify.Present() {
-		ctx.DockerInsecureSkipTLSVerify = types.NewOptionalBool(!opts.tlsVerify.Value())
-	}
-	if opts.credsOption.Present() && opts.noCreds {
+	if opts.credsOption.present && opts.noCreds {
 		return nil, errors.New("creds and no-creds cannot be specified at the same time")
 	}
-	if opts.userName.Present() && opts.noCreds {
-		return nil, errors.New("username and no-creds cannot be specified at the same time")
-	}
-	if opts.credsOption.Present() && opts.userName.Present() {
-		return nil, errors.New("creds and username cannot be specified at the same time")
-	}
-	// if any of username or password is present, then both are expected to be present
-	if opts.userName.Present() != opts.password.Present() {
-		if opts.userName.Present() {
-			return nil, errors.New("password must be specified when username is specified")
-		}
-		return nil, errors.New("username must be specified when password is specified")
-	}
-	if opts.credsOption.Present() {
+	if opts.credsOption.present {
 		var err error
-		ctx.DockerAuthConfig, err = getDockerAuth(opts.credsOption.Value())
+		ctx.DockerAuthConfig, err = getDockerAuth(opts.credsOption.value)
 		if err != nil {
 			return nil, err
 		}
-	} else if opts.userName.Present() {
-		ctx.DockerAuthConfig = &types.DockerAuthConfig{
-			Username: opts.userName.Value(),
-			Password: opts.password.Value(),
-		}
 	}
-	if opts.registryToken.Present() {
-		ctx.DockerBearerRegistryToken = opts.registryToken.Value()
+	if opts.registryToken.present {
+		ctx.DockerBearerRegistryToken = opts.registryToken.value
 	}
 	if opts.noCreds {
 		ctx.DockerAuthConfig = &types.DockerAuthConfig{}
@@ -223,26 +165,22 @@ func (opts *imageOptions) newSystemContext() (*types.SystemContext, error) {
 // imageDestOptions is a superset of imageOptions specialized for image destinations.
 type imageDestOptions struct {
 	*imageOptions
-	dirForceCompression         bool                   // Compress layers when saving to the dir: transport
-	dirForceDecompression       bool                   // Decompress layers when saving to the dir: transport
-	ociAcceptUncompressedLayers bool                   // Whether to accept uncompressed layers in the oci: transport
-	compressionFormat           string                 // Format to use for the compression
-	compressionLevel            commonFlag.OptionalInt // Level to use for the compression
-	precomputeDigests           bool                   // Precompute digests to dedup layers when saving to the docker: transport
+	dirForceCompression         bool        // Compress layers when saving to the dir: transport
+	ociAcceptUncompressedLayers bool        // Whether to accept uncompressed layers in the oci: transport
+	compressionFormat           string      // Format to use for the compression
+	compressionLevel            optionalInt // Level to use for the compression
 }
 
 // imageDestFlags prepares a collection of CLI flags writing into imageDestOptions, and the managed imageDestOptions structure.
-func imageDestFlags(global *globalOptions, shared *sharedImageOptions, deprecatedTLSVerify *deprecatedTLSVerifyOption, flagPrefix, credsOptionAlias string) (pflag.FlagSet, *imageDestOptions) {
-	genericFlags, genericOptions := imageFlags(global, shared, deprecatedTLSVerify, flagPrefix, credsOptionAlias)
+func imageDestFlags(global *globalOptions, shared *sharedImageOptions, flagPrefix, credsOptionAlias string) (pflag.FlagSet, *imageDestOptions) {
+	genericFlags, genericOptions := imageFlags(global, shared, flagPrefix, credsOptionAlias)
 	opts := imageDestOptions{imageOptions: genericOptions}
 	fs := pflag.FlagSet{}
 	fs.AddFlagSet(&genericFlags)
 	fs.BoolVar(&opts.dirForceCompression, flagPrefix+"compress", false, "Compress tarball image layers when saving to directory using the 'dir' transport. (default is same compression type as source)")
-	fs.BoolVar(&opts.dirForceDecompression, flagPrefix+"decompress", false, "Decompress tarball image layers when saving to directory using the 'dir' transport. (default is same compression type as source)")
 	fs.BoolVar(&opts.ociAcceptUncompressedLayers, flagPrefix+"oci-accept-uncompressed-layers", false, "Allow uncompressed image layers when saving to an OCI image using the 'oci' transport. (default is to compress things that aren't compressed)")
 	fs.StringVar(&opts.compressionFormat, flagPrefix+"compress-format", "", "`FORMAT` to use for the compression")
-	fs.Var(commonFlag.NewOptionalIntValue(&opts.compressionLevel), flagPrefix+"compress-level", "`LEVEL` to use for the compression")
-	fs.BoolVar(&opts.precomputeDigests, flagPrefix+"precompute-digests", false, "Precompute digests to prevent uploading layers already on the registry using the 'docker' transport.")
+	fs.Var(newOptionalIntValue(&opts.compressionLevel), flagPrefix+"compress-level", "`LEVEL` to use for the compression")
 	return fs, &opts
 }
 
@@ -255,7 +193,6 @@ func (opts *imageDestOptions) newSystemContext() (*types.SystemContext, error) {
 	}
 
 	ctx.DirForceCompress = opts.dirForceCompression
-	ctx.DirForceDecompress = opts.dirForceDecompression
 	ctx.OCIAcceptUncompressedLayers = opts.ociAcceptUncompressedLayers
 	if opts.compressionFormat != "" {
 		cf, err := compression.AlgorithmByName(opts.compressionFormat)
@@ -264,11 +201,9 @@ func (opts *imageDestOptions) newSystemContext() (*types.SystemContext, error) {
 		}
 		ctx.CompressionFormat = &cf
 	}
-	if opts.compressionLevel.Present() {
-		value := opts.compressionLevel.Value()
-		ctx.CompressionLevel = &value
+	if opts.compressionLevel.present {
+		ctx.CompressionLevel = &opts.compressionLevel.value
 	}
-	ctx.DockerRegistryPushPrecomputeDigests = opts.precomputeDigests
 	return ctx, err
 }
 
@@ -311,21 +246,6 @@ func parseImageSource(ctx context.Context, opts *imageOptions, name string) (typ
 	return ref.NewImageSource(ctx, sys)
 }
 
-// parseManifestFormat parses format parameter for copy and sync command.
-// It returns string value to use as manifest MIME type
-func parseManifestFormat(manifestFormat string) (string, error) {
-	switch manifestFormat {
-	case "oci":
-		return imgspecv1.MediaTypeImageManifest, nil
-	case "v2s1":
-		return manifest.DockerV2Schema1SignedMediaType, nil
-	case "v2s2":
-		return manifest.DockerV2Schema2MediaType, nil
-	default:
-		return "", fmt.Errorf("unknown format %q. Choose one of the supported formats: 'oci', 'v2s1', or 'v2s2'", manifestFormat)
-	}
-}
-
 // usageTemplate returns the usage template for skopeo commands
 // This blocks the displaying of the global options. The main skopeo
 // command should not use this.

cmd/skopeo/utils_test.go

@@ -4,11 +4,8 @@ import (
 	"os"
 	"testing"
 
-	"github.com/containers/image/v5/manifest"
 	"github.com/containers/image/v5/types"
-	imgspecv1 "github.com/opencontainers/image-spec/specs-go/v1"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -18,26 +15,17 @@ func fakeGlobalOptions(t *testing.T, flags []string) (*globalOptions, *cobra.Com
 	app, opts := createApp()
 	cmd := &cobra.Command{}
 	app.AddCommand(cmd)
-	err := app.ParseFlags(flags)
+	err := cmd.ParseFlags(flags)
 	require.NoError(t, err)
 	return opts, cmd
 }
 
 // fakeImageOptions creates imageOptions and sets it according to globalFlags/cmdFlags.
-func fakeImageOptions(t *testing.T, flagPrefix string, useDeprecatedTLSVerify bool,
-	globalFlags []string, cmdFlags []string) *imageOptions {
+func fakeImageOptions(t *testing.T, flagPrefix string, globalFlags []string, cmdFlags []string) *imageOptions {
 	globalOpts, cmd := fakeGlobalOptions(t, globalFlags)
 	sharedFlags, sharedOpts := sharedImageFlags()
-	var deprecatedTLSVerifyFlag pflag.FlagSet
-	var deprecatedTLSVerifyOpt *deprecatedTLSVerifyOption
-	if useDeprecatedTLSVerify {
-		deprecatedTLSVerifyFlag, deprecatedTLSVerifyOpt = deprecatedTLSVerifyFlags()
-	}
-	imageFlags, imageOpts := imageFlags(globalOpts, sharedOpts, deprecatedTLSVerifyOpt, flagPrefix, "")
+	imageFlags, imageOpts := imageFlags(globalOpts, sharedOpts, flagPrefix, "")
 	cmd.Flags().AddFlagSet(&sharedFlags)
-	if useDeprecatedTLSVerify {
-		cmd.Flags().AddFlagSet(&deprecatedTLSVerifyFlag)
-	}
 	cmd.Flags().AddFlagSet(&imageFlags)
 	err := cmd.ParseFlags(cmdFlags)
 	require.NoError(t, err)
@@ -46,15 +34,13 @@ func fakeImageOptions(t *testing.T, flagPrefix string, useDeprecatedTLSVerify bo
 
 func TestImageOptionsNewSystemContext(t *testing.T) {
 	// Default state
-	opts := fakeImageOptions(t, "dest-", true, []string{}, []string{})
+	opts := fakeImageOptions(t, "dest-", []string{}, []string{})
 	res, err := opts.newSystemContext()
 	require.NoError(t, err)
-	assert.Equal(t, &types.SystemContext{
-		DockerRegistryUserAgent: defaultUserAgent,
-	}, res)
+	assert.Equal(t, &types.SystemContext{}, res)
 
 	// Set everything to non-default values.
-	opts = fakeImageOptions(t, "dest-", true, []string{
+	opts = fakeImageOptions(t, "dest-", []string{
 		"--registries.d", "/srv/registries.d",
 		"--override-arch", "overridden-arch",
 		"--override-os", "overridden-os",
@@ -86,33 +72,52 @@ func TestImageOptionsNewSystemContext(t *testing.T) {
 		DockerDaemonCertPath:              "/srv/cert-dir",
 		DockerDaemonHost:                  "daemon-host.example.com",
 		DockerDaemonInsecureSkipTLSVerify: true,
-		DockerRegistryUserAgent:           defaultUserAgent,
 		BigFilesTemporaryDir:              "/srv",
 	}, res)
 
-	// Global/per-command tlsVerify behavior is tested in TestTLSVerifyFlags.
+	// Global/per-command tlsVerify behavior
+	for _, c := range []struct {
+		global, cmd          string
+		expectedDocker       types.OptionalBool
+		expectedDockerDaemon bool
+	}{
+		{"", "", types.OptionalBoolUndefined, false},
+		{"", "false", types.OptionalBoolTrue, true},
+		{"", "true", types.OptionalBoolFalse, false},
+		{"false", "", types.OptionalBoolTrue, false},
+		{"false", "false", types.OptionalBoolTrue, true},
+		{"false", "true", types.OptionalBoolFalse, false},
+		{"true", "", types.OptionalBoolFalse, false},
+		{"true", "false", types.OptionalBoolTrue, true},
+		{"true", "true", types.OptionalBoolFalse, false},
+	} {
+		globalFlags := []string{}
+		if c.global != "" {
+			globalFlags = append(globalFlags, "--tls-verify="+c.global)
+		}
+		cmdFlags := []string{}
+		if c.cmd != "" {
+			cmdFlags = append(cmdFlags, "--dest-tls-verify="+c.cmd)
+		}
+		opts := fakeImageOptions(t, "dest-", globalFlags, cmdFlags)
+		res, err = opts.newSystemContext()
+		require.NoError(t, err)
+		assert.Equal(t, c.expectedDocker, res.DockerInsecureSkipTLSVerify, "%#v", c)
+		assert.Equal(t, c.expectedDockerDaemon, res.DockerDaemonInsecureSkipTLSVerify, "%#v", c)
+	}
 
 	// Invalid option values
-	opts = fakeImageOptions(t, "dest-", true, []string{}, []string{"--dest-creds", ""})
+	opts = fakeImageOptions(t, "dest-", []string{}, []string{"--dest-creds", ""})
 	_, err = opts.newSystemContext()
 	assert.Error(t, err)
 }
 
 // fakeImageDestOptions creates imageDestOptions and sets it according to globalFlags/cmdFlags.
-func fakeImageDestOptions(t *testing.T, flagPrefix string, useDeprecatedTLSVerify bool,
-	globalFlags []string, cmdFlags []string) *imageDestOptions {
+func fakeImageDestOptions(t *testing.T, flagPrefix string, globalFlags []string, cmdFlags []string) *imageDestOptions {
 	globalOpts, cmd := fakeGlobalOptions(t, globalFlags)
 	sharedFlags, sharedOpts := sharedImageFlags()
-	var deprecatedTLSVerifyFlag pflag.FlagSet
-	var deprecatedTLSVerifyOpt *deprecatedTLSVerifyOption
-	if useDeprecatedTLSVerify {
-		deprecatedTLSVerifyFlag, deprecatedTLSVerifyOpt = deprecatedTLSVerifyFlags()
-	}
-	imageFlags, imageOpts := imageDestFlags(globalOpts, sharedOpts, deprecatedTLSVerifyOpt, flagPrefix, "")
+	imageFlags, imageOpts := imageDestFlags(globalOpts, sharedOpts, flagPrefix, "")
 	cmd.Flags().AddFlagSet(&sharedFlags)
-	if useDeprecatedTLSVerify {
-		cmd.Flags().AddFlagSet(&deprecatedTLSVerifyFlag)
-	}
 	cmd.Flags().AddFlagSet(&imageFlags)
 	err := cmd.ParseFlags(cmdFlags)
 	require.NoError(t, err)
@@ -121,12 +126,10 @@ func fakeImageDestOptions(t *testing.T, flagPrefix string, useDeprecatedTLSVerif
 
 func TestImageDestOptionsNewSystemContext(t *testing.T) {
 	// Default state
-	opts := fakeImageDestOptions(t, "dest-", true, []string{}, []string{})
+	opts := fakeImageDestOptions(t, "dest-", []string{}, []string{})
 	res, err := opts.newSystemContext()
 	require.NoError(t, err)
-	assert.Equal(t, &types.SystemContext{
-		DockerRegistryUserAgent: defaultUserAgent,
-	}, res)
+	assert.Equal(t, &types.SystemContext{}, res)
 
 	oldXRD, hasXRD := os.LookupEnv("REGISTRY_AUTH_FILE")
 	defer func() {
@@ -141,18 +144,15 @@ func TestImageDestOptionsNewSystemContext(t *testing.T) {
 	os.Setenv("REGISTRY_AUTH_FILE", authFile)
 
 	// Explicitly set everything to default, except for when the default is “not present”
-	opts = fakeImageDestOptions(t, "dest-", true, []string{}, []string{
+	opts = fakeImageDestOptions(t, "dest-", []string{}, []string{
 		"--dest-compress=false",
 	})
 	res, err = opts.newSystemContext()
 	require.NoError(t, err)
-	assert.Equal(t, &types.SystemContext{
-		AuthFilePath:            authFile,
-		DockerRegistryUserAgent: defaultUserAgent,
-	}, res)
+	assert.Equal(t, &types.SystemContext{AuthFilePath: authFile}, res)
 
 	// Set everything to non-default values.
-	opts = fakeImageDestOptions(t, "dest-", true, []string{
+	opts = fakeImageDestOptions(t, "dest-", []string{
 		"--registries.d", "/srv/registries.d",
 		"--override-arch", "overridden-arch",
 		"--override-os", "overridden-os",
@@ -167,208 +167,33 @@ func TestImageDestOptionsNewSystemContext(t *testing.T) {
 		"--dest-tls-verify=false",
 		"--dest-creds", "creds-user:creds-password",
 		"--dest-registry-token", "faketoken",
-		"--dest-precompute-digests=true",
 	})
 	res, err = opts.newSystemContext()
 	require.NoError(t, err)
 	assert.Equal(t, &types.SystemContext{
-		RegistriesDirPath:                   "/srv/registries.d",
-		AuthFilePath:                        "/srv/authfile",
-		ArchitectureChoice:                  "overridden-arch",
-		OSChoice:                            "overridden-os",
-		VariantChoice:                       "overridden-variant",
-		OCISharedBlobDirPath:                "/srv/shared-blob-dir",
-		DockerCertPath:                      "/srv/cert-dir",
-		DockerInsecureSkipTLSVerify:         types.OptionalBoolTrue,
-		DockerAuthConfig:                    &types.DockerAuthConfig{Username: "creds-user", Password: "creds-password"},
-		DockerBearerRegistryToken:           "faketoken",
-		DockerDaemonCertPath:                "/srv/cert-dir",
-		DockerDaemonHost:                    "daemon-host.example.com",
-		DockerDaemonInsecureSkipTLSVerify:   true,
-		DockerRegistryUserAgent:             defaultUserAgent,
-		DirForceCompress:                    true,
-		BigFilesTemporaryDir:                "/srv",
-		DockerRegistryPushPrecomputeDigests: true,
+		RegistriesDirPath:                 "/srv/registries.d",
+		AuthFilePath:                      "/srv/authfile",
+		ArchitectureChoice:                "overridden-arch",
+		OSChoice:                          "overridden-os",
+		VariantChoice:                     "overridden-variant",
+		OCISharedBlobDirPath:              "/srv/shared-blob-dir",
+		DockerCertPath:                    "/srv/cert-dir",
+		DockerInsecureSkipTLSVerify:       types.OptionalBoolTrue,
+		DockerAuthConfig:                  &types.DockerAuthConfig{Username: "creds-user", Password: "creds-password"},
+		DockerBearerRegistryToken:         "faketoken",
+		DockerDaemonCertPath:              "/srv/cert-dir",
+		DockerDaemonHost:                  "daemon-host.example.com",
+		DockerDaemonInsecureSkipTLSVerify: true,
+		DirForceCompress:                  true,
+		BigFilesTemporaryDir:              "/srv",
 	}, res)
 
-	// Global/per-command tlsVerify behavior is tested in TestTLSVerifyFlags.
-
 	// Invalid option values in imageOptions
-	opts = fakeImageDestOptions(t, "dest-", true, []string{}, []string{"--dest-creds", ""})
+	opts = fakeImageDestOptions(t, "dest-", []string{}, []string{"--dest-creds", ""})
 	_, err = opts.newSystemContext()
 	assert.Error(t, err)
 }
 
-// TestImageOptionsUsernamePassword verifies that using the username and password
-// options works as expected
-func TestImageOptionsUsernamePassword(t *testing.T) {
-	for _, command := range []struct {
-		commandArgs        []string
-		expectedAuthConfig *types.DockerAuthConfig // data to expect, or nil if an error is expected
-	}{
-		// Set only username/password (without --creds), expected to pass
-		{
-			commandArgs:        []string{"--dest-username", "foo", "--dest-password", "bar"},
-			expectedAuthConfig: &types.DockerAuthConfig{Username: "foo", Password: "bar"},
-		},
-		// no username but set password, expect error
-		{
-			commandArgs:        []string{"--dest-password", "foo"},
-			expectedAuthConfig: nil,
-		},
-		// set username but no password. expected to fail (we currently don't allow a user without password)
-		{
-			commandArgs:        []string{"--dest-username", "bar"},
-			expectedAuthConfig: nil,
-		},
-		// set username with --creds, expected to fail
-		{
-			commandArgs:        []string{"--dest-username", "bar", "--dest-creds", "hello:world", "--dest-password", "foo"},
-			expectedAuthConfig: nil,
-		},
-		// set username with --no-creds, expected to fail
-		{
-			commandArgs:        []string{"--dest-username", "bar", "--dest-no-creds", "--dest-password", "foo"},
-			expectedAuthConfig: nil,
-		},
-	} {
-		opts := fakeImageDestOptions(t, "dest-", true, []string{}, command.commandArgs)
-		// parse the command options
-		res, err := opts.newSystemContext()
-		if command.expectedAuthConfig == nil {
-			assert.Error(t, err)
-		} else {
-			require.NoError(t, err)
-			assert.Equal(t, &types.SystemContext{
-				DockerRegistryUserAgent: defaultUserAgent,
-				DockerAuthConfig:        command.expectedAuthConfig,
-			}, res)
-		}
-	}
-}
-
-func TestTLSVerifyFlags(t *testing.T) {
-	type systemContextOpts interface { // Either *imageOptions or *imageDestOptions
-		newSystemContext() (*types.SystemContext, error)
-	}
-
-	for _, creator := range []struct {
-		name    string
-		newOpts func(useDeprecatedTLSVerify bool, globalFlags, cmdFlags []string) systemContextOpts
-	}{
-		{
-			"imageFlags",
-			func(useDeprecatedTLSVerify bool, globalFlags, cmdFlags []string) systemContextOpts {
-				return fakeImageOptions(t, "dest-", useDeprecatedTLSVerify, globalFlags, cmdFlags)
-			},
-		},
-		{
-			"imageDestFlags",
-			func(useDeprecatedTLSVerify bool, globalFlags, cmdFlags []string) systemContextOpts {
-				return fakeImageDestOptions(t, "dest-", useDeprecatedTLSVerify, globalFlags, cmdFlags)
-			},
-		},
-	} {
-		t.Run(creator.name, func(t *testing.T) {
-			for _, c := range []struct {
-				global, deprecatedCmd, cmd string
-				expectedDocker             types.OptionalBool
-				expectedDockerDaemon       bool
-			}{
-				{"", "", "", types.OptionalBoolUndefined, false},
-				{"", "", "false", types.OptionalBoolTrue, true},
-				{"", "", "true", types.OptionalBoolFalse, false},
-				{"", "false", "", types.OptionalBoolTrue, false},
-				{"", "false", "false", types.OptionalBoolTrue, true},
-				{"", "false", "true", types.OptionalBoolFalse, false},
-				{"", "true", "", types.OptionalBoolFalse, false},
-				{"", "true", "false", types.OptionalBoolTrue, true},
-				{"", "true", "true", types.OptionalBoolFalse, false},
-				{"false", "", "", types.OptionalBoolTrue, false},
-				{"false", "", "false", types.OptionalBoolTrue, true},
-				{"false", "", "true", types.OptionalBoolFalse, false},
-				{"false", "false", "", types.OptionalBoolTrue, false},
-				{"false", "false", "false", types.OptionalBoolTrue, true},
-				{"false", "false", "true", types.OptionalBoolFalse, false},
-				{"false", "true", "", types.OptionalBoolFalse, false},
-				{"false", "true", "false", types.OptionalBoolTrue, true},
-				{"false", "true", "true", types.OptionalBoolFalse, false},
-				{"true", "", "", types.OptionalBoolFalse, false},
-				{"true", "", "false", types.OptionalBoolTrue, true},
-				{"true", "", "true", types.OptionalBoolFalse, false},
-				{"true", "false", "", types.OptionalBoolTrue, false},
-				{"true", "false", "false", types.OptionalBoolTrue, true},
-				{"true", "false", "true", types.OptionalBoolFalse, false},
-				{"true", "true", "", types.OptionalBoolFalse, false},
-				{"true", "true", "false", types.OptionalBoolTrue, true},
-				{"true", "true", "true", types.OptionalBoolFalse, false},
-			} {
-				globalFlags := []string{}
-				if c.global != "" {
-					globalFlags = append(globalFlags, "--tls-verify="+c.global)
-				}
-				cmdFlags := []string{}
-				if c.deprecatedCmd != "" {
-					cmdFlags = append(cmdFlags, "--tls-verify="+c.deprecatedCmd)
-				}
-				if c.cmd != "" {
-					cmdFlags = append(cmdFlags, "--dest-tls-verify="+c.cmd)
-				}
-				opts := creator.newOpts(true, globalFlags, cmdFlags)
-				res, err := opts.newSystemContext()
-				require.NoError(t, err)
-				assert.Equal(t, c.expectedDocker, res.DockerInsecureSkipTLSVerify, "%#v", c)
-				assert.Equal(t, c.expectedDockerDaemon, res.DockerDaemonInsecureSkipTLSVerify, "%#v", c)
-
-				if c.deprecatedCmd == "" { // Test also the behavior when deprecatedTLSFlag is not recognized
-					// Use globalFlags from the previous test
-					cmdFlags := []string{}
-					if c.cmd != "" {
-						cmdFlags = append(cmdFlags, "--dest-tls-verify="+c.cmd)
-					}
-					opts := creator.newOpts(false, globalFlags, cmdFlags)
-					res, err = opts.newSystemContext()
-					require.NoError(t, err)
-					assert.Equal(t, c.expectedDocker, res.DockerInsecureSkipTLSVerify, "%#v", c)
-					assert.Equal(t, c.expectedDockerDaemon, res.DockerDaemonInsecureSkipTLSVerify, "%#v", c)
-				}
-			}
-		})
-	}
-}
-
-func TestParseManifestFormat(t *testing.T) {
-	for _, testCase := range []struct {
-		formatParam          string
-		expectedManifestType string
-		expectErr            bool
-	}{
-		{"oci",
-			imgspecv1.MediaTypeImageManifest,
-			false},
-		{"v2s1",
-			manifest.DockerV2Schema1SignedMediaType,
-			false},
-		{"v2s2",
-			manifest.DockerV2Schema2MediaType,
-			false},
-		{"",
-			"",
-			true},
-		{"badValue",
-			"",
-			true},
-	} {
-		manifestType, err := parseManifestFormat(testCase.formatParam)
-		if testCase.expectErr {
-			require.Error(t, err)
-		} else {
-			require.NoError(t, err)
-		}
-		assert.Equal(t, manifestType, testCase.expectedManifestType)
-	}
-}
-
 // since there is a shared authfile image option and a non-shared (prefixed) one, make sure the override logic
 // works correctly.
 func TestImageOptionsAuthfileOverride(t *testing.T) {
@@ -403,13 +228,12 @@ func TestImageOptionsAuthfileOverride(t *testing.T) {
 			}, "/srv/dest-authfile",
 		},
 	} {
-		opts := fakeImageOptions(t, testCase.flagPrefix, false, []string{}, testCase.cmdFlags)
+		opts := fakeImageOptions(t, testCase.flagPrefix, []string{}, testCase.cmdFlags)
 		res, err := opts.newSystemContext()
 		require.NoError(t, err)
 
 		assert.Equal(t, &types.SystemContext{
-			AuthFilePath:            testCase.expectedAuthfilePath,
-			DockerRegistryUserAgent: defaultUserAgent,
+			AuthFilePath: testCase.expectedAuthfilePath,
 		}, res)
 	}
 }

completions/bash/skopeo

@@ -51,62 +51,15 @@ _skopeo_copy() {
     --dest-daemon-host
     --src-registry-token
     --dest-registry-token
-    --src-username
-    --src-password
-    --dest-username
-    --dest-password
     "
 
     local boolean_options="
     --all
     --dest-compress
-    --dest-decompress
     --remove-signatures
     --src-no-creds
     --dest-no-creds
     --dest-oci-accept-uncompressed-layers
-    --dest-precompute-digests
-    "
-
-    local transports
-    transports="
-    $(_skopeo_supported_transports "${FUNCNAME//"_skopeo_"/}")
-    "
-
-    _complete_ "$options_with_args" "$boolean_options" "$transports"
-}
-
-_skopeo_sync() {
-    local options_with_args="
-    --authfile
-    --dest
-    --dest-authfile
-    --dest-cert-
-    --dest-creds
-    --dest-registry-token string
-    --format
-    --retry-times
-    --sign-by
-    --src
-    --src-authfile
-    --src-cert-dir
-    --src-creds
-    --src-registry-token
-    --src-username
-    --src-password
-    --dest-username
-    --dest-password
-    "
-
-    local boolean_options="
-    --all
-    --dest-no-creds
-    --dest-tls-verify
-    --remove-signatures
-    --scoped
-    --src-no-creds
-    --src-tls-verify
-    --keep-going
     "
 
     local transports
@@ -125,15 +78,12 @@ _skopeo_inspect() {
      --format
      --retry-times
      --registry-token
-    --username
-    --password
      "
      local boolean_options="
      --config
      --raw
      --tls-verify
      --no-creds
-     --no-tags -n
     "
 
     local transports
@@ -175,8 +125,6 @@ _skopeo_delete() {
      --creds
      --cert-dir
      --registry-token
-    --username
-    --password
      "
      local boolean_options="
      --tls-verify
@@ -197,8 +145,6 @@ _skopeo_layers() {
        --creds
        --cert-dir
        --registry-token
-      --username
-      --password
      "
      local boolean_options="
        --tls-verify
@@ -213,8 +159,6 @@ _skopeo_list_repository_tags() {
      --creds
      --cert-dir
      --registry-token
-    --username
-    --password
      "
 
      local boolean_options="
@@ -316,7 +260,7 @@ _cli_bash_autocomplete() {
      local counter=1
      while [ $counter -lt "$cword" ]; do
          case "${words[$counter]}" in
-             skopeo|copy|sync|inspect|delete|manifest-digest|standalone-sign|standalone-verify|help|h|list-repository-tags)
+             skopeo|copy|inspect|delete|manifest-digest|standalone-sign|standalone-verify|help|h|list-repository-tags)
                  command="${words[$counter]//-/_}"
                  cpos=$counter
                  (( cpos++ ))

contrib/cirrus/runner.sh

@@ -1,148 +0,0 @@
-#!/bin/bash
-
-# This script is intended to be executed by automation or humans
-# under a hack/get_ci_vm.sh context.  Use under any other circumstances
-# is unlikely to function.
-
-set -e
-
-# BEGIN Global export of all variables
-set -a
-
-# Due to differences across platforms and runtime execution environments,
-# handling of the (otherwise) default shell setup is non-uniform.  Rather
-# than attempt to workaround differences, simply force-load/set required
-# items every time this library is utilized.
-USER="$(whoami)"
-HOME="$(getent passwd $USER | cut -d : -f 6)"
-# Some platforms set and make this read-only
-[[ -n "$UID" ]] || \
-    UID=$(getent passwd $USER | cut -d : -f 3)
-
-if [[ -r "/etc/automation_environment" ]]; then
-    source /etc/automation_environment
-    source $AUTOMATION_LIB_PATH/common_lib.sh
-else
-    (
-    echo "WARNING: It does not appear that containers/automation was installed."
-    echo "         Functionality of most of ${BASH_SOURCE[0]} will be negatively"
-    echo "         impacted."
-    ) > /dev/stderr
-fi
-
-OS_RELEASE_ID="$(source /etc/os-release; echo $ID)"
-# GCE image-name compatible string representation of distribution _major_ version
-OS_RELEASE_VER="$(source /etc/os-release; echo $VERSION_ID | tr -d '.')"
-# Combined to ease some usage
-OS_REL_VER="${OS_RELEASE_ID}-${OS_RELEASE_VER}"
-
-# This is the magic interpreted by the tests to allow modifying local config/services.
-SKOPEO_CONTAINER_TESTS=1
-
-PATH=$PATH:$GOPATH/bin
-
-# END Global export of all variables
-set +a
-
-
-_run_setup() {
-    local mnt
-    local errmsg
-    req_env_vars SKOPEO_CIDEV_CONTAINER_FQIN
-    if [[ "$OS_RELEASE_ID" != "fedora" ]]; then
-        die "Unknown/unsupported distro. $OS_REL_VER"
-    fi
-
-    if [[ -r "/.ci_setup_complete" ]]; then
-        warn "Thwarted an attempt to execute setup more than once."
-        return
-    fi
-
-    # This is required as part of the standard Fedora GCE VM setup
-    growpart /dev/sda 1
-    resize2fs /dev/sda1
-
-    # VM's come with the distro. skopeo package pre-installed
-    dnf erase -y skopeo
-
-    # A slew of compiled binaries are pre-built and distributed
-    # within the CI/Dev container image, but we want to run
-    # things directly on the host VM.  Fortunately they're all
-    # located in the container under /usr/local/bin
-    msg "Accessing contents of $SKOPEO_CIDEV_CONTAINER_FQIN"
-    podman pull --quiet $SKOPEO_CIDEV_CONTAINER_FQIN
-    mnt=$(podman mount $(podman create $SKOPEO_CIDEV_CONTAINER_FQIN))
-
-    # The container and VM images are built in tandem in the same repo.
-    # automation, but the sources are in different directories.  It's
-    # possible for a mismatch to happen, but should (hopefully) be unlikely.
-    # Double-check to make sure.
-    if ! fgrep -qx "ID=$OS_RELEASE_ID" $mnt/etc/os-release || \
-       ! fgrep -qx "VERSION_ID=$OS_RELEASE_VER" $mnt/etc/os-release; then
-            die "Somehow $SKOPEO_CIDEV_CONTAINER_FQIN is not based on $OS_REL_VER."
-    fi
-    msg "Copying test binaries from $SKOPEO_CIDEV_CONTAINER_FQIN /usr/local/bin/"
-    cp -a "$mnt/usr/local/bin/"* "/usr/local/bin/"
-    msg "Configuring the openshift registry"
-
-    # TODO: Put directory & yaml into more sensible place + update integration tests
-    mkdir -vp /registry
-    cp -a "$mnt/atomic-registry-config.yml" /
-
-    msg "Cleaning up"
-    podman umount --latest
-    podman rm --latest
-
-    # Ensure setup can only run once
-    touch "/.ci_setup_complete"
-}
-
-_run_vendor() {
-    make vendor BUILDTAGS="$BUILDTAGS"
-}
-
-_run_build() {
-    make bin/skopeo BUILDTAGS="$BUILDTAGS"
-    make install PREFIX=/usr/local
-}
-
-_run_cross() {
-    make local-cross BUILDTAGS="$BUILDTAGS"
-}
-
-_run_doccheck() {
-    make validate-docs BUILDTAGS="$BUILDTAGS"
-}
-
-_run_unit() {
-    make test-unit-local BUILDTAGS="$BUILDTAGS"
-}
-
-_run_integration() {
-    # Ensure we start with a clean-slate
-    podman system reset --force
-
-    make test-integration-local BUILDTAGS="$BUILDTAGS"
-}
-
-_run_system() {
-    # Ensure we start with a clean-slate
-    podman system reset --force
-
-    # Executes with containers required for testing.
-    make test-system-local BUILDTAGS="$BUILDTAGS"
-}
-
-req_env_vars SKOPEO_PATH BUILDTAGS
-
-handler="_run_${1}"
-if [ "$(type -t $handler)" != "function" ]; then
-    die "Unknown/Unsupported command-line argument '$1'"
-fi
-
-msg "************************************************************"
-msg "Runner executing $1 on $OS_REL_VER"
-msg "************************************************************"
-
-cd "$SKOPEO_PATH"
-$handler

contrib/skopeoimage/README.md

@@ -6,35 +6,22 @@
 
 ## Overview
 
-This directory contains the Dockerfiles necessary to create the skopeoimage container
-images that are housed on quay.io under the skopeo account.  All repositories where
-the images live are public and can be pulled without credentials.  These container images are secured and the
-resulting containers can run safely with privileges within the container.
+This directory contains the Dockerfiles necessary to create the three skopeoimage container
+images that are housed on quay.io under the skopeo account.  All three repositories where
+the images live are public and can be pulled without credentials.  These container images
+are secured and the resulting containers can run safely.  The container images are built
+using the latest Fedora and then Skopeo is installed into them:
 
-The container images are built using the latest Fedora and then Skopeo is installed into them.
-The PATH in the container images is set to the default PATH provided by Fedora.  Also, the
-ENTRYPOINT and the WORKDIR variables are not set within these container images, as such they
-default to `/`.
+  * quay.io/skopeo/stable - This image is built using the latest stable version of Skopeo in a Fedora based container.  Built with skopeoimage/stable/Dockerfile.
+  * quay.io/skopeo/upstream - This image is built using the latest code found in this GitHub repository.  When someone creates a commit and pushes it, the image is created.  Due to that the image changes frequently and is not guaranteed to be stable.  Built with skopeoimage/upstream/Dockerfile.
+  * quay.io/skopeo/testing - This image is built using the latest version of Skopeo that is or was in updates testing for Fedora.  At times this may be the same as the stable image.  This container image will primarily be used by the development teams for verification testing when a new package is created.  Built with skopeoimage/testing/Dockerfile.
 
-The container images are:
+## Multiarch images
 
-  * `quay.io/containers/skopeo:<version>` and `quay.io/skopeo/stable:<version>` -
-    These images are built when a new Skopeo version becomes available in
-    Fedora.  These images are intended to be unchanging and stable, they will
-    never be updated by automation once they've been pushed.  For build details,
-    please [see the configuration file](stable/Dockerfile).
-  * `quay.io/containers/skopeo:latest` and `quay.io/skopeo/stable:latest` -
-    Built daily using the same Dockerfile as above.  The skopeo version
-    will remain the "latest" available in Fedora, however the image
-    contents may vary compared to the version-tagged images.
-  * `quay.io/skopeo/testing:latest` - This image is built daily, using the
-    latest version of Skopeo that was in the Fedora `updates-testing` repository.
-    The image is Built with [the testing Dockerfile](testing/Dockerfile).
-  * `quay.io/skopeo/upstream:latest` - This image is built daily using the latest
-    code found in this GitHub repository.  Due to the image changing frequently,
-    it's not guaranteed to be stable or even executable.  The image is built with
-    [the upstream Dockerfile](upstream/Dockerfile).
+Multiarch images are available for Skopeo upstream and stable versions. Supported architectures are `amd64`, `s390x`, `ppc64le`.
+Available images are `quay.io/skopeo/upstream:master`, `quay.io/skopeo/stable:v1.2.0`, `quay.io/containers/skopeo:v1.2.0`.
 
+Images can be used the same way as in a single architecture case, no extra setup is required. For samples see next chapter.
 
 ## Sample Usage
 

contrib/skopeoimage/stable/Dockerfile

@@ -6,7 +6,7 @@
 # This image can be used to create a secured container
 # that runs safely with privileges within the container.
 #
-FROM registry.fedoraproject.org/fedora:33
+FROM registry.fedoraproject.org/fedora:32
 
 # Don't include container-selinux and remove
 # directories used by yum that are just taking
@@ -27,7 +27,7 @@ RUN echo skopeo:100000:65536 > /etc/subuid
 RUN echo skopeo:100000:65536 > /etc/subgid
 
 # Point to the Authorization file
-ENV REGISTRY_AUTH_FILE=/tmp/auth.json
+ENV REGISTRY_AUTH_FILE=/auth.json
 
 # Set the entrypoint
 ENTRYPOINT ["/usr/bin/skopeo"]

contrib/skopeoimage/testing/Dockerfile

@@ -7,7 +7,7 @@
 # This image can be used to create a secured container
 # that runs safely with privileges within the container.
 #
-FROM registry.fedoraproject.org/fedora:33
+FROM registry.fedoraproject.org/fedora:32
 
 # Don't include container-selinux and remove
 # directories used by yum that are just taking
@@ -28,7 +28,7 @@ RUN echo skopeo:100000:65536 > /etc/subuid
 RUN echo skopeo:100000:65536 > /etc/subgid
 
 # Point to the Authorization file
-ENV REGISTRY_AUTH_FILE=/tmp/auth.json
+ENV REGISTRY_AUTH_FILE=/auth.json
 
 # Set the entrypoint
 ENTRYPOINT ["/usr/bin/skopeo"]

contrib/skopeoimage/upstream/Dockerfile

@@ -6,7 +6,7 @@
 # This image can be used to create a secured container
 # that runs safely with privileges within the container.
 #
-FROM registry.fedoraproject.org/fedora:33
+FROM registry.fedoraproject.org/fedora:32
 
 # Don't include container-selinux and remove
 # directories used by yum that are just taking
@@ -30,7 +30,7 @@ git clone https://github.com/containers/skopeo /root/skopeo/src/github.com/conta
 export GOPATH=/root/skopeo; \
 cd /root/skopeo/src/github.com/containers/skopeo; \
 make bin/skopeo;\
-make PREFIX=/usr install;\
+make install;\
 rm -rf /root/skopeo/*; \
 yum -y remove git golang go-md2man make; \
 yum -y clean all; yum -y clean all; rm -rf /var/cache/dnf/* /var/log/dnf* /var/log/yum*
@@ -48,7 +48,7 @@ RUN echo skopeo:100000:65536 > /etc/subuid
 RUN echo skopeo:100000:65536 > /etc/subgid
 
 # Point to the Authorization file
-ENV REGISTRY_AUTH_FILE=/tmp/auth.json
+ENV REGISTRY_AUTH_FILE=/auth.json
 
 # Set the entrypoint
 ENTRYPOINT ["/usr/bin/skopeo"]

docs/skopeo-copy.1.md

@@ -4,7 +4,7 @@
 skopeo\-copy - Copy an image (manifest, filesystem layers, signatures) from one location to another.
 
 ## SYNOPSIS
-**skopeo copy** [*options*] _source-image_ _destination-image_
+**skopeo copy** [**--sign-by=**_key-ID_] _source-image destination-image_
 
 ## DESCRIPTION
 Copy an image (manifest, filesystem layers, signatures) from one location to another.
@@ -20,11 +20,7 @@ automatically inherit any parts of the source name.
 
 ## OPTIONS
 
-**--additional-tag**=_strings_
-
-Additional tags (supports docker-archive).
-
-**--all**, **-a**
+**--all**
 
 If _source-image_ refers to a list of images, instead of copying just the image which matches the current OS and
 architecture (subject to the use of the global --override-os, --override-arch and --override-variant options), attempt to copy all of
@@ -46,143 +42,51 @@ Path of the authentication file for the source registry. Uses path given by `--a
 
 Path of the authentication file for the destination registry. Uses path given by `--authfile`, if not provided.
 
-**--dest-shared-blob-dir** _directory_
+**--format, -f** _manifest-type_ Manifest type (oci, v2s1, or v2s2) to use when saving image to directory using the 'dir:' transport (default is manifest type of source)
 
-Directory to use to share blobs across OCI repositories.
+**--quiet, -q** suppress output information when copying images
 
-**--digestfile** _path_
+**--remove-signatures** do not copy signatures, if any, from _source-image_. Necessary when copying a signed image to a destination which does not support signatures.
 
-After copying the image, write the digest of the resulting image to the file.
+**--sign-by=**_key-id_ add a signature using that key ID for an image name corresponding to _destination-image_
 
-**--encrypt-layer** _ints_
+**--encryption-key** _protocol:keyfile_ specifies the encryption protocol, which can be JWE (RFC7516), PGP (RFC4880), and PKCS7 (RFC2315) and the key material required for image encryption. For instance, jwe:/path/to/key.pem or pgp:admin@example.com or pkcs7:/path/to/x509-file.
 
-*Experimental* the 0-indexed layer indices, with support for negative indexing (e.g. 0 is the first layer, -1 is the last layer)
+**--decryption-key** _key[:passphrase]_ to be used for decryption of images. Key can point to keys and/or certificates. Decryption will be tried with all keys. If the key is protected by a passphrase, it is required to be passed in the argument and omitted otherwise.
 
-**--format**, **-f** _manifest-type_
+**--src-creds** _username[:password]_ for accessing the source registry.
 
-MANIFEST TYPE (oci, v2s1, or v2s2) to use in the destination (default is manifest type of source, with fallbacks)
+**--dest-compress** _bool-value_ Compress tarball image layers when saving to directory using the 'dir' transport. (default is same compression type as source).
 
-**--help**, **-h**
+**--dest-oci-accept-uncompressed-layers** _bool-value_ Allow uncompressed image layers when saving to an OCI image using the 'oci' transport. (default is to compress things that aren't compressed).
 
-Print usage statement
+**--dest-creds** _username[:password]_ for accessing the destination registry.
 
-**--quiet**, **-q**
+**--src-cert-dir** _path_ Use certificates at _path_ (*.crt, *.cert, *.key) to connect to the source registry or daemon.
 
-Suppress output information when copying images.
+**--src-no-creds** _bool-value_ Access the registry anonymously.
 
-**--remove-signatures**
+**--src-tls-verify** _bool-value_ Require HTTPS and verify certificates when talking to container source registry or daemon (defaults to true).
 
-Do not copy signatures, if any, from _source-image_. Necessary when copying a signed image to a destination which does not support signatures.
+**--dest-cert-dir** _path_ Use certificates at _path_ (*.crt, *.cert, *.key) to connect to the destination registry or daemon.
 
-**--sign-by**=_key-id_
+**--dest-no-creds** _bool-value_  Access the registry anonymously.
 
-Add a signature using that key ID for an image name corresponding to _destination-image_
+**--dest-tls-verify** _bool-value_ Require HTTPS and verify certificates when talking to container destination registry or daemon (defaults to true).
 
-**--src-shared-blob-dir** _directory_
+**--src-daemon-host** _host_ Copy from docker daemon at _host_. If _host_ starts with `tcp://`, HTTPS is enabled by default. To use plain HTTP, use the form `http://` (default is `unix:///var/run/docker.sock`).
 
-Directory to use to share blobs across OCI repositories.
-
-**--encryption-key** _protocol:keyfile_
-
-Specifies the encryption protocol, which can be JWE (RFC7516), PGP (RFC4880), and PKCS7 (RFC2315) and the key material required for image encryption. For instance, jwe:/path/to/key.pem or pgp:admin@example.com or pkcs7:/path/to/x509-file.
-
-**--decryption-key** _key[:passphrase]_
-
-Key to be used for decryption of images. Key can point to keys and/or certificates. Decryption will be tried with all keys. If the key is protected by a passphrase, it is required to be passed in the argument and omitted otherwise.
-
-**--src-creds** _username[:password]_
-
-Credentials for accessing the source registry.
-
-**--dest-compress** _bool-value_
-
-Compress tarball image layers when saving to directory using the 'dir' transport. (default is same compression type as source).
-
-**--dest-decompress** _bool-value_
-
-Decompress tarball image layers when saving to directory using the 'dir' transport. (default is same compression type as source).
-
-**--dest-oci-accept-uncompressed-layers** _bool-value_
-
-Allow uncompressed image layers when saving to an OCI image using the 'oci' transport. (default is to compress things that aren't compressed).
-
-**--dest-creds** _username[:password]_
-
-Credentials for accessing the destination registry.
-
-**--src-cert-dir** _path_
-
-Use certificates at _path_ (*.crt, *.cert, *.key) to connect to the source registry or daemon.
-
-**--src-no-creds** _bool-value_
-
-Access the registry anonymously.
-
-**--src-tls-verify** _bool-value_
-
-Require HTTPS and verify certificates when talking to container source registry or daemon. Default to source registry setting.
-
-**--dest-cert-dir** _path_
-
-Use certificates at _path_ (*.crt, *.cert, *.key) to connect to the destination registry or daemon.
-
-**--dest-no-creds** _bool-value_
-
-Access the registry anonymously.
-
-**--dest-tls-verify** _bool-value_
-
-Require HTTPS and verify certificates when talking to container destination registry or daemon. Default to destination registry setting.
-
-**--src-daemon-host** _host_
-
-Copy from docker daemon at _host_. If _host_ starts with `tcp://`, HTTPS is enabled by default. To use plain HTTP, use the form `http://` (default is `unix:///var/run/docker.sock`).
-
-**--dest-daemon-host** _host_
-
-Copy to docker daemon at _host_. If _host_ starts with `tcp://`, HTTPS is enabled by default. To use plain HTTP, use the form `http://` (default is `unix:///var/run/docker.sock`).
+**--dest-daemon-host** _host_ Copy to docker daemon at _host_. If _host_ starts with `tcp://`, HTTPS is enabled by default. To use plain HTTP, use the form `http://` (default is `unix:///var/run/docker.sock`).
 
 Existing signatures, if any, are preserved as well.
 
-**--dest-compress-format** _format_
+**--dest-compress-format** _format_ Specifies the compression format to use.  Supported values are: `gzip` and `zstd`.
 
-Specifies the compression format to use.  Supported values are: `gzip` and `zstd`.
+**--dest-compress-level** _format_ Specifies the compression level to use.  The value is specific to the compression algorithm used, e.g. for zstd the accepted values are in the range 1-20 (inclusive), while for gzip it is 1-9 (inclusive).
 
-**--dest-compress-level** _format_
+**--src-registry-token** _Bearer token_ for accessing the source registry.
 
-Specifies the compression level to use.  The value is specific to the compression algorithm used, e.g. for zstd the accepted values are in the range 1-20 (inclusive), while for gzip it is 1-9 (inclusive).
-
-**--src-registry-token** _token_
-
-Bearer token for accessing the source registry.
-
-**--dest-registry-token** _token_
-
-Bearer token for accessing the destination registry.
-
-**--dest-precompute-digests** _bool-value_
-
-Precompute digests to ensure layers are not uploaded that already exist on the destination registry. Layers with initially unknown digests (ex. compressing "on the fly") will be temporarily streamed to disk.
-
-**--retry-times**
-
-The number of times to retry. Retry wait time will be exponentially increased based on the number of failed attempts.
-
-**--src-username**
-
-The username to access the source registry.
-
-**--src-password**
-
-The password to access the source registry.
-
-**--dest-username**
-
-The username to access the destination registry.
-
-**--dest-password**
-
-The password to access the destination registry.
+**--dest-registry-token** _Bearer token_ for accessing the destination registry.
 
 ## EXAMPLES
 
@@ -240,8 +144,9 @@ skopeo  copy --encryption-key jwe:./public.key --encrypt-layer 1 oci:local_nginx
 ```
 
 ## SEE ALSO
-skopeo(1), skopeo-login(1), docker-login(1), containers-auth.json(5), containers-policy.json(5), containers-transports(5), containers-signature(5)
+skopeo(1), skopeo-login(1), docker-login(1), containers-auth.json(5), containers-policy.json(5), containers-transports(5)
 
 ## AUTHORS
 
 Antonio Murdaca <runcom@redhat.com>, Miloslav Trmac <mitr@redhat.com>, Jhon Honce <jhonce@redhat.com>
+

docs/skopeo-delete.1.md

@@ -4,7 +4,7 @@
 skopeo\-delete - Mark the _image-name_ for later deletion by the registry's garbage collector.
 
 ## SYNOPSIS
-**skopeo delete** [*options*] _image-name_
+**skopeo delete** _image-name_
 
 Mark _image-name_ for deletion.  To release the allocated disk space, you must login to the container registry server and execute the container registry garbage collector. E.g.,
 
@@ -19,58 +19,22 @@ $ docker exec -it registry /usr/bin/registry garbage-collect /etc/docker-distrib
 
 ```
 
-## OPTIONS
-
 **--authfile** _path_
 
-Path of the authentication file. Default is ${XDG_RUNTIME\_DIR}/containers/auth.json, which is set using `skopeo login`.
-If the authorization state is not found there, $HOME/.docker/config.json is checked, which is set using `docker login`.
+  Path of the authentication file. Default is ${XDG_RUNTIME\_DIR}/containers/auth.json, which is set using `skopeo login`.
+  If the authorization state is not found there, $HOME/.docker/config.json is checked, which is set using `docker login`.
 
-**--creds** _username[:password]_
+**--creds** _username[:password]_ for accessing the registry.
 
-Credentials for accessing the registry.
+**--cert-dir** _path_ Use certificates at _path_ (*.crt, *.cert, *.key) to connect to the registry.
 
-**--cert-dir** _path_
+**--tls-verify** _bool-value_ Require HTTPS and verify certificates when talking to container registries (defaults to true).
 
-Use certificates at _path_ (*.crt, *.cert, *.key) to connect to the registry.
-
-**--daemon-host** _host_
-
-Use docker daemon host at _host_ (`docker-daemon:` transport only)
-
-**--help**, **-h**
-
-Print usage statement
-
-**--no-creds** _bool-value_
-
-Access the registry anonymously.
+**--no-creds** _bool-value_ Access the registry anonymously.
 
 Additionally, the registry must allow deletions by setting `REGISTRY_STORAGE_DELETE_ENABLED=true` for the registry daemon.
 
-**--registry-token** _token_
-
-Bearer token for accessing the registry.
-
-**--retry-times**
-
-The number of times to retry. Retry wait time will be exponentially increased based on the number of failed attempts.
-
-**--shared-blob-dir** _directory_
-
-Directory to use to share blobs across OCI repositories.
-
-**--tls-verify**=_bool_
-
-Require HTTPS and verify certificates when talking to the container registry or daemon. Default to registry.conf setting.
-
-**--username**
-
-The username to access the registry.
-
-**--password**
-
-The password to access the registry.
+**--registry-token** _Bearer token_ for accessing the registry.
 
 ## EXAMPLES
 
@@ -87,3 +51,4 @@ skopeo(1), skopeo-login(1), docker-login(1), containers-auth.json(5)
 ## AUTHORS
 
 Antonio Murdaca <runcom@redhat.com>, Miloslav Trmac <mitr@redhat.com>, Jhon Honce <jhonce@redhat.com>
+

docs/skopeo-inspect.1.md

@@ -31,19 +31,11 @@ Output configuration in OCI format, default is to format in JSON format.
 
 Username and password for accessing the registry.
 
-**--daemon-host** _host_
-
-Use docker daemon host at _host_ (`docker-daemon:` transport only)
-
 **--format**, **-f**=*format*
 
 Format the output using the given Go template.
 The keys of the returned JSON can be used as the values for the --format flag (see examples below).
 
-**--help**, **-h**
-
-Print usage statement
-
 **--no-creds**
 
 Access the registry anonymously.
@@ -61,25 +53,9 @@ Registry token for accessing the registry.
 
 The number of times to retry; retry wait time will be exponentially increased based on the number of failed attempts.
 
-**--shared-blob-dir** _directory_
+**--tls-verify**
 
-Directory to use to share blobs across OCI repositories.
-
-**--tls-verify**=_bool_
-
-Require HTTPS and verify certificates when talking to the container registry or daemon. Default to registry.conf setting.
-
-**--username**
-
-The username to access the registry.
-
-**--password**
-
-The password to access the registry.
-
-**--no-tags**, **-n**=_bool_
-
-Do not list the available tags from the repository in the output. When `true`, the `RepoTags` array will be empty.  Defaults to `false`, which includes all available tags.
+Require HTTPS and verify certificates when talking to container registries (defaults to true).
 
 ## EXAMPLES
 
@@ -110,42 +86,6 @@ $ skopeo inspect docker://docker.io/fedora
 }
 ```
 
-To inspect python from the docker.io registry and not show the available tags:
-```sh
-$ skopeo inspect --no-tags docker://docker.io/library/python
-{
-    "Name": "docker.io/library/python",
-    "Digest": "sha256:5ca194a80ddff913ea49c8154f38da66a41d2b73028c5cf7e46bc3c1d6fda572",
-    "RepoTags": [],
-    "Created": "2021-10-05T23:40:54.936108045Z",
-    "DockerVersion": "20.10.7",
-    "Labels": null,
-    "Architecture": "amd64",
-    "Os": "linux",
-    "Layers": [
-        "sha256:df5590a8898bedd76f02205dc8caa5cc9863267dbcd8aac038bcd212688c1cc7",
-        "sha256:705bb4cb554eb7751fd21a994f6f32aee582fbe5ea43037db6c43d321763992b",
-        "sha256:519df5fceacdeaadeec563397b1d9f4d7c29c9f6eff879739cab6f0c144f49e1",
-        "sha256:ccc287cbeddc96a0772397ca00ec85482a7b7f9a9fac643bfddd87b932f743db",
-        "sha256:e3f8e6af58ed3a502f0c3c15dce636d9d362a742eb5b67770d0cfcb72f3a9884",
-        "sha256:aebed27b2d86a5a3a2cbe186247911047a7e432b9d17daad8f226597c0ea4276",
-        "sha256:54c32182bdcc3041bf64077428467109a70115888d03f7757dcf614ff6d95ebe",
-        "sha256:cc8b7caedab13af07adf4836e13af2d4e9e54d794129b0fd4c83ece6b1112e86",
-        "sha256:462c3718af1d5cdc050cfba102d06c26f78fe3b738ce2ca2eb248034b1738945"
-    ],
-    "Env": [
-        "PATH=/usr/local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
-        "LANG=C.UTF-8",
-        "GPG_KEY=A035C8C19219BA821ECEA86B64E628F8D684696D",
-        "PYTHON_VERSION=3.10.0",
-        "PYTHON_PIP_VERSION=21.2.4",
-        "PYTHON_SETUPTOOLS_VERSION=57.5.0",
-        "PYTHON_GET_PIP_URL=https://github.com/pypa/get-pip/raw/d781367b97acf0ece7e9e304bf281e99b618bf10/public/get-pip.py",
-        "PYTHON_GET_PIP_SHA256=01249aa3e58ffb3e1686b7141b4e9aac4d398ef4ac3012ed9dff8dd9f685ffe0"
-    ]
-}
-```
-
 ```
 $ /bin/skopeo inspect --config docker://registry.fedoraproject.org/fedora --format "{{ .Architecture }}"
 amd64

docs/skopeo-list-tags.1.md

@@ -1,55 +1,29 @@
 % skopeo-list-tags(1)
 
 ## NAME
-skopeo\-list\-tags - List tags in the transport-specific image repository.
+skopeo\-list\-tags - Return a list of tags for the transport-specific image repository.
 
 ## SYNOPSIS
-**skopeo list-tags** [*options*] _repository-name_
+**skopeo list-tags** _repository-name_
 
 Return a list of tags from _repository-name_ in a registry.
 
   _repository-name_ name of repository to retrieve tag listing from
 
-## OPTIONS
+  **--authfile** _path_
 
-**--authfile** _path_
-
-Path of the authentication file. Default is ${XDG\_RUNTIME\_DIR}/containers/auth.json, which is set using `skopeo login`.
+  Path of the authentication file. Default is ${XDG\_RUNTIME\_DIR}/containers/auth.json, which is set using `skopeo login`.
   If the authorization state is not found there, $HOME/.docker/config.json is checked, which is set using `docker login`.
 
-**--creds** _username[:password]_ for accessing the registry.
+  **--creds** _username[:password]_ for accessing the registry.
 
-**--cert-dir** _path_
+  **--cert-dir** _path_ Use certificates at _path_ (\*.crt, \*.cert, \*.key) to connect to the registry.
 
-Use certificates at _path_ (\*.crt, \*.cert, \*.key) to connect to the registry.
+  **--tls-verify** _bool-value_ Require HTTPS and verify certificates when talking to container registries (defaults to true).
 
-**--help**, **-h**
+  **--no-creds** _bool-value_ Access the registry anonymously.
 
-Print usage statement
-
-**--no-creds** _bool-value_
-
-Access the registry anonymously.
-
-**--registry-token** _Bearer token_
-
-Bearer token for accessing the registry.
-
-**--retry-times**
-
-The number of times to retry. Retry wait time will be exponentially increased based on the number of failed attempts.
-
-**--tls-verify**=_bool_
-
-Require HTTPS and verify certificates when talking to the container registry or daemon. Default to registry.conf setting.
-
-**--username**
-
-The username to access the registry.
-
-**--password**
-
-The password to access the registry.
+  **--registry-token** _Bearer token_ for accessing the registry.
 
 ## REPOSITORY NAMES
 
@@ -60,18 +34,18 @@ This commands refers to repositories using a _transport_`:`_details_ format. The
   **docker://**_docker-repository-reference_
   A repository in a registry implementing the "Docker Registry HTTP API V2". By default, uses the authorization state in either `$XDG_RUNTIME_DIR/containers/auth.json`, which is set using `(skopeo login)`. If the authorization state is not found there, `$HOME/.docker/config.json` is checked, which is set using `(docker login)`.
   A _docker-repository-reference_ is of the form: **registryhost:port/repositoryname** which is similar to an _image-reference_ but with no tag or digest allowed as the last component (e.g no `:latest` or `@sha256:xyz`)
-
+      
       Examples of valid docker-repository-references:
         "docker.io/myuser/myrepo"
         "docker.io/nginx"
         "docker.io/library/fedora"
         "localhost:5000/myrepository"
-
+        
       Examples of invalid references:
         "docker.io/nginx:latest"
         "docker.io/myuser/myimage:v1.0"
         "docker.io/myuser/myimage@sha256:f48c4cc192f4c3c6a069cb5cca6d0a9e34d6076ba7c214fd0cc3ca60e0af76bb"
-
+       
 
 ## EXAMPLES
 
@@ -127,3 +101,4 @@ skopeo(1), skopeo-login(1), docker-login(1), containers-auth.json(5)
 ## AUTHORS
 
 Zach Hill <zach@anchore.com>
+

docs/skopeo-login.1.md

@@ -4,7 +4,7 @@
 skopeo\-login - Login to a container registry.
 
 ## SYNOPSIS
-**skopeo login** [*options*] _registry_
+**skopeo login** [*options*] *registry*
 
 ## DESCRIPTION
 **skopeo login** logs into a specified registry server with the correct username
@@ -43,18 +43,16 @@ Return the logged-in user for the registry. Return error if no login is found.
 Use certificates at *path* (\*.crt, \*.cert, \*.key) to connect to the registry.
 Default certificates directory is _/etc/containers/certs.d_.
 
+**--tls-verify**=*true|false*
+
+Require HTTPS and verify certificates when contacting registries (default: true). If explicitly set to true,
+then TLS verification will be used. If set to false, then TLS verification will not be used. If not specified,
+TLS verification will be used unless the target registry is listed as an insecure registry in registries.conf.
+
 **--help**, **-h**
 
 Print usage statement
 
-**--tls-verify**=_bool_
-
-Require HTTPS and verify certificates when talking to the container registry or daemon. Default to registry.conf setting.
-
-**--verbose**, **-v**
-
-Write more detailed information to stdout
-
 ## EXAMPLES
 
 ```

docs/skopeo-logout.1.md

@@ -4,7 +4,7 @@
 skopeo\-logout - Logout of a container registry.
 
 ## SYNOPSIS
-**skopeo logout** [*options*] _registry_
+**skopeo logout** [*options*] *registry*
 
 ## DESCRIPTION
 **skopeo logout** logs out of a specified registry server by deleting the cached credentials
@@ -29,10 +29,6 @@ Remove the cached credentials for all registries in the auth file
 
 Print usage statement
 
-**--tls-verify**=_bool_
-
-Require HTTPS and verify certificates when talking to the container registry or daemon. Default to registry.conf setting.
-
 ## EXAMPLES
 
 ```

docs/skopeo-manifest-digest.1.md

@@ -10,12 +10,6 @@ skopeo\-manifest\-digest - Compute a manifest digest for a manifest-file and wri
 
 Compute a manifest digest of _manifest-file_ and write it to standard output.
 
-## OPTIONS
-
-**--help**, **-h**
-
-Print usage statement
-
 ## EXAMPLES
 
 ```sh
@@ -29,3 +23,4 @@ skopeo(1)
 ## AUTHORS
 
 Antonio Murdaca <runcom@redhat.com>, Miloslav Trmac <mitr@redhat.com>, Jhon Honce <jhonce@redhat.com>
+

docs/skopeo-standalone-sign.1.md

@@ -4,10 +4,11 @@
 skopeo\-standalone-sign - Debugging tool - Publish and sign an image in one step.
 
 ## SYNOPSIS
-**skopeo standalone-sign** [*options*] _manifest_ _docker-reference_ _key-fingerprint_ **--output**|**-o** _signature_
+**skopeo standalone-sign** _manifest docker-reference key-fingerprint_ **--output**|**-o** _signature_
 
 ## DESCRIPTION
-This is primarily a debugging tool, useful for special cases, and usually should not be a part of your normal operational workflow; use `skopeo copy --sign-by` instead to publish and sign an image in one step.
+This is primarily a debugging tool, or useful for special cases,
+and usually should not be a part of your normal operational workflow; use `skopeo copy --sign-by` instead to publish and sign an image in one step.
 
   _manifest_ Path to a file containing the image manifest
 
@@ -15,15 +16,7 @@ This is primarily a debugging tool, useful for special cases, and usually should
 
   _key-fingerprint_ Key identity to use for signing
 
-## OPTIONS
-
-**--help**, **-h**
-
-Print usage statement
-
-**--output**, **-o** _output file_
-
-Write signature to _output file_.
+  **--output**|**-o** output file
 
 ## EXAMPLES
 
@@ -32,13 +25,10 @@ $ skopeo standalone-sign busybox-manifest.json registry.example.com/example/busy
 $
 ```
 
-## NOTES
-
-This command is intended for use with local signatures e.g. OpenPGP ( other signature formats may be added in the future ), as per containers-signature(5). Furthermore, this command does **not** interact with the artifacts generated by Docker Content Trust (DCT). For more information, please see [containers-signature(5)](https://github.com/containers/image/blob/main/docs/containers-signature.5.md).
-
 ## SEE ALSO
 skopeo(1), skopeo-copy(1), containers-signature(5)
 
 ## AUTHORS
 
 Antonio Murdaca <runcom@redhat.com>, Miloslav Trmac <mitr@redhat.com>, Jhon Honce <jhonce@redhat.com>
+

docs/skopeo-standalone-verify.1.md

@@ -4,13 +4,11 @@
 skopeo\-standalone\-verify - Verify an image signature.
 
 ## SYNOPSIS
-**skopeo standalone-verify** _manifest_ _docker-reference_ _key-fingerprint_ _signature_
+**skopeo standalone-verify** _manifest docker-reference key-fingerprint signature_
 
 ## DESCRIPTION
 
-Verify a signature using local files; the digest will be printed on success. This is primarily a debugging tool, useful for special cases,
-and usually should not be a part of your normal operational workflow. Additionally, consider configuring a signature verification policy file,
-as per containers-policy.json(5).
+Verify a signature using local files, digest will be printed on success.
 
   _manifest_ Path to a file containing the image manifest
 
@@ -22,12 +20,6 @@ as per containers-policy.json(5).
 
 **Note:** If you do use this, make sure that the image can not be changed at the source location between the times of its verification and use.
 
-## OPTIONS
-
-**--help**, **-h**
-
-Print usage statement
-
 ## EXAMPLES
 
 ```sh
@@ -35,13 +27,10 @@ $ skopeo standalone-verify busybox-manifest.json registry.example.com/example/bu
 Signature verified, digest sha256:20bf21ed457b390829cdbeec8795a7bea1626991fda603e0d01b4e7f60427e55
 ```
 
-## NOTES
-
-This command is intended for use with local signatures e.g. OpenPGP ( other signature formats may be added in the future ), as per containers-signature(5). Furthermore, this command does **not** interact with the artifacts generated by Docker Content Trust (DCT). For more information, please see [containers-signature(5)](https://github.com/containers/image/blob/main/docs/containers-signature.5.md).
-
 ## SEE ALSO
-skopeo(1), containers-signature(5), containers-policy.json(5)
+skopeo(1), containers-signature(5)
 
 ## AUTHORS
 
 Antonio Murdaca <runcom@redhat.com>, Miloslav Trmac <mitr@redhat.com>, Jhon Honce <jhonce@redhat.com>
+

docs/skopeo-sync.1.md

@@ -5,7 +5,7 @@ skopeo\-sync - Synchronize images between container registries and local directo
 
 
 ## SYNOPSIS
-**skopeo sync** [*options*] --src _transport_ --dest _transport_ _source_ _destination_
+**skopeo sync** --src _transport_ --dest _transport_ _source_ _destination_
 
 ## DESCRIPTION
 Synchronize images between container registries and local directories.
@@ -32,7 +32,7 @@ When the `--scoped` option is specified, images are prefixed with the source ima
 name can be stored at _destination_.
 
 ## OPTIONS
-**--all**, **-a**
+**--all**
 If one of the images in __src__ refers to a list of images, instead of copying just the image which matches the current OS and
 architecture (subject to the use of the global --override-os, --override-arch and --override-variant options), attempt to copy all of
 the images in the list, and the list itself.
@@ -50,21 +50,15 @@ Path of the authentication file for the source registry. Uses path given by `--a
 
 Path of the authentication file for the destination registry. Uses path given by `--authfile`, if not provided.
 
-**--src**, **-s** _transport_ Transport for the source repository.
+**--src** _transport_ Transport for the source repository.
 
-**--dest**, **-d** _transport_ Destination transport.
-
-**--format**, **-f** _manifest-type_ Manifest Type (oci, v2s1, or v2s2) to use when syncing image(s) to a destination (default is manifest type of source, with fallbacks).
-
-**--help**, **-h**
-
-Print usage statement.
+**--dest** _transport_ Destination transport.
 
 **--scoped** Prefix images with the source image path, so that multiple images with the same name can be stored at _destination_.
 
 **--remove-signatures** Do not copy signatures, if any, from _source-image_. This is necessary when copying a signed image to a destination which does not support signatures.
 
-**--sign-by**=_key-id_ Add a signature using that key ID for an image name corresponding to _destination-image_.
+**--sign-by=**_key-id_ Add a signature using that key ID for an image name corresponding to _destination-image_.
 
 **--src-creds** _username[:password]_ for accessing the source registry.
 
@@ -74,39 +68,18 @@ Print usage statement.
 
 **--src-no-creds** _bool-value_ Access the registry anonymously.
 
-**--src-tls-verify** _bool-value_ Require HTTPS and verify certificates when talking to a container source registry or daemon. Default to source registry entry in registry.conf setting.
+**--src-tls-verify** _bool-value_ Require HTTPS and verify certificates when talking to a container source registry or daemon (defaults to true).
 
 **--dest-cert-dir** _path_ Use certificates (*.crt, *.cert, *.key) at _path_ to connect to the destination registry or daemon.
 
 **--dest-no-creds** _bool-value_  Access the registry anonymously.
 
-**--dest-tls-verify** _bool-value_ Require HTTPS and verify certificates when talking to a container destination registry or daemon. Default to destination registry entry in registry.conf setting.
+**--dest-tls-verify** _bool-value_ Require HTTPS and verify certificates when talking to a container destination registry or daemon (defaults to true).
 
 **--src-registry-token** _Bearer token_ for accessing the source registry.
 
 **--dest-registry-token** _Bearer token_ for accessing the destination registry.
 
-**--retry-times**  the number of times to retry, retry wait time will be exponentially increased based on the number of failed attempts.
-
-**--keep-going**
-If any errors occur during copying of images, those errors are logged and the process continues syncing rest of the images and finally fails at the end.
-
-**--src-username**
-
-The username to access the source registry.
-
-**--src-password**
-
-The password to access the source registry.
-
-**--dest-username**
-
-The username to access the destination registry.
-
-**--dest-password**
-
-The password to access the destination registry.
-
 ## EXAMPLES
 
 ### Synchronizing to a local directory

docs/skopeo.1.md

@@ -51,64 +51,42 @@ See [containers-transports(5)](https://github.com/containers/image/blob/master/d
 
 ## OPTIONS
 
-**--command-timeout** _duration_
+  **--command-timeout** _duration_ Timeout for the command execution.
 
-Timeout for the command execution.
+  **--debug** enable debug output
 
-**--debug**
+  **--help**|**-h** Show help
 
-enable debug output
+  **--insecure-policy** Adopt an insecure, permissive policy that allows anything. This obviates the need for a policy file.
 
-**--help**, **-h**
+  **--override-arch** _arch_ Use _arch_ instead of the architecture of the machine for choosing images.
 
-Show help
+  **--override-os** _OS_ Use _OS_ instead of the running OS for choosing images.
 
-**--insecure-policy**
+  **--override-variant** _VARIANT_ Use _VARIANT_ instead of the running architecture variant for choosing images.
 
-Adopt an insecure, permissive policy that allows anything. This obviates the need for a policy file.
+  **--policy** _path-to-policy_ Path to a policy.json file to use for verifying signatures and deciding whether an image is trusted, overriding the default trust policy file.
 
-**--override-arch** _arch_
+  **--registries.d** _dir_ use registry configuration files in _dir_ (e.g. for container signature storage), overriding the default path.
 
-Use _arch_ instead of the architecture of the machine for choosing images.
+  **--tmpdir** _dir_ used to store temporary files. Defaults to /var/tmp.
 
-**--override-os** _os_
-
-Use _OS_ instead of the running OS for choosing images.
-
-**--override-variant** _variant_
-
-Use _variant_ instead of the running architecture variant for choosing images.
-
-**--policy** _path-to-policy_
-
-Path to a policy.json file to use for verifying signatures and deciding whether an image is trusted, overriding the default trust policy file.
-
-**--registries.d** _dir_
-
-Use registry configuration files in _dir_ (e.g. for container signature storage), overriding the default path.
-
-**--tmpdir** _dir_
-
-Directory used to store temporary files. Defaults to /var/tmp.
-
-**--version**, **-v**
-
-Print the version number
+  **--version**|**-v** print the version number
 
 ## COMMANDS
 
 | Command                                   | Description                                                                    |
 | ----------------------------------------- | ------------------------------------------------------------------------------ |
 | [skopeo-copy(1)](skopeo-copy.1.md)        | Copy an image (manifest, filesystem layers, signatures) from one location to another. |
-| [skopeo-delete(1)](skopeo-delete.1.md)    | Mark the _image-name_ for later deletion by the registry's garbage collector.  |
-| [skopeo-inspect(1)](skopeo-inspect.1.md)  | Return low-level information about _image-name_ in a registry.                 |
-| [skopeo-list-tags(1)](skopeo-list-tags.1.md)  | List tags in the transport-specific image repository.                      |
+| [skopeo-delete(1)](skopeo-delete.1.md)    | Mark image-name for deletion.                                                  |
+| [skopeo-inspect(1)](skopeo-inspect.1.md)  | Return low-level information about image-name in a registry.                   |
+| [skopeo-list-tags(1)](skopeo-list-tags.1.md)  | List the tags for the given transport/repository.                           |
 | [skopeo-login(1)](skopeo-login.1.md)  | Login to a container registry. |
 | [skopeo-logout(1)](skopeo-logout.1.md)  | Logout of a container registry. |
-| [skopeo-manifest-digest(1)](skopeo-manifest-digest.1.md)    | Compute a manifest digest for a manifest-file and write it to standard output. |
-| [skopeo-standalone-sign(1)](skopeo-standalone-sign.1.md)    | Debugging tool - Publish and sign an image in one step.      |
-| [skopeo-standalone-verify(1)](skopeo-standalone-verify.1.md)| Verify an image signature.                                   |
-| [skopeo-sync(1)](skopeo-sync.1.md)| Synchronize images between container registries and local directories.                 |
+| [skopeo-manifest-digest(1)](skopeo-manifest-digest.1.md)    | Compute a manifest digest of manifest-file and write it to standard output.|
+| [skopeo-standalone-sign(1)](skopeo-standalone-sign.1.md)    | Sign an image.                                               |
+| [skopeo-standalone-verify(1)](skopeo-standalone-verify.1.md)| Verify an image.                                             |
+| [skopeo-sync(1)](skopeo-sync.1.md)| Copy images from one or more repositories to a user specified destination.             |
 
 ## FILES
   **/etc/containers/policy.json**

go.mod

@@ -3,22 +3,28 @@ module github.com/containers/skopeo
 go 1.12
 
 require (
-	github.com/containers/common v0.46.1-0.20211026130826-7abfd453c86f
-	github.com/containers/image/v5 v5.16.2-0.20211021181114-25411654075f
-	github.com/containers/ocicrypt v1.1.2
-	github.com/containers/storage v1.37.0
-	github.com/docker/docker v20.10.10+incompatible
-	github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5 // indirect
+	github.com/containers/common v0.33.4
+	github.com/containers/image/v5 v5.10.2
+	github.com/containers/ocicrypt v1.0.3
+	github.com/containers/storage v1.24.6
+	github.com/docker/docker v17.12.0-ce-rc1.0.20201020191947-73dc6a680cdd+incompatible
+	github.com/dsnet/compress v0.0.1 // indirect
+	github.com/go-check/check v0.0.0-20180628173108-788fd7840127
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/moby/term v0.0.0-20201110203204-bea5bbe245bf // indirect
 	github.com/opencontainers/go-digest v1.0.0
-	github.com/opencontainers/image-spec v1.0.2-0.20210819154149-5ad6f50d6283
-	github.com/opencontainers/image-tools v1.0.0-rc3
+	github.com/opencontainers/image-spec v1.0.2-0.20190823105129-775207bd45b6
+	github.com/opencontainers/image-tools v0.0.0-20170926011501-6d941547fa1d
+	github.com/opencontainers/runc v1.0.0-rc92 // indirect
 	github.com/pkg/errors v0.9.1
 	github.com/russross/blackfriday v2.0.0+incompatible // indirect
-	github.com/sirupsen/logrus v1.8.1
-	github.com/spf13/cobra v1.2.1
+	github.com/sirupsen/logrus v1.7.0
+	github.com/spf13/cobra v1.1.1
 	github.com/spf13/pflag v1.0.5
 	github.com/stretchr/testify v1.7.0
-	github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635
-	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c
+	github.com/syndtr/gocapability v0.0.0-20180916011248-d98352740cb2
+	go4.org v0.0.0-20190218023631-ce4c26f7be8e // indirect
+	golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad // indirect
 	gopkg.in/yaml.v2 v2.4.0
+	gotest.tools/v3 v3.0.3 // indirect
 )

hack/get_ci_vm.sh

@@ -1,61 +0,0 @@
-#!/usr/bin/env bash
-
-#
-# For help and usage information, simply execute the script w/o any arguments.
-#
-# This script is intended to be run by Red Hat skopeo developers who need
-# to debug problems specifically related to Cirrus-CI automated testing.
-# It requires that you have been granted prior access to create VMs in
-# google-cloud.  For non-Red Hat contributors, VMs are available as-needed,
-# with supervision upon request.
-
-set -e
-
-SCRIPT_FILEPATH=$(realpath "${BASH_SOURCE[0]}")
-SCRIPT_DIRPATH=$(dirname "$SCRIPT_FILEPATH")
-REPO_DIRPATH=$(realpath "$SCRIPT_DIRPATH/../")
-
-# Help detect if we were called by get_ci_vm container
-GET_CI_VM="${GET_CI_VM:-0}"
-in_get_ci_vm() {
-    if ((GET_CI_VM==0)); then
-        echo "Error: $1 is not intended for use in this context"
-        exit 2
-    fi
-}
-
-# get_ci_vm APIv1 container entrypoint calls into this script
-# to obtain required repo. specific configuration options.
-if [[ "$1" == "--config" ]]; then
-    in_get_ci_vm "$1"
-    cat <<EOF
-DESTDIR="/var/tmp/go/src/github.com/containers/skopeo"
-UPSTREAM_REPO="https://github.com/containers/skopeo.git"
-GCLOUD_PROJECT="skopeo"
-GCLOUD_IMGPROJECT="libpod-218412"
-GCLOUD_CFG="skopeo"
-GCLOUD_ZONE="${GCLOUD_ZONE:-us-central1-f}"
-GCLOUD_CPUS="2"
-GCLOUD_MEMORY="4Gb"
-GCLOUD_DISK="200"
-EOF
-elif [[ "$1" == "--setup" ]]; then
-    in_get_ci_vm "$1"
-    # get_ci_vm container entrypoint calls us with this option on the
-    # Cirrus-CI environment instance, to perform repo.-specific setup.
-    echo "+ Executing setup" > /dev/stderr
-    ${GOSRC}/${SCRIPT_BASE}/runner.sh setup
-else
-    # Create and access VM for specified Cirrus-CI task
-    mkdir -p $HOME/.config/gcloud/ssh
-    podman run -it --rm \
-        --tz=local \
-        -e NAME="$USER" \
-        -e SRCDIR=/src \
-        -e GCLOUD_ZONE="$GCLOUD_ZONE" \
-        -e DEBUG="${DEBUG:-0}" \
-        -v $REPO_DIRPATH:/src:O \
-        -v $HOME/.config/gcloud:/root/.config/gcloud:z \
-        -v $HOME/.config/gcloud/ssh:/root/.ssh:z \
-        quay.io/libpod/get_ci_vm:latest "$@"
-fi

hack/get_fqin.sh

@@ -1,34 +0,0 @@
-#!/usr/bin/env bash
-
-# This script is intended to be called from the Makefile.  It's purpose
-# is to automation correspondence between the environment used for local
-# development and CI.
-
-set -e
-
-SCRIPT_FILEPATH=$(realpath "${BASH_SOURCE[0]}")
-SCRIPT_DIRPATH=$(dirname "$SCRIPT_FILEPATH")
-REPO_DIRPATH=$(realpath "$SCRIPT_DIRPATH/../")
-
-# When running under CI, we already have the necessary information,
-# simply provide it to the Makefile.
-if [[ -n "$SKOPEO_CIDEV_CONTAINER_FQIN" ]]; then
-    echo "$SKOPEO_CIDEV_CONTAINER_FQIN"
-    exit 0
-fi
-
-if [[ -n $(command -v podman) ]]; then CONTAINER_RUNTIME=podman; fi
-CONTAINER_RUNTIME=${CONTAINER_RUNTIME:-docker}
-
-# Borrow the get_ci_vm container image since it's small, and
-# by necessity contains a script that can accurately interpret
-# env. var. values from any .cirrus.yml runtime context.
-$CONTAINER_RUNTIME run --rm \
-    --security-opt label=disable \
-    -v $REPO_DIRPATH:/src:ro \
-    --entrypoint=/usr/share/automation/bin/cirrus-ci_env.py \
-    quay.io/libpod/get_ci_vm:latest \
-    --envs="Skopeo Test" /src/.cirrus.yml | \
-    egrep -m1 '^SKOPEO_CIDEV_CONTAINER_FQIN' | \
-    awk -F "=" -e '{print $2}' | \
-    tr -d \'\"

hack/libsubid_tag.sh

@@ -1,19 +0,0 @@
-#!/usr/bin/env bash
-if test $(${GO:-go} env GOOS) != "linux" ; then
-	exit 0
-fi
-tmpdir="$PWD/tmp.$RANDOM"
-mkdir -p "$tmpdir"
-trap 'rm -fr "$tmpdir"' EXIT
-cc -o "$tmpdir"/libsubid_tag -l subid -x c - > /dev/null 2> /dev/null << EOF
-#include <shadow/subid.h>
-int main() {
-	struct subid_range *ranges = NULL;
-	get_subuid_ranges("root", &ranges);
-	free(ranges);
-	return 0;
-}
-EOF
-if test $? -eq 0 ; then
-	echo libsubid
-fi

hack/make.sh

@@ -2,14 +2,15 @@
 set -e
 
 # This script builds various binary from a checkout of the skopeo
-# source code. DO NOT CALL THIS SCRIPT DIRECTLY.
+# source code.
 #
 # Requirements:
 # - The current directory should be a checkout of the skopeo source code
 #   (https://github.com/containers/skopeo). Whatever version is checked out
 #   will be built.
-# - The script is intended to be run inside the container specified
-#   in the output of hack/get_fqin.sh
+# - The script is intended to be run inside the docker container specified
+#   in the Dockerfile at the root of the source. In other words:
+#   DO NOT CALL THIS SCRIPT DIRECTLY.
 # - The right way to call this script is to invoke "make" from
 #   your checkout of the skopeo repository.
 #   the Makefile will do a "docker build -t skopeo ." and then
@@ -22,19 +23,22 @@ export SKOPEO_PKG='github.com/containers/skopeo'
 export SCRIPTDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 export MAKEDIR="$SCRIPTDIR/make"
 
-# Set this to 1 to enable installation/modification of environment/services
-export SKOPEO_CONTAINER_TESTS=${SKOPEO_CONTAINER_TESTS:-0}
+# We're a nice, sexy, little shell script, and people might try to run us;
+# but really, they shouldn't. We want to be in a container!
+inContainer="AssumeSoInitially"
+if [ "$PWD" != "/go/src/$SKOPEO_PKG" ]; then
+	unset inContainer
+fi
 
-if [[ "$SKOPEO_CONTAINER_TESTS" == "0" ]] && [[ "$CI" != "true" ]]; then
-    (
-    echo "***************************************************************"
-    echo "WARNING: Executing tests directly on the local development"
-    echo "         host is highly discouraged.  Many important items"
-    echo "         will be skipped.  For manual execution, please utilize"
-    echo "         the Makefile targets WITHOUT the '-local' suffix."
-    echo "***************************************************************"
-    ) > /dev/stderr
-    sleep 5s
+if [ -z "$inContainer" ]; then
+	{
+		echo "# WARNING! I don't seem to be running in a Docker container."
+		echo "# The result of this command might be an incorrect build, and will not be"
+		echo "# officially supported."
+		echo "#"
+		echo "# Try this instead: make all"
+		echo "#"
+	} >&2
 fi
 
 echo
@@ -53,6 +57,8 @@ DEFAULT_BUNDLES=(
 	test-integration
 )
 
+TESTFLAGS+=" -test.timeout=15m"
+
 # Go module support: set `-mod=vendor` to use the vendored sources
 # See also the top-level Makefile.
 mod_vendor=
@@ -61,6 +67,16 @@ if go help mod >/dev/null 2>&1; then
   mod_vendor='-mod=vendor'
 fi
 
+# If $TESTFLAGS is set in the environment, it is passed as extra arguments to 'go test'.
+# You can use this to select certain tests to run, eg.
+#
+#     TESTFLAGS='-test.run ^TestBuild$' ./hack/make.sh test-unit
+#
+# For integration-cli test, we use [gocheck](https://labix.org/gocheck), if you want
+# to run certain tests on your local host, you should run with command:
+#
+#     TESTFLAGS='-check.f DockerSuite.TestBuild*' ./hack/make.sh binary test-integration-cli
+#
 go_test_dir() {
 	dir=$1
 	(

hack/make/.validate

@@ -5,7 +5,7 @@ if [ -z "$VALIDATE_UPSTREAM" ]; then
 	# are running more than one validate bundlescript
 	
 	VALIDATE_REPO='https://github.com/containers/skopeo.git'
-	VALIDATE_BRANCH='main'
+	VALIDATE_BRANCH='master'
 	
 	if [ "$TRAVIS" = 'true' -a "$TRAVIS_PULL_REQUEST" != 'false' ]; then
 		VALIDATE_REPO="https://github.com/${TRAVIS_REPO_SLUG}.git"

hack/make/test-integration

@@ -2,11 +2,13 @@
 set -e
 
 bundle_test_integration() {
+	TESTFLAGS="$TESTFLAGS -check.v"
 	go_test_dir ./integration
 }
 
 # subshell so that we can export PATH without breaking other things
 (
-	make PREFIX=/usr install
+	make bin/skopeo ${BUILDTAGS:+BUILDTAGS="$BUILDTAGS"}
+	make install
 	bundle_test_integration
 ) 2>&1

hack/make/test-system

@@ -11,7 +11,8 @@ sed -i \
     /etc/containers/storage.conf
 
 # Build skopeo, install into /usr/bin
-make PREFIX=/usr install
+make bin/skopeo ${BUILDTAGS:+BUILDTAGS="$BUILDTAGS"}
+make install
 
 # Run tests
 SKOPEO_BINARY=/usr/bin/skopeo bats --tap systemtest

hack/make/validate-vet

@@ -1,6 +1,6 @@
 #!/bin/bash
 
-errors=$(go vet -tags="${BUILDTAGS}" $mod_vendor $(go list $mod_vendor -e ./...))
+errors=$(go vet $mod_vendor $(go list $mod_vendor -e ./...))
 
 if [ -z "$errors" ]; then
 	echo 'Congratulations!  All Go source files have been vetted.'

hack/man-page-checker

@@ -1,150 +0,0 @@
-#!/usr/bin/env bash
-#
-# man-page-checker - validate and cross-reference man page names
-#
-# This is the script that cross-checks BETWEEN MAN PAGES. It is not the
-# script that cross-checks that each option in skopeo foo --help is listed
-# in skopeo-foo.1.md and vice-versa; that one is xref-helpmsgs-manpages.
-#
-
-verbose=
-for i; do
-    case "$i" in
-        -v|--verbose)   verbose=verbose ;;
-    esac
-done
-
-
-die() {
-    echo "$(basename $0): $*" >&2
-    exit 1
-}
-
-cd $(dirname $0)/../docs || die "Please run me from top-level skopeo dir"
-
-rc=0
-
-# Pass 1: cross-check file names with NAME section
-#
-# for a given skopeo-foo.1.md, the NAME should be 'skopeo-foo'
-for md in *.1.md;do
-    # Read the first line after '## NAME'
-    name=$(egrep -A1 '^## NAME' $md|tail -1|awk '{print $1}' | tr -d \\\\)
-
-    expect=$(basename $md .1.md)
-    if [ "$name" != "$expect" ]; then
-        echo
-        printf "Inconsistent program NAME in %s:\n" $md
-        printf "  NAME= %s  (expected: %s)\n" $name $expect
-        rc=1
-    fi
-done
-
-# Pass 2: compare descriptions.
-#
-# Make sure the descriptive text in skopeo-foo.1.md matches the one
-# in the table in skopeo.1.md.
-for md in $(ls -1 *-*.1.md);do
-    desc=$(egrep -A1 '^## NAME' $md|tail -1|sed -E -e 's/^skopeo[^[:space:]]+ - //')
-
-    # Find the descriptive text in the main skopeo man page.
-    parent=skopeo.1.md
-    parent_desc=$(grep $md $parent | awk -F'|' '{print $3}' | sed -E -e 's/^[[:space:]]+//' -e 's/[[:space:]]+$//')
-
-    if [ "$desc" != "$parent_desc" ]; then
-        echo
-        printf "Inconsistent subcommand descriptions:\n"
-        printf "  %-32s = '%s'\n" $md "$desc"
-        printf "  %-32s = '%s'\n" $parent "$parent_desc"
-        printf "Please ensure that the NAME section of $md\n"
-        printf "matches the subcommand description in $parent\n"
-        rc=1
-    fi
-done
-
-# Helper function: compares man page synopsis vs --help usage message
-function compare_usage() {
-    local cmd="$1"
-    local from_man="$2"
-
-    # Run 'cmd --help', grab the line immediately after 'Usage:'
-    local help_output=$(../bin/$cmd --help)
-    local from_help=$(echo "$help_output" | grep -A1 '^Usage:' | tail -1)
-
-    # strip off command name from both
-    from_man=$(sed -E -e "s/\*\*$cmd\*\*[[:space:]]*//" <<<"$from_man")
-    from_help=$(sed -E -e "s/^[[:space:]]*$cmd[[:space:]]*//" <<<"$from_help")
-
-    # man page lists 'foo [*options*]', help msg shows 'foo [command options]'.
-    # Make sure if one has it, the other does too.
-    if expr "$from_man" : "\[\*options\*\]" >/dev/null; then
-        if expr "$from_help" : "\[command options\]" >/dev/null; then
-            :
-        else
-            echo "WARNING: $cmd: man page shows '[*options*]', help does not show [command options]"
-            rc=1
-       fi
-    elif expr "$from_help" : "\[command options\]" >/dev/null; then
-        echo "WARNING: $cmd: --help shows [command options], man page does not show [*options*]"
-        rc=1
-    fi
-
-    # Strip off options and flags; start comparing arguments
-    from_man=$(sed  -E -e 's/^\[\*options\*\][[:space:]]*//' <<<"$from_man")
-    from_help=$(sed -E -e 's/^\[command options\][[:space:]]*//'      <<<"$from_help")
-
-    # Constant strings in man page are '**foo**', in --help are 'foo'.
-    from_man=$(sed -E -e 's/\*\*([^*]+)\*\*/\1/g' <<<"$from_man")
-
-    # Args in man page are '_foo_', in --help are 'FOO'. Convert all to
-    # UPCASE simply because it stands out better to the eye.
-    from_man=$(sed -E -e 's/_([a-z-]+)_/\U\1/g' <<<"$from_man")
-
-    # Compare man-page and --help usage strings. Skip 'skopeo' itself,
-    # because the man page includes '[global options]' which we don't grok.
-    if [[ "$from_man" != "$from_help" && "$cmd" != "skopeo" ]]; then
-        printf "%-25s man='%s' help='%s'\n" "$cmd:" "$from_man" "$from_help"
-        rc=1
-    fi
-}
-
-# Pass 3: compare synopses.
-#
-# Make sure the SYNOPSIS line in skopeo-foo.1.md reads '**skopeo foo** ...'
-for md in *.1.md;do
-    synopsis=$(egrep -A1 '^#* SYNOPSIS' $md|tail -1)
-
-    # Command name must be bracketed by double asterisks; options and
-    # arguments are bracketed by single ones.
-    #   E.g. '**skopeo copy** [*options*] _..._'
-    # Get the command name, and confirm that it matches the md file name.
-    cmd=$(echo "$synopsis" | sed -E -e 's/^\*\*([^*]+)\*\*.*/\1/' | tr -d \*)
-    # Use sed, not tr, so we only replace the first dash: we want
-    # skopeo-list-tags -> "skopeo list-tags", not "skopeo list tags"
-    md_nodash=$(basename "$md" .1.md | sed -e 's/-/ /')
-    if [ "$cmd" != "$md_nodash" ]; then
-        echo
-        printf "Inconsistent program name in SYNOPSIS in %s:\n" $md
-        printf "  SYNOPSIS = %s (expected: '%s')\n" "$cmd" "$md_nodash"
-        rc=1
-    fi
-
-    # The convention is to use UPPER CASE in 'skopeo foo --help',
-    # but *lower case bracketed by asterisks* in the man page
-    if expr "$synopsis" : ".*[A-Z]" >/dev/null; then
-        echo
-        printf "Inconsistent capitalization in SYNOPSIS in %s\n" $md
-        printf "  '%s' should not contain upper-case characters\n" "$synopsis"
-        rc=1
-    fi
-
-    # (for debugging, and getting a sense of standard conventions)
-    #printf "  %-32s ------ '%s'\n" $md "$synopsis"
-
-    # If bin/skopeo is available, run "cmd --help" and compare Usage
-    # messages. This is complicated, so do it in a helper function.
-    compare_usage "$md_nodash" "$synopsis"
-done
-
-
-exit $rc

hack/travis_osx.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+set -e
+
+export GOPATH=$(pwd)/_gopath
+export PATH=$GOPATH/bin:$PATH
+
+_containers="${GOPATH}/src/github.com/containers"
+mkdir -vp ${_containers}
+ln -vsf $(pwd) ${_containers}/skopeo
+
+go version
+GO111MODULE=off go get -u github.com/cpuguy83/go-md2man golang.org/x/lint/golint
+
+cd ${_containers}/skopeo
+make validate-local test-unit-local bin/skopeo
+sudo make install
+skopeo -v

hack/xref-helpmsgs-manpages

@@ -1,277 +0,0 @@
-#!/usr/bin/perl
-#
-# xref-helpmsgs-manpages - cross-reference --help options against man pages
-#
-package LibPod::CI::XrefHelpmsgsManpages;
-
-use v5.14;
-use utf8;
-
-use strict;
-use warnings;
-
-(our $ME = $0) =~ s|.*/||;
-our $VERSION = '0.1';
-
-# For debugging, show data structures using DumpTree($var)
-#use Data::TreeDumper; $Data::TreeDumper::Displayaddress = 0;
-
-# unbuffer output
-$| = 1;
-
-###############################################################################
-# BEGIN user-customizable section
-
-# Path to skopeo executable
-my $Default_Skopeo = './bin/skopeo';
-my $SKOPEO = $ENV{SKOPEO} || $Default_Skopeo;
-
-# Path to all doc files (markdown)
-my $Docs_Path = 'docs';
-
-# Global error count
-my $Errs = 0;
-
-# END   user-customizable section
-###############################################################################
-
-###############################################################################
-# BEGIN boilerplate args checking, usage messages
-
-sub usage {
-    print  <<"END_USAGE";
-Usage: $ME [OPTIONS]
-
-$ME recursively runs 'skopeo --help' against
-all subcommands; and recursively reads skopeo-*.1.md files
-in $Docs_Path, then cross-references that each --help
-option is listed in the appropriate man page and vice-versa.
-
-$ME invokes '\$SKOPEO' (default: $Default_Skopeo).
-
-Exit status is zero if no inconsistencies found, one otherwise
-
-OPTIONS:
-
-  -v, --verbose  show verbose progress indicators
-  -n, --dry-run  make no actual changes
-
-  --help         display this message
-  --version      display program name and version
-END_USAGE
-
-    exit;
-}
-
-# Command-line options.  Note that this operates directly on @ARGV !
-our $debug   = 0;
-our $verbose = 0;
-sub handle_opts {
-    use Getopt::Long;
-    GetOptions(
-        'debug!'     => \$debug,
-        'verbose|v'  => \$verbose,
-
-        help         => \&usage,
-        version      => sub { print "$ME version $VERSION\n"; exit 0 },
-    ) or die "Try `$ME --help' for help\n";
-}
-
-# END   boilerplate args checking, usage messages
-###############################################################################
-
-############################## CODE BEGINS HERE ###############################
-
-# The term is "modulino".
-__PACKAGE__->main()                                     unless caller();
-
-# Main code.
-sub main {
-    # Note that we operate directly on @ARGV, not on function parameters.
-    # This is deliberate: it's because Getopt::Long only operates on @ARGV
-    # and there's no clean way to make it use @_.
-    handle_opts();                      # will set package globals
-
-    # Fetch command-line arguments.  Barf if too many.
-    die "$ME: Too many arguments; try $ME --help\n"                 if @ARGV;
-
-    my $help = skopeo_help();
-    my $man  = skopeo_man('skopeo');
-
-    xref_by_help($help, $man);
-    xref_by_man($help, $man);
-
-    exit !!$Errs;
-}
-
-###############################################################################
-# BEGIN cross-referencing
-
-##################
-#  xref_by_help  #  Find keys in '--help' but not in man
-##################
-sub xref_by_help {
-    my ($help, $man, @subcommand) = @_;
-
-    for my $k (sort keys %$help) {
-        if (exists $man->{$k}) {
-            if (ref $help->{$k}) {
-                xref_by_help($help->{$k}, $man->{$k}, @subcommand, $k);
-            }
-            # Otherwise, non-ref is leaf node such as a --option
-        }
-        else {
-            my $man = $man->{_path} || 'man';
-            warn "$ME: skopeo @subcommand --help lists $k, but $k not in $man\n";
-            ++$Errs;
-        }
-    }
-}
-
-#################
-#  xref_by_man  #  Find keys in man pages but not in --help
-#################
-#
-# In an ideal world we could share the functionality in one function; but
-# there are just too many special cases in man pages.
-#
-sub xref_by_man {
-    my ($help, $man, @subcommand) = @_;
-
-    # FIXME: this generates way too much output
-    for my $k (grep { $_ ne '_path' } sort keys %$man) {
-        if (exists $help->{$k}) {
-            if (ref $man->{$k}) {
-                xref_by_man($help->{$k}, $man->{$k}, @subcommand, $k);
-            }
-        }
-        elsif ($k ne '--help' && $k ne '-h') {
-            my $man = $man->{_path} || 'man';
-
-            warn "$ME: skopeo @subcommand: $k in $man, but not --help\n";
-            ++$Errs;
-        }
-    }
-}
-
-# END   cross-referencing
-###############################################################################
-# BEGIN data gathering
-
-#################
-#  skopeo_help  #  Parse output of 'skopeo [subcommand] --help'
-#################
-sub skopeo_help {
-    my %help;
-    open my $fh, '-|', $SKOPEO, @_, '--help'
-        or die "$ME: Cannot fork: $!\n";
-    my $section = '';
-    while (my $line = <$fh>) {
-        # Cobra is blessedly consistent in its output:
-        #    Usage: ...
-        #    Available Commands:
-        #       ....
-        #    Options:
-        #       ....
-        #
-        # Start by identifying the section we're in...
-        if ($line =~ /^Available\s+(Commands):/) {
-            $section = lc $1;
-        }
-        elsif ($line =~ /^(Flags):/) {
-            $section = lc $1;
-        }
-
-        # ...then track commands and options. For subcommands, recurse.
-        elsif ($section eq 'commands') {
-            if ($line =~ /^\s{1,4}(\S+)\s/) {
-                my $subcommand = $1;
-                print "> skopeo @_ $subcommand\n"               if $debug;
-                $help{$subcommand} = skopeo_help(@_, $subcommand)
-                    unless $subcommand eq 'help';       # 'help' not in man
-            }
-        }
-        elsif ($section eq 'flags') {
-            # Handle '--foo' or '-f, --foo'
-            if ($line =~ /^\s{1,10}(--\S+)\s/) {
-                print "> skopeo @_ $1\n"                        if $debug;
-                $help{$1} = 1;
-            }
-            elsif ($line =~ /^\s{1,10}(-\S),\s+(--\S+)\s/) {
-                print "> skopeo @_ $1, $2\n"                    if $debug;
-                $help{$1} = $help{$2} = 1;
-            }
-        }
-    }
-    close $fh
-        or die "$ME: Error running 'skopeo @_ --help'\n";
-
-    return \%help;
-}
-
-
-################
-#  skopeo_man  #  Parse contents of skopeo-*.1.md
-################
-sub skopeo_man {
-    my $command = shift;
-    my $manpath = "$Docs_Path/$command.1.md";
-    print "** $manpath \n"                              if $debug;
-
-    my %man = (_path => $manpath);
-    open my $fh, '<', $manpath
-        or die "$ME: Cannot read $manpath: $!\n";
-    my $section = '';
-    my @most_recent_flags;
-    my $previous_subcmd = '';
-    while (my $line = <$fh>) {
-        chomp $line;
-        next unless $line;		# skip empty lines
-
-        # .md files designate sections with leading double hash
-        if ($line =~ /^##\s*OPTIONS/) {
-            $section = 'flags';
-        }
-        elsif ($line =~ /^\#\#\s+(SUB)?COMMANDS/) {
-            $section = 'commands';
-        }
-        elsif ($line =~ /^\#\#[^#]/) {
-            $section = '';
-        }
-
-        # This will be a table containing subcommand names, links to man pages.
-        elsif ($section eq 'commands') {
-            # In skopeo.1.md
-            if ($line =~ /^\|\s*\[skopeo-(\S+?)\(\d\)\]/) {
-                # $1 will be changed by recursion _*BEFORE*_ left-hand assignment
-                my $subcmd = $1;
-                $man{$subcmd} = skopeo_man("skopeo-$1");
-            }
-        }
-
-        # Options should always be of the form '**-f**' or '**\-\-flag**',
-        # possibly separated by comma-space.
-        elsif ($section eq 'flags') {
-            # If option has long and short form, long must come first.
-            # This is a while-loop because there may be multiple long
-            # option names (not in skopeo ATM, but leave the possibility open)
-            while ($line =~ s/^\*\*(--[a-z0-9.-]+)\*\*(=\*[a-zA-Z0-9-]+\*)?(,\s+)?//g) {
-                $man{$1} = 1;
-            }
-            # Short form
-            if ($line =~ s/^\*\*(-[a-zA-Z0-9.])\*\*(=\*[a-zA-Z0-9-]+\*)?//g) {
-                $man{$1} = 1;
-            }
-        }
-    }
-    close $fh;
-
-    return \%man;
-}
-
-
-
-# END   data gathering
-###############################################################################
-
-1;

install.md

@@ -1,4 +1,4 @@
-# Installing Skopeo
+# Installing from packages
 
 ## Distribution Packages
 `skopeo` may already be packaged in your distribution.
@@ -15,12 +15,43 @@ sudo dnf -y install skopeo
 sudo dnf -y install skopeo
 ```
 
+Newer Skopeo releases may be available on the repositories provided by the
+Kubic project. Beware, these may not be suitable for production environments.
+
+on CentOS 8:
+
+```sh
+sudo dnf -y module disable container-tools
+sudo dnf -y install 'dnf-command(copr)'
+sudo dnf -y copr enable rhcontainerbot/container-selinux
+sudo curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable.repo https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/CentOS_8/devel:kubic:libcontainers:stable.repo
+sudo dnf -y install skopeo
+```
+
+on CentOS 8 Stream:
+
+```sh
+sudo dnf -y module disable container-tools
+sudo dnf -y install 'dnf-command(copr)'
+sudo dnf -y copr enable rhcontainerbot/container-selinux
+sudo curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable.repo https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/CentOS_8_Stream/devel:kubic:libcontainers:stable.repo
+sudo dnf -y install skopeo
+```
+
 ### RHEL/CentOS ≤ 7.x
 
 ```sh
 sudo yum -y install skopeo
 ```
 
+Newer Skopeo releases may be available on the repositories provided by the
+Kubic project. Beware, these may not be suitable for production environments.
+
+```sh
+sudo curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable.repo https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/CentOS_7/devel:kubic:libcontainers:stable.repo
+sudo yum -y install skopeo
+```
+
 ### openSUSE
 
 ```sh
@@ -46,15 +77,59 @@ $ nix-env -i skopeo
 
 ### Debian
 
-The skopeo package is available on [Bullseye](https://packages.debian.org/bullseye/skopeo),
-and Debian Testing and Unstable.
+The skopeo package is available in
+the [Bullseye (testing) branch](https://packages.debian.org/bullseye/skopeo), which
+will be the next stable release (Debian 11) as well as Debian Unstable/Sid.
 
 ```bash
-# Debian Bullseye, Testing or Unstable/Sid
+# Debian Testing/Bullseye or Unstable/Sid
 sudo apt-get update
 sudo apt-get -y install skopeo
 ```
 
+If you would prefer newer (though not as well-tested) packages,
+the [Kubic project](https://build.opensuse.org/package/show/devel:kubic:libcontainers:stable/skopeo)
+provides packages for Debian 10 and newer. The packages in Kubic project repos are more frequently
+updated than the one in Debian's official repositories, due to how Debian works.
+The build sources for the Kubic packages can be found [here](https://gitlab.com/rhcontainerbot/skopeo/-/tree/debian/debian).
+
+CAUTION: On Debian 11 and newer, including Debian Testing and Sid, we highly recommend you use Buildah, Podman and Skopeo ONLY from EITHER the Kubic repo
+OR the official Debian repos. Mixing and matching may lead to unpredictable situations including installation conflicts.
+
+```bash
+# Debian 10
+echo 'deb https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/Debian_10/ /' > /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list
+curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/Debian_10/Release.key | sudo apt-key add -
+sudo apt-get update
+sudo apt-get -y install skopeo
+
+# Debian Testing
+echo 'deb https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/Debian_Testing/ /' > /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list
+curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/Debian_Testing/Release.key | sudo apt-key add -
+sudo apt-get update
+sudo apt-get -y install skopeo
+
+# Debian Sid/Unstable
+echo 'deb https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/Debian_Unstable/ /' > /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list
+curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/Debian_Unstable/Release.key | sudo apt-key add -
+sudo apt-get update
+sudo apt-get -y install skopeo
+```
+
+
+### Raspberry Pi OS armhf (ex Raspbian)
+
+The Kubic project provides packages for Raspbian 10.
+
+```bash
+# Raspbian 10
+echo 'deb https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/Raspbian_10/ /' | sudo tee /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list
+curl -L https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/Raspbian_10/Release.key | sudo apt-key add -
+sudo apt-get update -qq
+sudo apt-get -qq -y install skopeo
+```
+
+
 ### Raspberry Pi OS arm64 (beta)
 
 Raspberry Pi OS uses the standard Debian's repositories,
@@ -73,8 +148,17 @@ sudo apt-get -y update
 sudo apt-get -y install skopeo
 ```
 
-The [Kubic project](https://build.opensuse.org/package/show/devel:kubic:libcontainers:stable/skopeo)
-provides packages for Ubuntu 20.04 (it should also work with direct derivatives like Pop!\_OS).
+If you would prefer newer (though not as well-tested) packages,
+the [Kubic project](https://build.opensuse.org/package/show/devel:kubic:libcontainers:stable/skopeo)
+provides packages for active Ubuntu releases 18.04 and newer (it should also work with direct derivatives like Pop!\_OS).
+Checkout the [Kubic project page](https://build.opensuse.org/package/show/devel:kubic:libcontainers:stable/skopeo)
+for a list of supported Ubuntu version and
+architecture combinations. **NOTE:** The command `sudo apt-get -y upgrade`
+maybe required in some cases if Skopeo cannot be installed without it.
+The build sources for the Kubic packages can be found [here](https://gitlab.com/rhcontainerbot/skopeo/-/tree/debian/debian).
+
+CAUTION: On Ubuntu 20.10 and newer, we highly recommend you use Buildah, Podman and Skopeo ONLY from EITHER the Kubic repo
+OR the official Ubuntu repos. Mixing and matching may lead to unpredictable situations including installation conflicts.
 
 ```bash
 . /etc/os-release
@@ -85,25 +169,6 @@ sudo apt-get -y upgrade
 sudo apt-get -y install skopeo
 ```
 
-### Windows
-Skopeo has not yet been packaged for Windows. There is an [open feature
-request](https://github.com/containers/skopeo/issues/715) and contributions are
-always welcome.
-
-
-## Container Images
-
-Skopeo container images are available at `quay.io/skopeo/stable:latest`.
-For example,
-
-```bash
-podman run docker://quay.io/skopeo/stable:latest copy --help
-```
-
-[Read more](./contrib/skopeoimage/README.md).
-
-
-## Building from Source
 
 Otherwise, read on for building and installing it from source:
 
@@ -112,6 +177,8 @@ To build the `skopeo` binary you need at least Go 1.12.
 There are two ways to build skopeo: in a container, or locally without a
 container. Choose the one which better matches your needs and environment.
 
+## Building from Source
+
 ### Building without a container
 
 Building without a container requires a bit more manual work and setup in your
@@ -130,7 +197,7 @@ sudo dnf install gpgme-devel libassuan-devel btrfs-progs-devel device-mapper-dev
 
 ```bash
 # Ubuntu (`libbtrfs-dev` requires Ubuntu 18.10 and above):
-sudo apt install libgpgme-dev libassuan-dev libbtrfs-dev libdevmapper-dev pkg-config
+sudo apt install libgpgme-dev libassuan-dev libbtrfs-dev libdevmapper-dev
 ```
 
 ```bash
@@ -152,12 +219,6 @@ cd $GOPATH/src/github.com/containers/skopeo && make bin/skopeo
 
 By default the `make` command (make all) will build bin/skopeo and the documentation locally.
 
-Building of documentation requires `go-md2man`. On systems that do not have this tool, the
-document generation can be skipped by passing `DISABLE_DOCS=1`:
-```
-DISABLE_DOCS=1 make
-```
-
 ### Building documentation
 
 To build the manual you will need go-md2man.
@@ -172,11 +233,6 @@ sudo apt-get install go-md2man
 sudo dnf install go-md2man
 ```
 
-```
-# MacOS:
-brew install go-md2man
-```
-
 Then
 
 ```bash
@@ -203,41 +259,3 @@ Finally, after the binary and documentation is built:
 ```bash
 sudo make install
 ```
-
-### Building a static binary
-
-There have been efforts in the past to produce and maintain static builds, but the maintainers prefer to run Skopeo using distro packages or within containers. This is because static builds of Skopeo tend to be unreliable and functionally restricted. Specifically:
-- Some features of Skopeo depend on non-Go libraries like `libgpgme` and `libdevmapper`.
-- Generating static Go binaries uses native Go libraries, which don't support e.g. `.local` or LDAP-based name resolution.
-
-That being said, if you would like to build Skopeo statically, you might be able to do it by combining all the following steps.
-- Export environment variable `CGO_ENABLED=0` (disabling CGO causes Go to prefer native libraries when possible, instead of dynamically linking against system libraries).
-- Set the `BUILDTAGS=containers_image_openpgp` Make variable (this remove the dependency on `libgpgme` and its companion libraries).
-- Clear the `GO_DYN_FLAGS` Make variable (which otherwise seems to force the creation of a dynamic executable).
-
-The following command implements these steps to produce a static binary in the `bin` subdirectory of the repository:
-
-```bash
-docker run -v $PWD:/src -w /src -e CGO_ENABLED=0 golang \
-make BUILDTAGS=containers_image_openpgp GO_DYN_FLAGS=
-```
-
-Keep in mind that the resulting binary is unsupported and might crash randomly. Only use if you know what you're doing!
-
-For more information, history, and context about static builds, check the following issues:
-
-- [#391] - Consider distributing statically built binaries as part of release
-- [#669] - Static build fails with segmentation violation
-- [#670] - Fixing static binary build using container
-- [#755] - Remove static and in-container targets from Makefile
-- [#932] - Add nix derivation for static builds
-- [#1336] - Unable to run skopeo on Fedora 30 (due to dyn lib dependency)
-- [#1478] - Publish binary releases to GitHub (request+discussion)
-
-[#391]: https://github.com/containers/skopeo/issues/391
-[#669]: https://github.com/containers/skopeo/issues/669
-[#670]: https://github.com/containers/skopeo/issues/670
-[#755]: https://github.com/containers/skopeo/issues/755
-[#932]: https://github.com/containers/skopeo/issues/932
-[#1336]: https://github.com/containers/skopeo/issues/1336
-[#1478]: https://github.com/containers/skopeo/issues/1478

integration/blocked_test.go

@@ -1,7 +1,7 @@
 package main
 
 import (
-	"gopkg.in/check.v1"
+	"github.com/go-check/check"
 )
 
 const blockedRegistriesConf = "./fixtures/blocked-registries.conf"

integration/check_test.go

@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	"github.com/containers/skopeo/version"
-	"gopkg.in/check.v1"
+	"github.com/go-check/check"
 )
 
 const (
@@ -101,7 +101,7 @@ func (s *SkopeoSuite) TestCopyWithLocalAuth(c *check.C) {
 	assertSkopeoSucceeds(c, wanted, "login", "--tls-verify=false", "--username="+s.regV2WithAuth.username, "--password="+s.regV2WithAuth.password, s.regV2WithAuth.url)
 	// copy to private registry using local authentication
 	imageName := fmt.Sprintf("docker://%s/busybox:mine", s.regV2WithAuth.url)
-	assertSkopeoSucceeds(c, "", "copy", "--dest-tls-verify=false", testFQIN+":latest", imageName)
+	assertSkopeoSucceeds(c, "", "copy", "--dest-tls-verify=false", "docker://docker.io/library/busybox:latest", imageName)
 	// inspect from private registry
 	assertSkopeoSucceeds(c, "", "inspect", "--tls-verify=false", imageName)
 	// logout from the registry

integration/copy_test.go

@@ -17,10 +17,10 @@ import (
 	"github.com/containers/image/v5/manifest"
 	"github.com/containers/image/v5/signature"
 	"github.com/containers/image/v5/types"
+	"github.com/go-check/check"
 	digest "github.com/opencontainers/go-digest"
 	imgspecv1 "github.com/opencontainers/image-spec/specs-go/v1"
 	"github.com/opencontainers/image-tools/image"
-	"gopkg.in/check.v1"
 )
 
 func init() {
@@ -246,21 +246,6 @@ func (s *CopySuite) TestCopyWithManifestListDigest(c *check.C) {
 	c.Assert(out, check.Equals, "")
 }
 
-func (s *CopySuite) TestCopyWithDigestfileOutput(c *check.C) {
-	tempdir, err := ioutil.TempDir("", "tempdir")
-	c.Assert(err, check.IsNil)
-	defer os.RemoveAll(tempdir)
-	dir1, err := ioutil.TempDir("", "copy-manifest-list-digest-dir")
-	c.Assert(err, check.IsNil)
-	defer os.RemoveAll(dir1)
-	digestOutPath := filepath.Join(tempdir, "digest.txt")
-	assertSkopeoSucceeds(c, "", "copy", "--digestfile="+digestOutPath, knownListImage, "dir:"+dir1)
-	readDigest, err := ioutil.ReadFile(digestOutPath)
-	c.Assert(err, check.IsNil)
-	_, err = digest.Parse(string(readDigest))
-	c.Assert(err, check.IsNil)
-}
-
 func (s *CopySuite) TestCopyWithManifestListStorageDigest(c *check.C) {
 	storage, err := ioutil.TempDir("", "copy-manifest-list-storage-digest")
 	c.Assert(err, check.IsNil)
@@ -318,8 +303,8 @@ func (s *CopySuite) TestCopyWithManifestListStorageDigestMultipleArchesBothUseLi
 	c.Assert(err, check.IsNil)
 	assertSkopeoSucceeds(c, "", "--override-arch=amd64", "copy", knownListImage+"@"+digest, "containers-storage:"+storage+"test@"+digest)
 	assertSkopeoSucceeds(c, "", "--override-arch=arm64", "copy", knownListImage+"@"+digest, "containers-storage:"+storage+"test@"+digest)
-	assertSkopeoFails(c, `.*reading manifest for image instance.*does not exist.*`, "--override-arch=amd64", "inspect", "containers-storage:"+storage+"test@"+digest)
-	assertSkopeoFails(c, `.*reading manifest for image instance.*does not exist.*`, "--override-arch=amd64", "inspect", "--config", "containers-storage:"+storage+"test@"+digest)
+	assertSkopeoFails(c, `.*error reading manifest for image instance.*does not exist.*`, "--override-arch=amd64", "inspect", "containers-storage:"+storage+"test@"+digest)
+	assertSkopeoFails(c, `.*error reading manifest for image instance.*does not exist.*`, "--override-arch=amd64", "inspect", "--config", "containers-storage:"+storage+"test@"+digest)
 	i2 := combinedOutputOfCommand(c, skopeoBinary, "--override-arch=arm64", "inspect", "--config", "containers-storage:"+storage+"test@"+digest)
 	var image2 imgspecv1.Image
 	err = json.Unmarshal([]byte(i2), &image2)
@@ -354,8 +339,8 @@ func (s *CopySuite) TestCopyWithManifestListStorageDigestMultipleArchesFirstUses
 	err = json.Unmarshal([]byte(i2), &image2)
 	c.Assert(err, check.IsNil)
 	c.Assert(image2.Architecture, check.Equals, "amd64")
-	assertSkopeoFails(c, `.*reading manifest for image instance.*does not exist.*`, "--override-arch=arm64", "inspect", "containers-storage:"+storage+"test@"+digest)
-	assertSkopeoFails(c, `.*reading manifest for image instance.*does not exist.*`, "--override-arch=arm64", "inspect", "--config", "containers-storage:"+storage+"test@"+digest)
+	assertSkopeoFails(c, `.*error reading manifest for image instance.*does not exist.*`, "--override-arch=arm64", "inspect", "containers-storage:"+storage+"test@"+digest)
+	assertSkopeoFails(c, `.*error reading manifest for image instance.*does not exist.*`, "--override-arch=arm64", "inspect", "--config", "containers-storage:"+storage+"test@"+digest)
 	i3 := combinedOutputOfCommand(c, skopeoBinary, "--override-arch=arm64", "inspect", "--config", "containers-storage:"+storage+"test@"+arm64Instance.String())
 	var image3 imgspecv1.Image
 	err = json.Unmarshal([]byte(i3), &image3)
@@ -385,8 +370,8 @@ func (s *CopySuite) TestCopyWithManifestListStorageDigestMultipleArchesSecondUse
 	err = json.Unmarshal([]byte(i1), &image1)
 	c.Assert(err, check.IsNil)
 	c.Assert(image1.Architecture, check.Equals, "amd64")
-	assertSkopeoFails(c, `.*reading manifest for image instance.*does not exist.*`, "--override-arch=amd64", "inspect", "containers-storage:"+storage+"test@"+digest)
-	assertSkopeoFails(c, `.*reading manifest for image instance.*does not exist.*`, "--override-arch=amd64", "inspect", "--config", "containers-storage:"+storage+"test@"+digest)
+	assertSkopeoFails(c, `.*error reading manifest for image instance.*does not exist.*`, "--override-arch=amd64", "inspect", "containers-storage:"+storage+"test@"+digest)
+	assertSkopeoFails(c, `.*error reading manifest for image instance.*does not exist.*`, "--override-arch=amd64", "inspect", "--config", "containers-storage:"+storage+"test@"+digest)
 	i2 := combinedOutputOfCommand(c, skopeoBinary, "--override-arch=arm64", "inspect", "--config", "containers-storage:"+storage+"test@"+digest)
 	var image2 imgspecv1.Image
 	err = json.Unmarshal([]byte(i2), &image2)
@@ -417,7 +402,7 @@ func (s *CopySuite) TestCopyWithManifestListStorageDigestMultipleArchesThirdUses
 	assertSkopeoSucceeds(c, "", "--override-arch=amd64", "copy", knownListImage+"@"+amd64Instance.String(), "containers-storage:"+storage+"test@"+amd64Instance.String())
 	assertSkopeoSucceeds(c, "", "--override-arch=amd64", "copy", knownListImage+"@"+digest, "containers-storage:"+storage+"test@"+digest)
 	assertSkopeoSucceeds(c, "", "--override-arch=arm64", "copy", knownListImage+"@"+digest, "containers-storage:"+storage+"test@"+digest)
-	assertSkopeoFails(c, `.*reading manifest for image instance.*does not exist.*`, "--override-arch=amd64", "inspect", "--config", "containers-storage:"+storage+"test@"+digest)
+	assertSkopeoFails(c, `.*error reading manifest for image instance.*does not exist.*`, "--override-arch=amd64", "inspect", "--config", "containers-storage:"+storage+"test@"+digest)
 	i1 := combinedOutputOfCommand(c, skopeoBinary, "--override-arch=amd64", "inspect", "--config", "containers-storage:"+storage+"test@"+amd64Instance.String())
 	var image1 imgspecv1.Image
 	err = json.Unmarshal([]byte(i1), &image1)
@@ -452,7 +437,7 @@ func (s *CopySuite) TestCopyWithManifestListStorageDigestMultipleArchesTagAndDig
 	c.Assert(err, check.IsNil)
 	assertSkopeoSucceeds(c, "", "--override-arch=amd64", "copy", knownListImage, "containers-storage:"+storage+"test:latest")
 	assertSkopeoSucceeds(c, "", "--override-arch=arm64", "copy", knownListImage+"@"+digest, "containers-storage:"+storage+"test@"+digest)
-	assertSkopeoFails(c, `.*reading manifest for image instance.*does not exist.*`, "--override-arch=amd64", "inspect", "--config", "containers-storage:"+storage+"test@"+digest)
+	assertSkopeoFails(c, `.*error reading manifest for image instance.*does not exist.*`, "--override-arch=amd64", "inspect", "--config", "containers-storage:"+storage+"test@"+digest)
 	i1 := combinedOutputOfCommand(c, skopeoBinary, "--override-arch=arm64", "inspect", "--config", "containers-storage:"+storage+"test:latest")
 	var image1 imgspecv1.Image
 	err = json.Unmarshal([]byte(i1), &image1)
@@ -506,12 +491,12 @@ func (s *CopySuite) TestCopySimpleAtomicRegistry(c *check.C) {
 
 	// FIXME: It would be nice to use one of the local Docker registries instead of needing an Internet connection.
 	// "pull": docker: → dir:
-	assertSkopeoSucceeds(c, "", "copy", testFQIN64, "dir:"+dir1)
+	assertSkopeoSucceeds(c, "", "copy", "docker://estesp/busybox:amd64", "dir:"+dir1)
 	// "push": dir: → atomic:
 	assertSkopeoSucceeds(c, "", "--tls-verify=false", "--debug", "copy", "dir:"+dir1, "atomic:localhost:5000/myns/unsigned:unsigned")
 	// The result of pushing and pulling is an equivalent image, except for schema1 embedded names.
 	assertSkopeoSucceeds(c, "", "--tls-verify=false", "copy", "atomic:localhost:5000/myns/unsigned:unsigned", "dir:"+dir2)
-	assertSchema1DirImagesAreEqualExceptNames(c, dir1, "libpod/busybox:amd64", dir2, "myns/unsigned:unsigned")
+	assertSchema1DirImagesAreEqualExceptNames(c, dir1, "estesp/busybox:amd64", dir2, "myns/unsigned:unsigned")
 }
 
 // The most basic (skopeo copy) use:
@@ -568,7 +553,6 @@ func (s *CopySuite) TestCopyEncryption(c *check.C) {
 	c.Assert(err, check.IsNil)
 	defer os.RemoveAll(keysDir)
 	undecryptedImgDir, err := ioutil.TempDir("", "copy-5")
-	c.Assert(err, check.IsNil)
 	defer os.RemoveAll(undecryptedImgDir)
 	multiLayerImageDir, err := ioutil.TempDir("", "copy-6")
 	c.Assert(err, check.IsNil)
@@ -603,7 +587,7 @@ func (s *CopySuite) TestCopyEncryption(c *check.C) {
 		"oci:"+encryptedImgDir+":encrypted", "oci:"+decryptedImgDir+":decrypted")
 
 	// Copy a standard busybox image locally
-	assertSkopeoSucceeds(c, "", "copy", testFQIN+":1.30.1", "oci:"+originalImageDir+":latest")
+	assertSkopeoSucceeds(c, "", "copy", "docker://busybox:1.31.1", "oci:"+originalImageDir+":latest")
 
 	// Encrypt the image
 	assertSkopeoSucceeds(c, "", "copy", "--encryption-key",
@@ -634,7 +618,7 @@ func (s *CopySuite) TestCopyEncryption(c *check.C) {
 	matchLayerBlobBinaryType(c, decryptedImgDir+"/blobs/sha256", "application/x-gzip", 1)
 
 	// Copy a standard multi layer nginx image locally
-	assertSkopeoSucceeds(c, "", "copy", testFQINMultiLayer, "oci:"+multiLayerImageDir+":latest")
+	assertSkopeoSucceeds(c, "", "copy", "docker://nginx:1.17.8", "oci:"+multiLayerImageDir+":latest")
 
 	// Partially encrypt the image
 	assertSkopeoSucceeds(c, "", "copy", "--encryption-key", "jwe:"+keysDir+"/public.key",
@@ -739,11 +723,11 @@ func (s *CopySuite) TestCopyStreaming(c *check.C) {
 
 	// FIXME: It would be nice to use one of the local Docker registries instead of needing an Internet connection.
 	// streaming: docker: → atomic:
-	assertSkopeoSucceeds(c, "", "--tls-verify=false", "--debug", "copy", testFQIN64, "atomic:localhost:5000/myns/unsigned:streaming")
+	assertSkopeoSucceeds(c, "", "--tls-verify=false", "--debug", "copy", "docker://estesp/busybox:amd64", "atomic:localhost:5000/myns/unsigned:streaming")
 	// Compare (copies of) the original and the copy:
-	assertSkopeoSucceeds(c, "", "copy", testFQIN64, "dir:"+dir1)
+	assertSkopeoSucceeds(c, "", "copy", "docker://estesp/busybox:amd64", "dir:"+dir1)
 	assertSkopeoSucceeds(c, "", "--tls-verify=false", "copy", "atomic:localhost:5000/myns/unsigned:streaming", "dir:"+dir2)
-	assertSchema1DirImagesAreEqualExceptNames(c, dir1, "libpod/busybox:amd64", dir2, "myns/unsigned:streaming")
+	assertSchema1DirImagesAreEqualExceptNames(c, dir1, "estesp/busybox:amd64", dir2, "myns/unsigned:streaming")
 	// FIXME: Also check pushing to docker://
 }
 
@@ -763,7 +747,7 @@ func (s *CopySuite) TestCopyOCIRoundTrip(c *check.C) {
 	defer os.RemoveAll(oci2)
 
 	// Docker -> OCI
-	assertSkopeoSucceeds(c, "", "--tls-verify=false", "--debug", "copy", testFQIN, "oci:"+oci1+":latest")
+	assertSkopeoSucceeds(c, "", "--tls-verify=false", "--debug", "copy", "docker://busybox", "oci:"+oci1+":latest")
 	// OCI -> Docker
 	assertSkopeoSucceeds(c, "", "--tls-verify=false", "--debug", "copy", "oci:"+oci1+":latest", ourRegistry+"original/busybox:oci_copy")
 	// Docker -> OCI
@@ -814,16 +798,16 @@ func (s *CopySuite) TestCopySignatures(c *check.C) {
 	defer os.Remove(policy)
 
 	// type: reject
-	assertSkopeoFails(c, fmt.Sprintf(".*Source image rejected: Running image %s:latest is rejected by policy.*", testFQIN),
-		"--policy", policy, "copy", testFQIN+":latest", dirDest)
+	assertSkopeoFails(c, ".*Source image rejected: Running image docker://busybox:latest is rejected by policy.*",
+		"--policy", policy, "copy", "docker://busybox:latest", dirDest)
 
 	// type: insecureAcceptAnything
-	assertSkopeoSucceeds(c, "", "--policy", policy, "copy", "docker://quay.io/openshift/origin-hello-openshift", dirDest)
+	assertSkopeoSucceeds(c, "", "--policy", policy, "copy", "docker://openshift/hello-openshift", dirDest)
 
 	// type: signedBy
 	// Sign the images
-	assertSkopeoSucceeds(c, "", "--tls-verify=false", "copy", "--sign-by", "personal@example.com", testFQIN+":1.26", "atomic:localhost:5006/myns/personal:personal")
-	assertSkopeoSucceeds(c, "", "--tls-verify=false", "copy", "--sign-by", "official@example.com", testFQIN+":1.26.1", "atomic:localhost:5006/myns/official:official")
+	assertSkopeoSucceeds(c, "", "--tls-verify=false", "copy", "--sign-by", "personal@example.com", "docker://busybox:1.26", "atomic:localhost:5006/myns/personal:personal")
+	assertSkopeoSucceeds(c, "", "--tls-verify=false", "copy", "--sign-by", "official@example.com", "docker://busybox:1.26.1", "atomic:localhost:5006/myns/official:official")
 	// Verify that we can pull them
 	assertSkopeoSucceeds(c, "", "--tls-verify=false", "--policy", policy, "copy", "atomic:localhost:5006/myns/personal:personal", dirDest)
 	assertSkopeoSucceeds(c, "", "--tls-verify=false", "--policy", policy, "copy", "atomic:localhost:5006/myns/official:official", dirDest)
@@ -877,8 +861,8 @@ func (s *CopySuite) TestCopyDirSignatures(c *check.C) {
 	defer os.Remove(policy)
 
 	// Get some images.
-	assertSkopeoSucceeds(c, "", "copy", testFQIN+":armfh", topDirDest+"/dir1")
-	assertSkopeoSucceeds(c, "", "copy", testFQIN+":s390x", topDirDest+"/dir2")
+	assertSkopeoSucceeds(c, "", "copy", "docker://estesp/busybox:armfh", topDirDest+"/dir1")
+	assertSkopeoSucceeds(c, "", "copy", "docker://estesp/busybox:s390x", topDirDest+"/dir2")
 
 	// Sign the images. By coping from a topDirDest/dirN, also test that non-/restricted paths
 	// use the dir:"" default of insecureAcceptAnything.
@@ -994,7 +978,7 @@ func (s *CopySuite) TestCopyDockerSigstore(c *check.C) {
 	c.Assert(err, check.IsNil)
 
 	// Get an image to work with.  Also verifies that we can use Docker repositories with no sigstore configured.
-	assertSkopeoSucceeds(c, "", "--tls-verify=false", "--registries.d", registriesDir, "copy", testFQIN, ourRegistry+"original/busybox")
+	assertSkopeoSucceeds(c, "", "--tls-verify=false", "--registries.d", registriesDir, "copy", "docker://busybox", ourRegistry+"original/busybox")
 	// Pulling an unsigned image fails.
 	assertSkopeoFails(c, ".*Source image rejected: A signature was required, but no signature exists.*",
 		"--tls-verify=false", "--policy", policy, "--registries.d", registriesDir, "copy", ourRegistry+"original/busybox", dirDest)
@@ -1048,7 +1032,7 @@ func (s *CopySuite) TestCopyAtomicExtension(c *check.C) {
 	defer os.Remove(policy)
 
 	// Get an image to work with to an atomic: destination.  Also verifies that we can use Docker repositories without X-Registry-Supports-Signatures
-	assertSkopeoSucceeds(c, "", "--tls-verify=false", "--registries.d", registriesDir, "copy", testFQIN, "atomic:localhost:5000/myns/extension:unsigned")
+	assertSkopeoSucceeds(c, "", "--tls-verify=false", "--registries.d", registriesDir, "copy", "docker://busybox", "atomic:localhost:5000/myns/extension:unsigned")
 	// Pulling an unsigned image using atomic: fails.
 	assertSkopeoFails(c, ".*Source image rejected: A signature was required, but no signature exists.*",
 		"--tls-verify=false", "--policy", policy,
@@ -1072,7 +1056,7 @@ func (s *CopySuite) TestCopyAtomicExtension(c *check.C) {
 
 	// Get another image (different so that they don't share signatures, and sign it using docker://)
 	assertSkopeoSucceeds(c, "", "--tls-verify=false", "--registries.d", registriesDir,
-		"copy", "--sign-by", "personal@example.com", testFQIN+":ppc64le", "docker://localhost:5000/myns/extension:extension")
+		"copy", "--sign-by", "personal@example.com", "docker://estesp/busybox:ppc64le", "docker://localhost:5000/myns/extension:extension")
 	c.Logf("%s", combinedOutputOfCommand(c, "oc", "get", "istag", "extension:extension", "-o", "json"))
 	// Pulling the image using atomic: succeeds.
 	assertSkopeoSucceeds(c, "", "--debug", "--tls-verify=false", "--policy", policy,
@@ -1093,10 +1077,12 @@ func copyWithSignedIdentity(c *check.C, src, dest, signedIdentity, signBy, regis
 
 	signingDir := filepath.Join(topDir, "signing-temp")
 	assertSkopeoSucceeds(c, "", "copy", "--src-tls-verify=false", src, "dir:"+signingDir)
-	c.Logf("%s", combinedOutputOfCommand(c, "ls", "-laR", signingDir))
+	// Unknown error in Travis: https://github.com/containers/skopeo/issues/1093
+	//	c.Logf("%s", combinedOutputOfCommand(c, "ls", "-laR", signingDir))
 	assertSkopeoSucceeds(c, "^$", "standalone-sign", "-o", filepath.Join(signingDir, "signature-1"),
 		filepath.Join(signingDir, "manifest.json"), signedIdentity, signBy)
-	c.Logf("%s", combinedOutputOfCommand(c, "ls", "-laR", signingDir))
+	// Unknown error in Travis: https://github.com/containers/skopeo/issues/1093
+	//	c.Logf("%s", combinedOutputOfCommand(c, "ls", "-laR", signingDir))
 	assertSkopeoSucceeds(c, "", "--registries.d", registriesDir, "copy", "--dest-tls-verify=false", "dir:"+signingDir, dest)
 }
 
@@ -1126,7 +1112,7 @@ func (s *CopySuite) TestCopyVerifyingMirroredSignatures(c *check.C) {
 	// So, make sure to never create a signature that could be considered valid in a different part of the test (i.e. don't reuse tags).
 
 	// Get an image to work with.
-	assertSkopeoSucceeds(c, "", "copy", "--dest-tls-verify=false", testFQIN, regPrefix+"primary:unsigned")
+	assertSkopeoSucceeds(c, "", "copy", "--dest-tls-verify=false", "docker://busybox", regPrefix+"primary:unsigned")
 	// Verify that unsigned images are rejected
 	assertSkopeoFails(c, ".*Source image rejected: A signature was required, but no signature exists.*",
 		"--policy", policy, "--registries.d", registriesDir, "--registries-conf", "fixtures/registries.conf", "copy", "--src-tls-verify=false", regPrefix+"primary:unsigned", dirDest)
@@ -1169,11 +1155,11 @@ func (s *CopySuite) TestCopyVerifyingMirroredSignatures(c *check.C) {
 	assertSkopeoSucceeds(c, "", "--policy", policy, "--registries.d", registriesDir, "--registries-conf", "fixtures/registries.conf", "copy", "--src-tls-verify=false", regPrefix+"remap:remapped", dirDest)
 	// To be extra clear about the semantics, verify that the signedPrefix (primary) location never exists
 	// and only the remapped prefix (mirror) is accessed.
-	assertSkopeoFails(c, ".*initializing source docker://localhost:5006/myns/mirroring-primary:remapped:.*manifest unknown: manifest unknown.*", "--policy", policy, "--registries.d", registriesDir, "--registries-conf", "fixtures/registries.conf", "copy", "--src-tls-verify=false", regPrefix+"primary:remapped", dirDest)
+	assertSkopeoFails(c, ".*Error initializing source docker://localhost:5006/myns/mirroring-primary:remapped:.*manifest unknown: manifest unknown.*", "--policy", policy, "--registries.d", registriesDir, "--registries-conf", "fixtures/registries.conf", "copy", "--src-tls-verify=false", regPrefix+"primary:remapped", dirDest)
 }
 
 func (s *SkopeoSuite) TestCopySrcWithAuth(c *check.C) {
-	assertSkopeoSucceeds(c, "", "--tls-verify=false", "copy", "--dest-creds=testuser:testpassword", testFQIN, fmt.Sprintf("docker://%s/busybox:latest", s.regV2WithAuth.url))
+	assertSkopeoSucceeds(c, "", "--tls-verify=false", "copy", "--dest-creds=testuser:testpassword", "docker://busybox", fmt.Sprintf("docker://%s/busybox:latest", s.regV2WithAuth.url))
 	dir1, err := ioutil.TempDir("", "copy-1")
 	c.Assert(err, check.IsNil)
 	defer os.RemoveAll(dir1)
@@ -1181,11 +1167,11 @@ func (s *SkopeoSuite) TestCopySrcWithAuth(c *check.C) {
 }
 
 func (s *SkopeoSuite) TestCopyDestWithAuth(c *check.C) {
-	assertSkopeoSucceeds(c, "", "--tls-verify=false", "copy", "--dest-creds=testuser:testpassword", testFQIN, fmt.Sprintf("docker://%s/busybox:latest", s.regV2WithAuth.url))
+	assertSkopeoSucceeds(c, "", "--tls-verify=false", "copy", "--dest-creds=testuser:testpassword", "docker://busybox", fmt.Sprintf("docker://%s/busybox:latest", s.regV2WithAuth.url))
 }
 
 func (s *SkopeoSuite) TestCopySrcAndDestWithAuth(c *check.C) {
-	assertSkopeoSucceeds(c, "", "--tls-verify=false", "copy", "--dest-creds=testuser:testpassword", testFQIN, fmt.Sprintf("docker://%s/busybox:latest", s.regV2WithAuth.url))
+	assertSkopeoSucceeds(c, "", "--tls-verify=false", "copy", "--dest-creds=testuser:testpassword", "docker://busybox", fmt.Sprintf("docker://%s/busybox:latest", s.regV2WithAuth.url))
 	assertSkopeoSucceeds(c, "", "--tls-verify=false", "copy", "--src-creds=testuser:testpassword", "--dest-creds=testuser:testpassword", fmt.Sprintf("docker://%s/busybox:latest", s.regV2WithAuth.url), fmt.Sprintf("docker://%s/test:auth", s.regV2WithAuth.url))
 }
 
@@ -1215,7 +1201,7 @@ func (s *CopySuite) TestCopyManifestConversion(c *check.C) {
 
 	// oci to v2s1 and vice-versa not supported yet
 	// get v2s2 manifest type
-	assertSkopeoSucceeds(c, "", "copy", testFQIN, "dir:"+srcDir)
+	assertSkopeoSucceeds(c, "", "copy", "docker://busybox", "dir:"+srcDir)
 	verifyManifestMIMEType(c, srcDir, manifest.DockerV2Schema2MediaType)
 	// convert from v2s2 to oci
 	assertSkopeoSucceeds(c, "", "copy", "--format=oci", "dir:"+srcDir, "dir:"+destDir1)
@@ -1245,7 +1231,7 @@ func (s *CopySuite) testCopySchemaConversionRegistries(c *check.C, schema1Regist
 
 	// Ensure we are working with a schema2 image.
 	// dir: accepts any manifest format, i.e. this makes …/input2 a schema2 source which cannot be asked to produce schema1 like ordinary docker: registries can.
-	assertSkopeoSucceeds(c, "", "copy", testFQIN, "dir:"+input2Dir)
+	assertSkopeoSucceeds(c, "", "copy", "docker://busybox", "dir:"+input2Dir)
 	verifyManifestMIMEType(c, input2Dir, manifest.DockerV2Schema2MediaType)
 	// 2→2 (the "f2t2" in tag means "from 2 to 2")
 	assertSkopeoSucceeds(c, "", "copy", "--dest-tls-verify=false", "dir:"+input2Dir, schema2Registry+":f2t2")
@@ -1265,6 +1251,14 @@ func (s *CopySuite) testCopySchemaConversionRegistries(c *check.C, schema1Regist
 	verifyManifestMIMEType(c, destDir, manifest.DockerV2Schema1SignedMediaType)
 }
 
+// Verify manifest in a dir: image at dir is expectedMIMEType.
+func verifyManifestMIMEType(c *check.C, dir string, expectedMIMEType string) {
+	manifestBlob, err := ioutil.ReadFile(filepath.Join(dir, "manifest.json"))
+	c.Assert(err, check.IsNil)
+	mimeType := manifest.GuessMIMEType(manifestBlob)
+	c.Assert(mimeType, check.Equals, expectedMIMEType)
+}
+
 const regConfFixture = "./fixtures/registries.conf"
 
 func (s *SkopeoSuite) TestSuccessCopySrcWithMirror(c *check.C) {

integration/fixtures/policy.json

@@ -50,11 +50,6 @@
                 {
                     "type": "insecureAcceptAnything"
                 }
-            ],
-            "quay.io/openshift": [
-                {
-                    "type": "insecureAcceptAnything"
-                }
             ]
         },
         "dir": {

integration/openshift.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"bufio"
-	"context"
 	"encoding/base64"
 	"fmt"
 	"io/ioutil"
@@ -10,10 +9,9 @@ import (
 	"os/exec"
 	"path/filepath"
 	"strings"
-	"time"
 
 	"github.com/docker/docker/pkg/homedir"
-	"gopkg.in/check.v1"
+	"github.com/go-check/check"
 )
 
 var adminKUBECONFIG = map[string]string{
@@ -64,7 +62,6 @@ func (cluster *openshiftCluster) startMaster(c *check.C) {
 	cmd := cluster.clusterCmd(nil, "openshift", "start", "master")
 	cluster.processes = append(cluster.processes, cmd)
 	stdout, err := cmd.StdoutPipe()
-	c.Assert(err, check.IsNil)
 	// Send both to the same pipe. This might cause the two streams to be mixed up,
 	// but logging actually goes only to stderr - this primarily ensure we log any
 	// unexpected output to stdout.
@@ -111,8 +108,6 @@ func (cluster *openshiftCluster) startMaster(c *check.C) {
 
 	gotPortCheck := false
 	gotLogCheck := false
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer cancel()
 	for !gotPortCheck || !gotLogCheck {
 		c.Logf("Waiting for master")
 		select {
@@ -125,8 +120,6 @@ func (cluster *openshiftCluster) startMaster(c *check.C) {
 				c.Fatal("log check done, success message not found")
 			}
 			gotLogCheck = true
-		case <-ctx.Done():
-			c.Fatalf("Timed out waiting for master: %v", ctx.Err())
 		}
 	}
 	c.Logf("OK, master started!")
@@ -172,14 +165,8 @@ func (cluster *openshiftCluster) startRegistryProcess(c *check.C, port int, conf
 		terminatePortCheck <- true
 	}()
 	c.Logf("Waiting for registry to start")
-	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
-	defer cancel()
-	select {
-	case <-portOpen:
-		c.Logf("OK, Registry port open")
-	case <-ctx.Done():
-		c.Fatalf("Timed out waiting for registry to start: %v", ctx.Err())
-	}
+	<-portOpen
+	c.Logf("OK, Registry port open")
 
 	return cmd
 }

integration/openshift_shell_test.go

@@ -1,4 +1,3 @@
-//go:build openshift_shell
 // +build openshift_shell
 
 package main
@@ -7,7 +6,7 @@ import (
 	"os"
 	"os/exec"
 
-	"gopkg.in/check.v1"
+	"github.com/go-check/check"
 )
 
 /*
@@ -20,8 +19,8 @@ to start a container, then within the container:
 	SKOPEO_CONTAINER_TESTS=1 PS1='nested> ' go test -tags openshift_shell -timeout=24h ./integration -v -check.v -check.vv -check.f='CopySuite.TestRunShell'
 
 An example of what can be done within the container:
-	cd ..; make bin/skopeo PREFIX=/usr install
-	./skopeo --tls-verify=false  copy --sign-by=personal@example.com docker://quay.io/libpod/busybox:latest atomic:localhost:5000/myns/personal:personal
+	cd ..; make bin/skopeo install
+	./skopeo --tls-verify=false  copy --sign-by=personal@example.com docker://busybox:latest atomic:localhost:5000/myns/personal:personal
 	oc get istag personal:personal -o json
 	curl -L -v 'http://localhost:5000/v2/'
 	cat ~/.docker/config.json

integration/registry.go

@@ -9,7 +9,7 @@ import (
 	"path/filepath"
 	"time"
 
-	"gopkg.in/check.v1"
+	"github.com/go-check/check"
 )
 
 const (

integration/signing_test.go

@@ -9,7 +9,7 @@ import (
 	"strings"
 
 	"github.com/containers/image/v5/signature"
-	"gopkg.in/check.v1"
+	"github.com/go-check/check"
 )
 
 const (

integration/sync_test.go

@@ -12,10 +12,8 @@ import (
 
 	"github.com/containers/image/v5/docker"
 	"github.com/containers/image/v5/docker/reference"
-	"github.com/containers/image/v5/manifest"
 	"github.com/containers/image/v5/types"
-	imgspecv1 "github.com/opencontainers/image-spec/specs-go/v1"
-	"gopkg.in/check.v1"
+	"github.com/go-check/check"
 )
 
 const (
@@ -474,26 +472,6 @@ func (s *SyncSuite) TestYamlTLSVerify(c *check.C) {
 
 }
 
-func (s *SyncSuite) TestSyncManifestOutput(c *check.C) {
-	tmpDir, err := ioutil.TempDir("", "sync-manifest-output")
-	c.Assert(err, check.IsNil)
-	defer os.RemoveAll(tmpDir)
-
-	destDir1 := filepath.Join(tmpDir, "dest1")
-	destDir2 := filepath.Join(tmpDir, "dest2")
-	destDir3 := filepath.Join(tmpDir, "dest3")
-
-	//Split image:tag path from image URI for manifest comparison
-	imageDir := pullableTaggedImage[strings.LastIndex(pullableTaggedImage, "/")+1:]
-
-	assertSkopeoSucceeds(c, "", "sync", "--format=oci", "--all", "--src", "docker", "--dest", "dir", pullableTaggedImage, destDir1)
-	verifyManifestMIMEType(c, filepath.Join(destDir1, imageDir), imgspecv1.MediaTypeImageManifest)
-	assertSkopeoSucceeds(c, "", "sync", "--format=v2s2", "--all", "--src", "docker", "--dest", "dir", pullableTaggedImage, destDir2)
-	verifyManifestMIMEType(c, filepath.Join(destDir2, imageDir), manifest.DockerV2Schema2MediaType)
-	assertSkopeoSucceeds(c, "", "sync", "--format=v2s1", "--all", "--src", "docker", "--dest", "dir", pullableTaggedImage, destDir3)
-	verifyManifestMIMEType(c, filepath.Join(destDir3, imageDir), manifest.DockerV2Schema1SignedMediaType)
-}
-
 func (s *SyncSuite) TestDocker2DockerTagged(c *check.C) {
 	const localRegURL = "docker://" + v2DockerRegistryURL + "/"
 
@@ -635,7 +613,7 @@ func (s *SyncSuite) TestFailsWithDockerSourceNotExisting(c *check.C) {
 		"sync", "--scoped", "--src-tls-verify=false", "--src", "docker", "--dest", "dir", repo, tmpDir)
 
 	//tagged
-	assertSkopeoFails(c, ".*reading manifest.*",
+	assertSkopeoFails(c, ".*Error reading manifest.*",
 		"sync", "--scoped", "--src-tls-verify=false", "--src", "docker", "--dest", "dir", repo+":thetag", tmpDir)
 }
 

integration/utils.go

@@ -10,17 +10,12 @@ import (
 	"strings"
 	"time"
 
-	"github.com/containers/image/v5/manifest"
-	"gopkg.in/check.v1"
+	"github.com/go-check/check"
 )
 
 const skopeoBinary = "skopeo"
 const decompressDirsBinary = "./decompress-dirs.sh"
 
-const testFQIN = "docker://quay.io/libpod/busybox" // tag left off on purpose, some tests need to add a special one
-const testFQIN64 = "docker://quay.io/libpod/busybox:amd64"
-const testFQINMultiLayer = "docker://quay.io/libpod/alpine_nginx:master" // multi-layer
-
 // consumeAndLogOutputStream takes (f, err) from an exec.*Pipe(), and causes all output to it to be logged to c.
 func consumeAndLogOutputStream(c *check.C, id string, f io.ReadCloser, err error) {
 	c.Assert(err, check.IsNil)
@@ -205,11 +200,3 @@ func runDecompressDirs(c *check.C, regexp string, args ...string) {
 		c.Assert(string(out), check.Matches, "(?s)"+regexp) // (?s) : '.' will also match newlines
 	}
 }
-
-// Verify manifest in a dir: image at dir is expectedMIMEType.
-func verifyManifestMIMEType(c *check.C, dir string, expectedMIMEType string) {
-	manifestBlob, err := ioutil.ReadFile(filepath.Join(dir, "manifest.json"))
-	c.Assert(err, check.IsNil)
-	mimeType := manifest.GuessMIMEType(manifestBlob)
-	c.Assert(mimeType, check.Equals, expectedMIMEType)
-}

nix/default.nix

@@ -0,0 +1,57 @@
+{ system ? builtins.currentSystem }:
+let
+  pkgs = (import ./nixpkgs.nix {
+    config = {
+      packageOverrides = pkg: {
+        gpgme = (static pkg.gpgme);
+        libassuan = (static pkg.libassuan);
+        libgpgerror = (static pkg.libgpgerror);
+        libseccomp = (static pkg.libseccomp);
+        glib = (static pkg.glib).overrideAttrs(x: {
+          outputs = [ "bin" "out" "dev" ];
+          mesonFlags = [
+            "-Ddefault_library=static"
+            "-Ddevbindir=${placeholder ''dev''}/bin"
+            "-Dgtk_doc=false"
+            "-Dnls=disabled"
+          ];
+        });
+      };
+    };
+  });
+
+  static = pkg: pkg.overrideAttrs(x: {
+    doCheck = false;
+    configureFlags = (x.configureFlags or []) ++ [
+      "--without-shared"
+      "--disable-shared"
+    ];
+    dontDisableStatic = true;
+    enableSharedExecutables = false;
+    enableStatic = true;
+  });
+
+  self = with pkgs; buildGoModule rec {
+    name = "skopeo";
+    src = ./..;
+    vendorSha256 = null;
+    doCheck = false;
+    enableParallelBuilding = true;
+    outputs = [ "out" ];
+    nativeBuildInputs = [ bash gitMinimal go-md2man installShellFiles makeWrapper pkg-config which ];
+    buildInputs = [ glibc glibc.static gpgme libassuan libgpgerror libseccomp ];
+    prePatch = ''
+      export CFLAGS='-static -pthread'
+      export LDFLAGS='-s -w -static-libgcc -static'
+      export EXTRA_LDFLAGS='-s -w -linkmode external -extldflags "-static -lm"'
+      export BUILDTAGS='static netgo osusergo exclude_graphdriver_btrfs exclude_graphdriver_devicemapper'
+    '';
+    buildPhase = ''
+      patchShebangs .
+      make bin/skopeo
+    '';
+    installPhase = ''
+      install -Dm755 bin/skopeo $out/bin/skopeo
+    '';
+  };
+in self

nix/nixpkgs.json

@@ -0,0 +1,10 @@
+{
+  "url": "https://github.com/nixos/nixpkgs",
+  "rev": "4a75203f0270f96cbc87f5dfa5d5185690237d87",
+  "date": "2020-12-29T03:18:48+01:00",
+  "path": "/nix/store/scswsm6r4jnhp9ki0f6s81kpj5x6jkn7-nixpkgs",
+  "sha256": "0h70fm9aa7s06wkalbadw70z5rscbs3p6nblb47z523nhlzgjxk9",
+  "fetchSubmodules": false,
+  "deepClone": false,
+  "leaveDotGit": false
+}

nix/nixpkgs.nix

@@ -0,0 +1,8 @@
+let
+  json = builtins.fromJSON (builtins.readFile ./nixpkgs.json);
+  nixpkgs = import (builtins.fetchTarball {
+    name = "nixos-unstable";
+    url = "${json.url}/archive/${json.rev}.tar.gz";
+    inherit (json) sha256;
+  });
+in nixpkgs

release/Makefile

@@ -0,0 +1,51 @@
+## This Makefile is used to publish skopeo container images with Travis CI ##
+## Environment variables, used in this Makefile are specified in .travis.yml
+
+export DOCKER_CLI_EXPERIMENTAL=enabled
+GOARCH ?= $(shell go env GOARCH)
+
+# Dereference variable $(1), return value if non-empty, otherwise raise an error.
+err_if_empty = $(if $(strip $($(1))),$(strip $($(1))),$(error Required $(1) variable is undefined or empty))
+
+# Requires two arguments: Names of the username and the password env. vars.
+define quay_login
+	@echo "$(call err_if_empty,$(2))" | \
+		docker login quay.io -u "$(call err_if_empty,$(1))" --password-stdin
+endef
+
+# Build container image of skopeo upstream based on host architecture
+build-image/upstream:
+	docker build -t "${UPSTREAM_IMAGE}-${GOARCH}" contrib/skopeoimage/upstream
+
+# Build container image of skopeo stable based on host architecture
+build-image/stable:
+	docker build -t "${STABLE_IMAGE}-${GOARCH}" contrib/skopeoimage/stable
+
+# Push container image of skopeo upstream (based on host architecture) to image repository
+push-image/upstream:
+	$(call quay_login,SKOPEO_QUAY_USERNAME,SKOPEO_QUAY_PASSWORD)
+	docker push "${UPSTREAM_IMAGE}-${GOARCH}"
+
+# Push container image of skopeo stable (based on host architecture) to image default and extra repositories
+push-image/stable:
+	$(call quay_login,SKOPEO_QUAY_USERNAME,SKOPEO_QUAY_PASSWORD)
+	docker push "${STABLE_IMAGE}-${GOARCH}"
+	docker tag "${STABLE_IMAGE}-${GOARCH}" "${EXTRA_STABLE_IMAGE}-${GOARCH}"
+	$(call quay_login,CONTAINERS_QUAY_USERNAME,CONTAINERS_QUAY_PASSWORD)
+	docker push "${EXTRA_STABLE_IMAGE}-${GOARCH}"
+
+# Create and push multiarch image manifest of skopeo upstream
+push-manifest-multiarch/upstream:
+	docker manifest create "${UPSTREAM_IMAGE}" $(foreach arch,${MULTIARCH_MANIFEST_ARCHITECTURES}, ${UPSTREAM_IMAGE}-${arch})
+	$(call quay_login,SKOPEO_QUAY_USERNAME,SKOPEO_QUAY_PASSWORD)
+	docker manifest push --purge "${UPSTREAM_IMAGE}"
+
+# Create and push multiarch image manifest of skopeo stable
+push-manifest-multiarch/stable:
+	docker manifest create "${STABLE_IMAGE}" $(foreach arch,${MULTIARCH_MANIFEST_ARCHITECTURES}, ${STABLE_IMAGE}-${arch})
+	$(call quay_login,SKOPEO_QUAY_USERNAME,SKOPEO_QUAY_PASSWORD)
+	docker manifest push --purge "${STABLE_IMAGE}"
+	# Push to extra repository
+	docker manifest create "${EXTRA_STABLE_IMAGE}" $(foreach arch,${MULTIARCH_MANIFEST_ARCHITECTURES}, ${EXTRA_STABLE_IMAGE}-${arch})
+	$(call quay_login,CONTAINERS_QUAY_USERNAME,CONTAINERS_QUAY_PASSWORD)
+	docker manifest push --purge "${EXTRA_STABLE_IMAGE}"

release/README.md

@@ -0,0 +1,40 @@
+# skopeo container image build with Travis
+
+This document describes the details and requirements to build and publish skopeo container images. The images are published as several architecture specific images and multiarch images on top for upstream and stable versions.
+
+The Travis configuration is available at `.travis.yml`.
+
+The code to build and publish images is available at `release/Makefile` and should be used only via Travis.
+
+Travis workflow has 3 major pieces:
+- `local-build` - build and test source code locally on osx and linux/amd64 environments, 2 jobs are running in parallel
+- `image-build-push` - build and push container images with several Travis jobs running in parallel to build images for several architectures (linux/amd64, linux/s390x, linux/ppc64le). Build part is done for each PR, push part is executed only in case of cron job or master branch update.
+- `manifest-multiarch-push` - create and push image manifests, which consists of architecture specific images from previous step. Executed only in case of cron job or master branch update.
+
+## Ways to have full workflow run
+- [cron job](https://docs.travis-ci.com/user/cron-jobs/#adding-cron-jobs)
+- Trigger build from Travis CI
+- Update code in master branch
+
+## Environment variables
+
+Several environment variables are used to customize image names and keep private credentials to push to quay.io repositories.
+
+**Image tags** are specified in environment variable and should be manually updated in case of new release.
+
+- `SKOPEO_QUAY_USERNAME` and `SKOPEO_QUAY_PASSWORD` are credentials to push images to `quay.io/skopeo/stable` and `quay.io/skopeo/upstream` repos, and require the credentials to have write permissions. These variables should be specified in [Travis](https://docs.travis-ci.com/user/environment-variables/#defining-variables-in-repository-settings).
+- `CONTAINERS_QUAY_USERNAME` and `CONTAINERS_QUAY_PASSWORD` are credentials to push images to `quay.io/containers/skopeo` repos, and require the credentials to have write permissions. These variables should be specified in [Travis](https://docs.travis-ci.com/user/environment-variables/#defining-variables-in-repository-settings).
+
+Variables in .travis.yml
+- `MULTIARCH_MANIFEST_ARCHITECTURES` is a list with architecture shortnames, to appear in final multiarch manifest. The values should fit to architectures used in the `image-build-push` Travis step.
+- `STABLE_IMAGE`, `EXTRA_STABLE_IMAGE` are image names to publish stable Skopeo.
+- `UPSTREAM_IMAGE` is an image name to publish upstream Skopeo.
+
+### Values for environment variables
+
+| Env variable                     | Value                            |
+| -------------------------------- |----------------------------------|
+| MULTIARCH_MANIFEST_ARCHITECTURES | "amd64 s390x ppc64le"            |
+| STABLE_IMAGE                     | quay.io/skopeo/stable:v1.2.0     |
+| EXTRA_STABLE_IMAGE               | quay.io/containers/skopeo:v1.2.0 |
+| UPSTREAM_IMAGE                   | quay.io/skopeo/upstream:master   |

systemtest/010-inspect.bats

@@ -93,7 +93,7 @@ END_EXPECT
 
     # By default, 'inspect' tries to match our host os+arch. This should fail.
     run_skopeo 1 inspect $img
-    expect_output --substring "parsing manifest for image: choosing image instance: no image found in manifest list for architecture $arch, variant " \
+    expect_output --substring "Error parsing manifest for image: Error choosing image instance: no image found in manifest list for architecture $arch, variant " \
                   "skopeo inspect, without --raw, fails"
 
     # With --raw, we can inspect
@@ -108,15 +108,4 @@ END_EXPECT
                   "os - variant - architecture of $img"
 }
 
-@test "inspect: don't list tags" {
-    remote_image=docker://quay.io/fedora/fedora
-    # use --no-tags to not list any tags
-    run_skopeo inspect --no-tags $remote_image
-    inspect_output=$output
-    # extract the content of "RepoTags" property from the JSON output
-    repo_tags=$(jq '.RepoTags[]' <<<"$inspect_output")
-    # verify that the RepoTags was empty
-    expect_output --from="$repo_tags" "" "inspect --no-tags was expected to return empty RepoTags[]"
-}
-
 # vim: filetype=sh

systemtest/020-copy.bats

@@ -45,7 +45,7 @@ function setup() {
 }
 
 # Compression zstd
-@test "copy: oci, zstd" {
+@test "copy: oci, round trip, zstd" {
     local remote_image=docker://quay.io/libpod/busybox:latest
 
     local dir=$TESTDIR/dir
@@ -57,12 +57,6 @@ function setup() {
 
     # Check there is at least one file that has the zstd magic number as the first 4 bytes
     (for i in $dir/blobs/sha256/*; do test "$(head -c 4 $i)" = $magic && exit 0; done; exit 1)
-
-    # Check that the manifest's description of the image's first layer is the zstd layer type
-    instance=$(jq -r '.manifests[0].digest' $dir/index.json)
-    [[ "$instance" != null ]]
-    mediatype=$(jq -r '.layers[0].mediaType' < $dir/blobs/${instance/://})
-    [[ "$mediatype" == "application/vnd.oci.image.layer.v1.tar+zstd" ]]
 }
 
 # Same image, extracted once with :tag and once without
@@ -100,50 +94,6 @@ function setup() {
                docker://localhost:5000/foo
 }
 
-# manifest format
-@test "copy: manifest format" {
-    local remote_image=docker://quay.io/libpod/busybox:latest
-
-    local dir1=$TESTDIR/dir1
-    local dir2=$TESTDIR/dir2
-
-    run_skopeo copy --format v2s2 $remote_image dir:$dir1
-    run_skopeo copy --format oci $remote_image dir:$dir2
-    grep 'application/vnd.docker.distribution.manifest.v2' $dir1/manifest.json
-    grep 'application/vnd.oci.image' $dir2/manifest.json
-}
-
-# additional tag
-@test "copy: additional tag" {
-    local remote_image=docker://quay.io/libpod/busybox:latest
-
-    # additional-tag is supported only for docker-archive
-    run_skopeo copy --additional-tag busybox:mine $remote_image \
-               docker-archive:$TESTDIR/mybusybox.tar:busybox:latest
-    mkdir -p $TESTDIR/podmanroot
-    run podman --root $TESTDIR/podmanroot load -i $TESTDIR/mybusybox.tar
-    run podman --root $TESTDIR/podmanroot images
-    expect_output --substring "mine"
-
-}
-
-# shared blob directory
-@test "copy: shared blob directory" {
-    local remote_image=docker://quay.io/libpod/busybox:latest
-
-    local shareddir=$TESTDIR/shareddir
-    local dir1=$TESTDIR/dir1
-    local dir2=$TESTDIR/dir2
-
-    run_skopeo copy --dest-shared-blob-dir $shareddir \
-               $remote_image oci:$dir1
-    [ -n "$(ls $shareddir)" ]
-    [ -z "$(ls $dir1/blobs)" ]
-    run_skopeo copy --src-shared-blob-dir $shareddir \
-               oci:$dir1 oci:$dir2
-    diff -urN $shareddir $dir2/blobs
-}
-
 teardown() {
     podman rm -f reg
 

systemtest/030-local-registry-tls.bats

@@ -8,7 +8,7 @@ load helpers
 function setup() {
     standard_setup
 
-    start_registry --with-cert --enable-delete=true reg
+    start_registry --with-cert reg
 }
 
 @test "local registry, with cert" {
@@ -21,15 +21,6 @@ function setup() {
     run_skopeo copy --src-cert-dir=$TESTDIR/client-auth \
                docker://localhost:5000/busybox:unsigned \
                dir:$TESTDIR/extracted
-
-    # inspect with cert
-    run_skopeo inspect --cert-dir=$TESTDIR/client-auth \
-               docker://localhost:5000/busybox:unsigned
-    expect_output --substring "localhost:5000/busybox"
-
-    # delete with cert
-    run_skopeo delete --cert-dir=$TESTDIR/client-auth \
-               docker://localhost:5000/busybox:unsigned
 }
 
 teardown() {

systemtest/040-local-registry-auth.bats

@@ -18,7 +18,7 @@ function setup() {
     testuser=testuser
     testpassword=$(random_string 15)
 
-    start_registry --testuser=$testuser --testpassword=$testpassword --enable-delete=true reg
+    start_registry --testuser=$testuser --testpassword=$testpassword reg
 }
 
 @test "auth: credentials on command line" {
@@ -67,47 +67,6 @@ function setup() {
     expect_output --substring "unauthorized: authentication required"
 }
 
-@test "auth: copy with --src-creds and --dest-creds" {
-    run_skopeo copy --dest-tls-verify=false --dest-creds=$testuser:$testpassword \
-               docker://quay.io/libpod/busybox:latest \
-               docker://localhost:5000/busybox:mine
-    run_skopeo copy --src-tls-verify=false --src-creds=$testuser:$testpassword \
-               docker://localhost:5000/busybox:mine \
-               dir:$TESTDIR/dir1
-    run ls $TESTDIR/dir1
-    expect_output --substring "manifest.json"
-}
-
-@test "auth: credentials via authfile" {
-    podman login --tls-verify=false --authfile $TESTDIR/test.auth -u $testuser -p $testpassword localhost:5000
-
-    # copy without authfile: should fail
-    run_skopeo 1 copy --dest-tls-verify=false \
-               docker://quay.io/libpod/busybox:latest \
-               docker://localhost:5000/busybox:mine
-
-    # copy with authfile: should work
-    run_skopeo copy --dest-tls-verify=false \
-               --authfile $TESTDIR/test.auth \
-               docker://quay.io/libpod/busybox:latest \
-               docker://localhost:5000/busybox:mine
-
-    # inspect without authfile: should fail
-    run_skopeo 1 inspect --tls-verify=false docker://localhost:5000/busybox:mine
-    expect_output --substring "unauthorized: authentication required"
-
-    # inspect with authfile: should work
-    run_skopeo inspect --tls-verify=false --authfile $TESTDIR/test.auth docker://localhost:5000/busybox:mine
-    expect_output --substring "localhost:5000/busybox"
-
-    # delete without authfile: should fail
-    run_skopeo 1 delete --tls-verify=false docker://localhost:5000/busybox:mine
-    expect_output --substring "authentication required"
-
-    # delete with authfile: should work
-    run_skopeo delete --tls-verify=false --authfile $TESTDIR/test.auth docker://localhost:5000/busybox:mine
-}
-
 teardown() {
     podman rm -f reg
 

systemtest/050-signing.bats

@@ -143,75 +143,6 @@ END_PUSH
 END_TESTS
 }
 
-@test "signing: remove signature" {
-    run_skopeo '?' standalone-sign /dev/null busybox alice@test.redhat.com -o /dev/null
-    if [[ "$output" =~ 'signing is not supported' ]]; then
-        skip "skopeo built without support for creating signatures"
-        return 1
-    fi
-    if [ "$status" -ne 0 ]; then
-        die "exit code is $status; expected 0"
-    fi
-
-    # Cache local copy
-    run_skopeo copy docker://quay.io/libpod/busybox:latest \
-               dir:$TESTDIR/busybox
-    # Push a signed image
-    run_skopeo --registries.d $REGISTRIES_D \
-               copy --dest-tls-verify=false \
-               --sign-by=alice@test.redhat.com \
-               dir:$TESTDIR/busybox \
-               docker://localhost:5000/myns/alice:signed
-    # Fetch the image with signature
-    run_skopeo  --registries.d $REGISTRIES_D \
-                --policy $POLICY_JSON \
-                copy --src-tls-verify=false \
-                docker://localhost:5000/myns/alice:signed \
-                dir:$TESTDIR/busybox-signed
-    # Fetch the image with removing signature
-    run_skopeo  --registries.d $REGISTRIES_D \
-                --policy $POLICY_JSON \
-                copy --src-tls-verify=false \
-                --remove-signatures \
-                docker://localhost:5000/myns/alice:signed \
-                dir:$TESTDIR/busybox-unsigned
-    ls $TESTDIR/busybox-signed | grep "signature"
-    [ -z "$(ls $TESTDIR/busybox-unsigned | grep "signature")" ]
-}
-
-@test "signing: standalone" {
-    run_skopeo '?' standalone-sign /dev/null busybox alice@test.redhat.com -o /dev/null
-    if [[ "$output" =~ 'signing is not supported' ]]; then
-        skip "skopeo built without support for creating signatures"
-        return 1
-    fi
-    if [ "$status" -ne 0 ]; then
-        die "exit code is $status; expected 0"
-    fi
-
-    run_skopeo copy --dest-tls-verify=false \
-               docker://quay.io/libpod/busybox:latest \
-               docker://localhost:5000/busybox:latest
-    run_skopeo copy --src-tls-verify=false \
-               docker://localhost:5000/busybox:latest \
-               dir:$TESTDIR/busybox
-    # Standalone sign
-    run_skopeo standalone-sign -o $TESTDIR/busybox.signature \
-               $TESTDIR/busybox/manifest.json \
-               localhost:5000/busybox:latest \
-               alice@test.redhat.com
-    # Standalone verify
-    fingerprint=$(gpg --list-keys | grep -B1 alice.test.redhat.com | head -n 1)
-    run_skopeo standalone-verify $TESTDIR/busybox/manifest.json \
-               localhost:5000/busybox:latest \
-               $fingerprint \
-               $TESTDIR/busybox.signature
-    # manifest digest
-    digest=$(echo "$output" | awk '{print $4;}')
-    run_skopeo manifest-digest $TESTDIR/busybox/manifest.json
-    expect_output $digest
-}
-
 teardown() {
     podman rm -f reg
 

systemtest/helpers.bash

@@ -359,7 +359,6 @@ start_registry() {
         timeout=$(expr $timeout - 1)
         sleep 1
     done
-    log_and_run $PODMAN logs $name
     die "Timed out waiting for registry container to respond on :$port"
 }
 

vendor/github.com/BurntSushi/toml/.gitignore

@@ -1,2 +1,5 @@
+TAGS
+tags
+.*.swp
+tomlcheck/tomlcheck
 toml.test
-/toml-test

vendor/github.com/BurntSushi/toml/.travis.yml

@@ -0,0 +1,15 @@
+language: go
+go:
+  - 1.1
+  - 1.2
+  - 1.3
+  - 1.4
+  - 1.5
+  - 1.6
+  - tip
+install:
+  - go install ./...
+  - go get github.com/BurntSushi/toml-test
+script:
+  - export PATH="$PATH:$HOME/gopath/bin"
+  - make test

vendor/github.com/BurntSushi/toml/COMPATIBLE

@@ -1 +1,3 @@
-Compatible with TOML version [v1.0.0](https://toml.io/en/v1.0.0).
+Compatible with TOML version
+[v0.4.0](https://github.com/toml-lang/toml/blob/v0.4.0/versions/en/toml-v0.4.0.md)
+

vendor/github.com/BurntSushi/toml/Makefile

@@ -0,0 +1,19 @@
+install:
+	go install ./...
+
+test: install
+	go test -v
+	toml-test toml-test-decoder
+	toml-test -encoder toml-test-encoder
+
+fmt:
+	gofmt -w *.go */*.go
+	colcheck *.go */*.go
+
+tags:
+	find ./ -name '*.go' -print0 | xargs -0 gotags > TAGS
+
+push:
+	git push origin master
+	git push github master
+

vendor/github.com/BurntSushi/toml/README.md

@@ -6,22 +6,27 @@ packages. This package also supports the `encoding.TextUnmarshaler` and
 `encoding.TextMarshaler` interfaces so that you can define custom data
 representations. (There is an example of this below.)
 
-Compatible with TOML version [v1.0.0](https://toml.io/en/v1.0.0).
+Spec: https://github.com/toml-lang/toml
 
-Documentation: https://godocs.io/github.com/BurntSushi/toml
+Compatible with TOML version
+[v0.4.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md)
 
-See the [releases page](https://github.com/BurntSushi/toml/releases) for a
-changelog; this information is also in the git tag annotations (e.g. `git show
-v0.4.0`).
+Documentation: https://godoc.org/github.com/BurntSushi/toml
 
-This library requires Go 1.13 or newer; install it with:
+Installation:
 
-    $ go get github.com/BurntSushi/toml
+```bash
+go get github.com/BurntSushi/toml
+```
 
-It also comes with a TOML validator CLI tool:
+Try the toml validator:
 
-    $ go get github.com/BurntSushi/toml/cmd/tomlv
-    $ tomlv some-toml-file.toml
+```bash
+go get github.com/BurntSushi/toml/cmd/tomlv
+tomlv some-toml-file.toml
+```
+
+[![Build Status](https://travis-ci.org/BurntSushi/toml.svg?branch=master)](https://travis-ci.org/BurntSushi/toml) [![GoDoc](https://godoc.org/github.com/BurntSushi/toml?status.svg)](https://godoc.org/github.com/BurntSushi/toml)
 
 ### Testing
 
@@ -31,8 +36,8 @@ and the encoder.
 
 ### Examples
 
-This package works similarly to how the Go standard library handles XML and
-JSON. Namely, data is loaded into Go values via reflection.
+This package works similarly to how the Go standard library handles `XML`
+and `JSON`. Namely, data is loaded into Go values via reflection.
 
 For the simplest example, consider some TOML file as just a list of keys
 and values:
@@ -49,11 +54,11 @@ Which could be defined in Go as:
 
 ```go
 type Config struct {
-	Age        int
-	Cats       []string
-	Pi         float64
-	Perfection []int
-	DOB        time.Time // requires `import time`
+  Age int
+  Cats []string
+  Pi float64
+  Perfection []int
+  DOB time.Time // requires `import time`
 }
 ```
 
@@ -79,9 +84,6 @@ type TOML struct {
 }
 ```
 
-Beware that like other most other decoders **only exported fields** are
-considered when encoding and decoding; private fields are silently ignored.
-
 ### Using the `encoding.TextUnmarshaler` interface
 
 Here's an example that automatically parses duration strings into
@@ -101,19 +103,19 @@ Which can be decoded with:
 
 ```go
 type song struct {
-	Name     string
-	Duration duration
+  Name     string
+  Duration duration
 }
 type songs struct {
-	Song []song
+  Song []song
 }
 var favorites songs
 if _, err := toml.Decode(blob, &favorites); err != nil {
-	log.Fatal(err)
+  log.Fatal(err)
 }
 
 for _, s := range favorites.Song {
-	fmt.Printf("%s (%s)\n", s.Name, s.Duration)
+  fmt.Printf("%s (%s)\n", s.Name, s.Duration)
 }
 ```
 
@@ -132,9 +134,6 @@ func (d *duration) UnmarshalText(text []byte) error {
 }
 ```
 
-To target TOML specifically you can implement `UnmarshalTOML` TOML interface in
-a similar way.
-
 ### More complex usage
 
 Here's an example of how to load the example from the official spec page:
@@ -181,23 +180,23 @@ And the corresponding Go types are:
 
 ```go
 type tomlConfig struct {
-	Title   string
-	Owner   ownerInfo
-	DB      database `toml:"database"`
+	Title string
+	Owner ownerInfo
+	DB database `toml:"database"`
 	Servers map[string]server
 	Clients clients
 }
 
 type ownerInfo struct {
 	Name string
-	Org  string `toml:"organization"`
-	Bio  string
-	DOB  time.Time
+	Org string `toml:"organization"`
+	Bio string
+	DOB time.Time
 }
 
 type database struct {
-	Server  string
-	Ports   []int
+	Server string
+	Ports []int
 	ConnMax int `toml:"connection_max"`
 	Enabled bool
 }
@@ -208,7 +207,7 @@ type server struct {
 }
 
 type clients struct {
-	Data  [][]interface{}
+	Data [][]interface{}
 	Hosts []string
 }
 ```
@@ -217,4 +216,3 @@ Note that a case insensitive match will be tried if an exact match can't be
 found.
 
 A working example of the above can be found in `_examples/example.{go,toml}`.
-

vendor/github.com/BurntSushi/toml/decode.go

@@ -1,17 +1,19 @@
 package toml
 
 import (
-	"encoding"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"math"
-	"os"
 	"reflect"
 	"strings"
 	"time"
 )
 
+func e(format string, args ...interface{}) error {
+	return fmt.Errorf("toml: "+format, args...)
+}
+
 // Unmarshaler is the interface implemented by objects that can unmarshal a
 // TOML description of themselves.
 type Unmarshaler interface {
@@ -25,21 +27,30 @@ func Unmarshal(p []byte, v interface{}) error {
 }
 
 // Primitive is a TOML value that hasn't been decoded into a Go value.
+// When using the various `Decode*` functions, the type `Primitive` may
+// be given to any value, and its decoding will be delayed.
 //
-// This type can be used for any value, which will cause decoding to be delayed.
-// You can use the PrimitiveDecode() function to "manually" decode these values.
+// A `Primitive` value can be decoded using the `PrimitiveDecode` function.
 //
-// NOTE: The underlying representation of a `Primitive` value is subject to
-// change. Do not rely on it.
+// The underlying representation of a `Primitive` value is subject to change.
+// Do not rely on it.
 //
-// NOTE: Primitive values are still parsed, so using them will only avoid the
-// overhead of reflection. They can be useful when you don't know the exact type
-// of TOML data until runtime.
+// N.B. Primitive values are still parsed, so using them will only avoid
+// the overhead of reflection. They can be useful when you don't know the
+// exact type of TOML data until run time.
 type Primitive struct {
 	undecoded interface{}
 	context   Key
 }
 
+// DEPRECATED!
+//
+// Use MetaData.PrimitiveDecode instead.
+func PrimitiveDecode(primValue Primitive, v interface{}) error {
+	md := MetaData{decoded: make(map[string]bool)}
+	return md.unify(primValue.undecoded, rvalue(v))
+}
+
 // PrimitiveDecode is just like the other `Decode*` functions, except it
 // decodes a TOML value that has already been parsed. Valid primitive values
 // can *only* be obtained from values filled by the decoder functions,
@@ -57,51 +68,43 @@ func (md *MetaData) PrimitiveDecode(primValue Primitive, v interface{}) error {
 	return md.unify(primValue.undecoded, rvalue(v))
 }
 
-// Decoder decodes TOML data.
+// Decode will decode the contents of `data` in TOML format into a pointer
+// `v`.
 //
-// TOML tables correspond to Go structs or maps (dealer's choice – they can be
-// used interchangeably).
+// TOML hashes correspond to Go structs or maps. (Dealer's choice. They can be
+// used interchangeably.)
 //
-// TOML table arrays correspond to either a slice of structs or a slice of maps.
+// TOML arrays of tables correspond to either a slice of structs or a slice
+// of maps.
 //
-// TOML datetimes correspond to Go time.Time values. Local datetimes are parsed
-// in the local timezone.
+// TOML datetimes correspond to Go `time.Time` values.
 //
-// All other TOML types (float, string, int, bool and array) correspond to the
-// obvious Go types.
+// All other TOML types (float, string, int, bool and array) correspond
+// to the obvious Go types.
 //
-// An exception to the above rules is if a type implements the TextUnmarshaler
-// interface, in which case any primitive TOML value (floats, strings, integers,
-// booleans, datetimes) will be converted to a []byte and given to the value's
-// UnmarshalText method. See the Unmarshaler example for a demonstration with
-// time duration strings.
+// An exception to the above rules is if a type implements the
+// encoding.TextUnmarshaler interface. In this case, any primitive TOML value
+// (floats, strings, integers, booleans and datetimes) will be converted to
+// a byte string and given to the value's UnmarshalText method. See the
+// Unmarshaler example for a demonstration with time duration strings.
 //
 // Key mapping
 //
-// TOML keys can map to either keys in a Go map or field names in a Go struct.
-// The special `toml` struct tag can be used to map TOML keys to struct fields
-// that don't match the key name exactly (see the example). A case insensitive
-// match to struct names will be tried if an exact match can't be found.
+// TOML keys can map to either keys in a Go map or field names in a Go
+// struct. The special `toml` struct tag may be used to map TOML keys to
+// struct fields that don't match the key name exactly. (See the example.)
+// A case insensitive match to struct names will be tried if an exact match
+// can't be found.
 //
-// The mapping between TOML values and Go values is loose. That is, there may
-// exist TOML values that cannot be placed into your representation, and there
-// may be parts of your representation that do not correspond to TOML values.
-// This loose mapping can be made stricter by using the IsDefined and/or
-// Undecoded methods on the MetaData returned.
+// The mapping between TOML values and Go values is loose. That is, there
+// may exist TOML values that cannot be placed into your representation, and
+// there may be parts of your representation that do not correspond to
+// TOML values. This loose mapping can be made stricter by using the IsDefined
+// and/or Undecoded methods on the MetaData returned.
 //
-// This decoder does not handle cyclic types. Decode will not terminate if a
-// cyclic type is passed.
-type Decoder struct {
-	r io.Reader
-}
-
-// NewDecoder creates a new Decoder.
-func NewDecoder(r io.Reader) *Decoder {
-	return &Decoder{r: r}
-}
-
-// Decode TOML data in to the pointer `v`.
-func (dec *Decoder) Decode(v interface{}) (MetaData, error) {
+// This decoder will not handle cyclic types. If a cyclic type is passed,
+// `Decode` will not terminate.
+func Decode(data string, v interface{}) (MetaData, error) {
 	rv := reflect.ValueOf(v)
 	if rv.Kind() != reflect.Ptr {
 		return MetaData{}, e("Decode of non-pointer %s", reflect.TypeOf(v))
@@ -109,15 +112,7 @@ func (dec *Decoder) Decode(v interface{}) (MetaData, error) {
 	if rv.IsNil() {
 		return MetaData{}, e("Decode of nil %s", reflect.TypeOf(v))
 	}
-
-	// TODO: have parser should read from io.Reader? Or at the very least, make
-	// it read from []byte rather than string
-	data, err := ioutil.ReadAll(dec.r)
-	if err != nil {
-		return MetaData{}, err
-	}
-
-	p, err := parse(string(data))
+	p, err := parse(data)
 	if err != nil {
 		return MetaData{}, err
 	}
@@ -128,22 +123,24 @@ func (dec *Decoder) Decode(v interface{}) (MetaData, error) {
 	return md, md.unify(p.mapping, indirect(rv))
 }
 
-// Decode the TOML data in to the pointer v.
-//
-// See the documentation on Decoder for a description of the decoding process.
-func Decode(data string, v interface{}) (MetaData, error) {
-	return NewDecoder(strings.NewReader(data)).Decode(v)
-}
-
 // DecodeFile is just like Decode, except it will automatically read the
-// contents of the file at path and decode it for you.
-func DecodeFile(path string, v interface{}) (MetaData, error) {
-	fp, err := os.Open(path)
+// contents of the file at `fpath` and decode it for you.
+func DecodeFile(fpath string, v interface{}) (MetaData, error) {
+	bs, err := ioutil.ReadFile(fpath)
 	if err != nil {
 		return MetaData{}, err
 	}
-	defer fp.Close()
-	return NewDecoder(fp).Decode(v)
+	return Decode(string(bs), v)
+}
+
+// DecodeReader is just like Decode, except it will consume all bytes
+// from the reader and decode it for you.
+func DecodeReader(r io.Reader, v interface{}) (MetaData, error) {
+	bs, err := ioutil.ReadAll(r)
+	if err != nil {
+		return MetaData{}, err
+	}
+	return Decode(string(bs), v)
 }
 
 // unify performs a sort of type unification based on the structure of `rv`,
@@ -152,8 +149,8 @@ func DecodeFile(path string, v interface{}) (MetaData, error) {
 // Any type mismatch produces an error. Finding a type that we don't know
 // how to handle produces an unsupported type error.
 func (md *MetaData) unify(data interface{}, rv reflect.Value) error {
+
 	// Special case. Look for a `Primitive` value.
-	// TODO: #76 would make this superfluous after implemented.
 	if rv.Type() == reflect.TypeOf((*Primitive)(nil)).Elem() {
 		// Save the undecoded data and the key context into the primitive
 		// value.
@@ -173,17 +170,25 @@ func (md *MetaData) unify(data interface{}, rv reflect.Value) error {
 		}
 	}
 
+	// Special case. Handle time.Time values specifically.
+	// TODO: Remove this code when we decide to drop support for Go 1.1.
+	// This isn't necessary in Go 1.2 because time.Time satisfies the encoding
+	// interfaces.
+	if rv.Type().AssignableTo(rvalue(time.Time{}).Type()) {
+		return md.unifyDatetime(data, rv)
+	}
+
 	// Special case. Look for a value satisfying the TextUnmarshaler interface.
-	if v, ok := rv.Interface().(encoding.TextUnmarshaler); ok {
+	if v, ok := rv.Interface().(TextUnmarshaler); ok {
 		return md.unifyText(data, v)
 	}
-	// TODO:
+	// BUG(burntsushi)
 	// The behavior here is incorrect whenever a Go type satisfies the
-	// encoding.TextUnmarshaler interface but also corresponds to a TOML hash or
-	// array. In particular, the unmarshaler should only be applied to primitive
-	// TOML values. But at this point, it will be applied to all kinds of values
-	// and produce an incorrect error whenever those values are hashes or arrays
-	// (including arrays of tables).
+	// encoding.TextUnmarshaler interface but also corresponds to a TOML
+	// hash or array. In particular, the unmarshaler should only be applied
+	// to primitive TOML values. But at this point, it will be applied to
+	// all kinds of values and produce an incorrect error whenever those values
+	// are hashes or arrays (including arrays of tables).
 
 	k := rv.Kind()
 
@@ -272,12 +277,6 @@ func (md *MetaData) unifyStruct(mapping interface{}, rv reflect.Value) error {
 }
 
 func (md *MetaData) unifyMap(mapping interface{}, rv reflect.Value) error {
-	if k := rv.Type().Key().Kind(); k != reflect.String {
-		return fmt.Errorf(
-			"toml: cannot decode to a map with non-string key type (%s in %q)",
-			k, rv.Type())
-	}
-
 	tmap, ok := mapping.(map[string]interface{})
 	if !ok {
 		if tmap == nil {
@@ -313,8 +312,10 @@ func (md *MetaData) unifyArray(data interface{}, rv reflect.Value) error {
 		}
 		return badtype("slice", data)
 	}
-	if l := datav.Len(); l != rv.Len() {
-		return e("expected array length %d; got TOML array of length %d", rv.Len(), l)
+	sliceLen := datav.Len()
+	if sliceLen != rv.Len() {
+		return e("expected array length %d; got TOML array of length %d",
+			rv.Len(), sliceLen)
 	}
 	return md.unifySliceArray(datav, rv)
 }
@@ -336,10 +337,11 @@ func (md *MetaData) unifySlice(data interface{}, rv reflect.Value) error {
 }
 
 func (md *MetaData) unifySliceArray(data, rv reflect.Value) error {
-	l := data.Len()
-	for i := 0; i < l; i++ {
-		err := md.unify(data.Index(i).Interface(), indirect(rv.Index(i)))
-		if err != nil {
+	sliceLen := data.Len()
+	for i := 0; i < sliceLen; i++ {
+		v := data.Index(i).Interface()
+		sliceval := indirect(rv.Index(i))
+		if err := md.unify(v, sliceval); err != nil {
 			return err
 		}
 	}
@@ -437,7 +439,7 @@ func (md *MetaData) unifyAnything(data interface{}, rv reflect.Value) error {
 	return nil
 }
 
-func (md *MetaData) unifyText(data interface{}, v encoding.TextUnmarshaler) error {
+func (md *MetaData) unifyText(data interface{}, v TextUnmarshaler) error {
 	var s string
 	switch sdata := data.(type) {
 	case TextMarshaler:
@@ -480,7 +482,7 @@ func indirect(v reflect.Value) reflect.Value {
 	if v.Kind() != reflect.Ptr {
 		if v.CanSet() {
 			pv := v.Addr()
-			if _, ok := pv.Interface().(encoding.TextUnmarshaler); ok {
+			if _, ok := pv.Interface().(TextUnmarshaler); ok {
 				return pv
 			}
 		}
@@ -496,16 +498,12 @@ func isUnifiable(rv reflect.Value) bool {
 	if rv.CanSet() {
 		return true
 	}
-	if _, ok := rv.Interface().(encoding.TextUnmarshaler); ok {
+	if _, ok := rv.Interface().(TextUnmarshaler); ok {
 		return true
 	}
 	return false
 }
 
-func e(format string, args ...interface{}) error {
-	return fmt.Errorf("toml: "+format, args...)
-}
-
 func badtype(expected string, data interface{}) error {
 	return e("cannot load TOML value of type %T into a Go %s", data, expected)
 }

vendor/github.com/BurntSushi/toml/decode_go116.go

@@ -1,18 +0,0 @@
-// +build go1.16
-
-package toml
-
-import (
-	"io/fs"
-)
-
-// DecodeFS is just like Decode, except it will automatically read the contents
-// of the file at `path` from a fs.FS instance.
-func DecodeFS(fsys fs.FS, path string, v interface{}) (MetaData, error) {
-	fp, err := fsys.Open(path)
-	if err != nil {
-		return MetaData{}, err
-	}
-	defer fp.Close()
-	return NewDecoder(fp).Decode(v)
-}

vendor/github.com/BurntSushi/toml/decode_meta.go

@@ -2,9 +2,9 @@ package toml
 
 import "strings"
 
-// MetaData allows access to meta information about TOML data that may not be
-// inferable via reflection. In particular, whether a key has been defined and
-// the TOML type of a key.
+// MetaData allows access to meta information about TOML data that may not
+// be inferrable via reflection. In particular, whether a key has been defined
+// and the TOML type of a key.
 type MetaData struct {
 	mapping map[string]interface{}
 	types   map[string]tomlType
@@ -13,11 +13,10 @@ type MetaData struct {
 	context Key // Used only during decoding.
 }
 
-// IsDefined reports if the key exists in the TOML data.
-//
-// The key should be specified hierarchically, for example to access the TOML
-// key "a.b.c" you would use:
+// IsDefined returns true if the key given exists in the TOML data. The key
+// should be specified hierarchially. e.g.,
 //
+//	// access the TOML key 'a.b.c'
 //	IsDefined("a", "b", "c")
 //
 // IsDefined will return false if an empty key given. Keys are case sensitive.
@@ -42,8 +41,8 @@ func (md *MetaData) IsDefined(key ...string) bool {
 
 // Type returns a string representation of the type of the key specified.
 //
-// Type will return the empty string if given an empty key or a key that does
-// not exist. Keys are case sensitive.
+// Type will return the empty string if given an empty key or a key that
+// does not exist. Keys are case sensitive.
 func (md *MetaData) Type(key ...string) string {
 	fullkey := strings.Join(key, ".")
 	if typ, ok := md.types[fullkey]; ok {
@@ -52,11 +51,13 @@ func (md *MetaData) Type(key ...string) string {
 	return ""
 }
 
-// Key represents any TOML key, including key groups. Use (MetaData).Keys to get
-// values of this type.
+// Key is the type of any TOML key, including key groups. Use (MetaData).Keys
+// to get values of this type.
 type Key []string
 
-func (k Key) String() string { return strings.Join(k, ".") }
+func (k Key) String() string {
+	return strings.Join(k, ".")
+}
 
 func (k Key) maybeQuotedAll() string {
 	var ss []string
@@ -67,9 +68,6 @@ func (k Key) maybeQuotedAll() string {
 }
 
 func (k Key) maybeQuoted(i int) string {
-	if k[i] == "" {
-		return `""`
-	}
 	quote := false
 	for _, c := range k[i] {
 		if !isBareKeyChar(c) {
@@ -78,7 +76,7 @@ func (k Key) maybeQuoted(i int) string {
 		}
 	}
 	if quote {
-		return `"` + quotedReplacer.Replace(k[i]) + `"`
+		return "\"" + strings.Replace(k[i], "\"", "\\\"", -1) + "\""
 	}
 	return k[i]
 }
@@ -91,10 +89,10 @@ func (k Key) add(piece string) Key {
 }
 
 // Keys returns a slice of every key in the TOML data, including key groups.
-//
 // Each key is itself a slice, where the first element is the top of the
-// hierarchy and the last is the most specific. The list will have the same
-// order as the keys appeared in the TOML data.
+// hierarchy and the last is the most specific.
+//
+// The list will have the same order as the keys appeared in the TOML data.
 //
 // All keys returned are non-empty.
 func (md *MetaData) Keys() []Key {

vendor/github.com/BurntSushi/toml/deprecated.go

@@ -1,33 +0,0 @@
-package toml
-
-import (
-	"encoding"
-	"io"
-)
-
-// DEPRECATED!
-//
-// Use the identical encoding.TextMarshaler instead. It is defined here to
-// support Go 1.1 and older.
-type TextMarshaler encoding.TextMarshaler
-
-// DEPRECATED!
-//
-// Use the identical encoding.TextUnmarshaler instead. It is defined here to
-// support Go 1.1 and older.
-type TextUnmarshaler encoding.TextUnmarshaler
-
-// DEPRECATED!
-//
-// Use MetaData.PrimitiveDecode instead.
-func PrimitiveDecode(primValue Primitive, v interface{}) error {
-	md := MetaData{decoded: make(map[string]bool)}
-	return md.unify(primValue.undecoded, rvalue(v))
-}
-
-// DEPRECATED!
-//
-// Use NewDecoder(reader).Decode(&v) instead.
-func DecodeReader(r io.Reader, v interface{}) (MetaData, error) {
-	return NewDecoder(r).Decode(v)
-}

vendor/github.com/BurntSushi/toml/doc.go

@@ -1,13 +1,27 @@
 /*
-Package toml implements decoding and encoding of TOML files.
+Package toml provides facilities for decoding and encoding TOML configuration
+files via reflection. There is also support for delaying decoding with
+the Primitive type, and querying the set of keys in a TOML document with the
+MetaData type.
 
-This package supports TOML v1.0.0, as listed on https://toml.io
+The specification implemented: https://github.com/toml-lang/toml
 
-There is also support for delaying decoding with the Primitive type, and
-querying the set of keys in a TOML document with the MetaData type.
+The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify
+whether a file is a valid TOML document. It can also be used to print the
+type of each key in a TOML document.
 
-The github.com/BurntSushi/toml/cmd/tomlv package implements a TOML validator,
-and can be used to verify if TOML document is valid. It can also be used to
-print the type of each key.
+Testing
+
+There are two important types of tests used for this package. The first is
+contained inside '*_test.go' files and uses the standard Go unit testing
+framework. These tests are primarily devoted to holistically testing the
+decoder and encoder.
+
+The second type of testing is used to verify the implementation's adherence
+to the TOML specification. These tests have been factored into their own
+project: https://github.com/BurntSushi/toml-test
+
+The reason the tests are in a separate project is so that they can be used by
+any implementation of TOML. Namely, it is language agnostic.
 */
 package toml

vendor/github.com/BurntSushi/toml/encode.go

@@ -2,92 +2,48 @@ package toml
 
 import (
 	"bufio"
-	"encoding"
 	"errors"
 	"fmt"
 	"io"
-	"math"
 	"reflect"
 	"sort"
 	"strconv"
 	"strings"
 	"time"
-
-	"github.com/BurntSushi/toml/internal"
 )
 
 type tomlEncodeError struct{ error }
 
 var (
-	errArrayNilElement = errors.New("toml: cannot encode array with nil element")
-	errNonString       = errors.New("toml: cannot encode a map with non-string key type")
-	errAnonNonStruct   = errors.New("toml: cannot encode an anonymous field that is not a struct")
-	errNoKey           = errors.New("toml: top-level values must be Go maps or structs")
-	errAnything        = errors.New("") // used in testing
+	errArrayMixedElementTypes = errors.New(
+		"toml: cannot encode array with mixed element types")
+	errArrayNilElement = errors.New(
+		"toml: cannot encode array with nil element")
+	errNonString = errors.New(
+		"toml: cannot encode a map with non-string key type")
+	errAnonNonStruct = errors.New(
+		"toml: cannot encode an anonymous field that is not a struct")
+	errArrayNoTable = errors.New(
+		"toml: TOML array element cannot contain a table")
+	errNoKey = errors.New(
+		"toml: top-level values must be Go maps or structs")
+	errAnything = errors.New("") // used in testing
 )
 
 var quotedReplacer = strings.NewReplacer(
+	"\t", "\\t",
+	"\n", "\\n",
+	"\r", "\\r",
 	"\"", "\\\"",
 	"\\", "\\\\",
-	"\x00", `\u0000`,
-	"\x01", `\u0001`,
-	"\x02", `\u0002`,
-	"\x03", `\u0003`,
-	"\x04", `\u0004`,
-	"\x05", `\u0005`,
-	"\x06", `\u0006`,
-	"\x07", `\u0007`,
-	"\b", `\b`,
-	"\t", `\t`,
-	"\n", `\n`,
-	"\x0b", `\u000b`,
-	"\f", `\f`,
-	"\r", `\r`,
-	"\x0e", `\u000e`,
-	"\x0f", `\u000f`,
-	"\x10", `\u0010`,
-	"\x11", `\u0011`,
-	"\x12", `\u0012`,
-	"\x13", `\u0013`,
-	"\x14", `\u0014`,
-	"\x15", `\u0015`,
-	"\x16", `\u0016`,
-	"\x17", `\u0017`,
-	"\x18", `\u0018`,
-	"\x19", `\u0019`,
-	"\x1a", `\u001a`,
-	"\x1b", `\u001b`,
-	"\x1c", `\u001c`,
-	"\x1d", `\u001d`,
-	"\x1e", `\u001e`,
-	"\x1f", `\u001f`,
-	"\x7f", `\u007f`,
 )
 
-// Encoder encodes a Go to a TOML document.
+// Encoder controls the encoding of Go values to a TOML document to some
+// io.Writer.
 //
-// The mapping between Go values and TOML values should be precisely the same as
-// for the Decode* functions. Similarly, the TextMarshaler interface is
-// supported by encoding the resulting bytes as strings. If you want to write
-// arbitrary binary data then you will need to use something like base64 since
-// TOML does not have any binary types.
-//
-// When encoding TOML hashes (Go maps or structs), keys without any sub-hashes
-// are encoded first.
-//
-// Go maps will be sorted alphabetically by key for deterministic output.
-//
-// Encoding Go values without a corresponding TOML representation will return an
-// error. Examples of this includes maps with non-string keys, slices with nil
-// elements, embedded non-struct types, and nested slices containing maps or
-// structs. (e.g. [][]map[string]string is not allowed but []map[string]string
-// is okay, as is []map[string][]string).
-//
-// NOTE: Only exported keys are encoded due to the use of reflection. Unexported
-// keys are silently discarded.
+// The indentation level can be controlled with the Indent field.
 type Encoder struct {
-	// The string to use for a single indentation level. The default is two
-	// spaces.
+	// A single indentation level. By default it is two spaces.
 	Indent string
 
 	// hasWritten is whether we have written any output to w yet.
@@ -95,7 +51,8 @@ type Encoder struct {
 	w          *bufio.Writer
 }
 
-// NewEncoder create a new Encoder.
+// NewEncoder returns a TOML encoder that encodes Go values to the io.Writer
+// given. By default, a single indentation level is 2 spaces.
 func NewEncoder(w io.Writer) *Encoder {
 	return &Encoder{
 		w:      bufio.NewWriter(w),
@@ -103,10 +60,29 @@ func NewEncoder(w io.Writer) *Encoder {
 	}
 }
 
-// Encode writes a TOML representation of the Go value to the Encoder's writer.
+// Encode writes a TOML representation of the Go value to the underlying
+// io.Writer. If the value given cannot be encoded to a valid TOML document,
+// then an error is returned.
 //
-// An error is returned if the value given cannot be encoded to a valid TOML
-// document.
+// The mapping between Go values and TOML values should be precisely the same
+// as for the Decode* functions. Similarly, the TextMarshaler interface is
+// supported by encoding the resulting bytes as strings. (If you want to write
+// arbitrary binary data then you will need to use something like base64 since
+// TOML does not have any binary types.)
+//
+// When encoding TOML hashes (i.e., Go maps or structs), keys without any
+// sub-hashes are encoded first.
+//
+// If a Go map is encoded, then its keys are sorted alphabetically for
+// deterministic output. More control over this behavior may be provided if
+// there is demand for it.
+//
+// Encoding Go values without a corresponding TOML representation---like map
+// types with non-string keys---will cause an error to be returned. Similarly
+// for mixed arrays/slices, arrays/slices with nil elements, embedded
+// non-struct types and nested slices containing maps or structs.
+// (e.g., [][]map[string]string is not allowed but []map[string]string is OK
+// and so is []map[string][]string.)
 func (enc *Encoder) Encode(v interface{}) error {
 	rv := eindirect(reflect.ValueOf(v))
 	if err := enc.safeEncode(Key([]string{}), rv); err != nil {
@@ -134,13 +110,9 @@ func (enc *Encoder) encode(key Key, rv reflect.Value) {
 	// Special case. If we can marshal the type to text, then we used that.
 	// Basically, this prevents the encoder for handling these types as
 	// generic structs (or whatever the underlying type of a TextMarshaler is).
-	switch t := rv.Interface().(type) {
-	case time.Time, encoding.TextMarshaler:
-		enc.writeKeyValue(key, rv, false)
-		return
-	// TODO: #76 would make this superfluous after implemented.
-	case Primitive:
-		enc.encode(key, reflect.ValueOf(t.undecoded))
+	switch rv.Interface().(type) {
+	case time.Time, TextMarshaler:
+		enc.keyEqElement(key, rv)
 		return
 	}
 
@@ -151,12 +123,12 @@ func (enc *Encoder) encode(key Key, rv reflect.Value) {
 		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32,
 		reflect.Uint64,
 		reflect.Float32, reflect.Float64, reflect.String, reflect.Bool:
-		enc.writeKeyValue(key, rv, false)
+		enc.keyEqElement(key, rv)
 	case reflect.Array, reflect.Slice:
 		if typeEqual(tomlArrayHash, tomlTypeOfGo(rv)) {
 			enc.eArrayOfTables(key, rv)
 		} else {
-			enc.writeKeyValue(key, rv, false)
+			enc.keyEqElement(key, rv)
 		}
 	case reflect.Interface:
 		if rv.IsNil() {
@@ -176,32 +148,22 @@ func (enc *Encoder) encode(key Key, rv reflect.Value) {
 	case reflect.Struct:
 		enc.eTable(key, rv)
 	default:
-		encPanic(fmt.Errorf("unsupported type for key '%s': %s", key, k))
+		panic(e("unsupported type for key '%s': %s", key, k))
 	}
 }
 
-// eElement encodes any value that can be an array element.
+// eElement encodes any value that can be an array element (primitives and
+// arrays).
 func (enc *Encoder) eElement(rv reflect.Value) {
 	switch v := rv.Interface().(type) {
-	case time.Time: // Using TextMarshaler adds extra quotes, which we don't want.
-		format := time.RFC3339Nano
-		switch v.Location() {
-		case internal.LocalDatetime:
-			format = "2006-01-02T15:04:05.999999999"
-		case internal.LocalDate:
-			format = "2006-01-02"
-		case internal.LocalTime:
-			format = "15:04:05.999999999"
-		}
-		switch v.Location() {
-		default:
-			enc.wf(v.Format(format))
-		case internal.LocalDatetime, internal.LocalDate, internal.LocalTime:
-			enc.wf(v.In(time.UTC).Format(format))
-		}
+	case time.Time:
+		// Special case time.Time as a primitive. Has to come before
+		// TextMarshaler below because time.Time implements
+		// encoding.TextMarshaler, but we need to always use UTC.
+		enc.wf(v.UTC().Format("2006-01-02T15:04:05Z"))
 		return
-	case encoding.TextMarshaler:
-		// Use text marshaler if it's available for this value.
+	case TextMarshaler:
+		// Special case. Use text marshaler if it's available for this value.
 		if s, err := v.MarshalText(); err != nil {
 			encPanic(err)
 		} else {
@@ -209,49 +171,32 @@ func (enc *Encoder) eElement(rv reflect.Value) {
 		}
 		return
 	}
-
 	switch rv.Kind() {
-	case reflect.String:
-		enc.writeQuoted(rv.String())
 	case reflect.Bool:
 		enc.wf(strconv.FormatBool(rv.Bool()))
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
+		reflect.Int64:
 		enc.wf(strconv.FormatInt(rv.Int(), 10))
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+	case reflect.Uint, reflect.Uint8, reflect.Uint16,
+		reflect.Uint32, reflect.Uint64:
 		enc.wf(strconv.FormatUint(rv.Uint(), 10))
 	case reflect.Float32:
-		f := rv.Float()
-		if math.IsNaN(f) {
-			enc.wf("nan")
-		} else if math.IsInf(f, 0) {
-			enc.wf("%cinf", map[bool]byte{true: '-', false: '+'}[math.Signbit(f)])
-		} else {
-			enc.wf(floatAddDecimal(strconv.FormatFloat(f, 'f', -1, 32)))
-		}
+		enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 32)))
 	case reflect.Float64:
-		f := rv.Float()
-		if math.IsNaN(f) {
-			enc.wf("nan")
-		} else if math.IsInf(f, 0) {
-			enc.wf("%cinf", map[bool]byte{true: '-', false: '+'}[math.Signbit(f)])
-		} else {
-			enc.wf(floatAddDecimal(strconv.FormatFloat(f, 'f', -1, 64)))
-		}
+		enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 64)))
 	case reflect.Array, reflect.Slice:
 		enc.eArrayOrSliceElement(rv)
-	case reflect.Struct:
-		enc.eStruct(nil, rv, true)
-	case reflect.Map:
-		enc.eMap(nil, rv, true)
 	case reflect.Interface:
 		enc.eElement(rv.Elem())
+	case reflect.String:
+		enc.writeQuoted(rv.String())
 	default:
-		encPanic(fmt.Errorf("unexpected primitive type: %T", rv.Interface()))
+		panic(e("unexpected primitive type: %s", rv.Kind()))
 	}
 }
 
-// By the TOML spec, all floats must have a decimal with at least one number on
-// either side.
+// By the TOML spec, all floats must have a decimal with at least one
+// number on either side.
 func floatAddDecimal(fstr string) string {
 	if !strings.Contains(fstr, ".") {
 		return fstr + ".0"
@@ -285,14 +230,16 @@ func (enc *Encoder) eArrayOfTables(key Key, rv reflect.Value) {
 		if isNil(trv) {
 			continue
 		}
+		panicIfInvalidKey(key)
 		enc.newline()
 		enc.wf("%s[[%s]]", enc.indentStr(key), key.maybeQuotedAll())
 		enc.newline()
-		enc.eMapOrStruct(key, trv, false)
+		enc.eMapOrStruct(key, trv)
 	}
 }
 
 func (enc *Encoder) eTable(key Key, rv reflect.Value) {
+	panicIfInvalidKey(key)
 	if len(key) == 1 {
 		// Output an extra newline between top-level tables.
 		// (The newline isn't written if nothing else has been written though.)
@@ -302,22 +249,21 @@ func (enc *Encoder) eTable(key Key, rv reflect.Value) {
 		enc.wf("%s[%s]", enc.indentStr(key), key.maybeQuotedAll())
 		enc.newline()
 	}
-	enc.eMapOrStruct(key, rv, false)
+	enc.eMapOrStruct(key, rv)
 }
 
-func (enc *Encoder) eMapOrStruct(key Key, rv reflect.Value, inline bool) {
+func (enc *Encoder) eMapOrStruct(key Key, rv reflect.Value) {
 	switch rv := eindirect(rv); rv.Kind() {
 	case reflect.Map:
-		enc.eMap(key, rv, inline)
+		enc.eMap(key, rv)
 	case reflect.Struct:
-		enc.eStruct(key, rv, inline)
+		enc.eStruct(key, rv)
 	default:
-		// Should never happen?
 		panic("eTable: unhandled reflect.Value Kind: " + rv.Kind().String())
 	}
 }
 
-func (enc *Encoder) eMap(key Key, rv reflect.Value, inline bool) {
+func (enc *Encoder) eMap(key Key, rv reflect.Value) {
 	rt := rv.Type()
 	if rt.Key().Kind() != reflect.String {
 		encPanic(errNonString)
@@ -335,76 +281,57 @@ func (enc *Encoder) eMap(key Key, rv reflect.Value, inline bool) {
 		}
 	}
 
-	var writeMapKeys = func(mapKeys []string, trailC bool) {
+	var writeMapKeys = func(mapKeys []string) {
 		sort.Strings(mapKeys)
-		for i, mapKey := range mapKeys {
-			val := rv.MapIndex(reflect.ValueOf(mapKey))
-			if isNil(val) {
+		for _, mapKey := range mapKeys {
+			mrv := rv.MapIndex(reflect.ValueOf(mapKey))
+			if isNil(mrv) {
+				// Don't write anything for nil fields.
 				continue
 			}
-
-			if inline {
-				enc.writeKeyValue(Key{mapKey}, val, true)
-				if trailC || i != len(mapKeys)-1 {
-					enc.wf(", ")
-				}
-			} else {
-				enc.encode(key.add(mapKey), val)
-			}
+			enc.encode(key.add(mapKey), mrv)
 		}
 	}
-
-	if inline {
-		enc.wf("{")
-	}
-	writeMapKeys(mapKeysDirect, len(mapKeysSub) > 0)
-	writeMapKeys(mapKeysSub, false)
-	if inline {
-		enc.wf("}")
-	}
+	writeMapKeys(mapKeysDirect)
+	writeMapKeys(mapKeysSub)
 }
 
-func (enc *Encoder) eStruct(key Key, rv reflect.Value, inline bool) {
+func (enc *Encoder) eStruct(key Key, rv reflect.Value) {
 	// Write keys for fields directly under this key first, because if we write
-	// a field that creates a new table then all keys under it will be in that
+	// a field that creates a new table, then all keys under it will be in that
 	// table (not the one we're writing here).
-	//
-	// Fields is a [][]int: for fieldsDirect this always has one entry (the
-	// struct index). For fieldsSub it contains two entries: the parent field
-	// index from tv, and the field indexes for the fields of the sub.
-	var (
-		rt                      = rv.Type()
-		fieldsDirect, fieldsSub [][]int
-		addFields               func(rt reflect.Type, rv reflect.Value, start []int)
-	)
+	rt := rv.Type()
+	var fieldsDirect, fieldsSub [][]int
+	var addFields func(rt reflect.Type, rv reflect.Value, start []int)
 	addFields = func(rt reflect.Type, rv reflect.Value, start []int) {
 		for i := 0; i < rt.NumField(); i++ {
 			f := rt.Field(i)
-			if f.PkgPath != "" && !f.Anonymous { /// Skip unexported fields.
+			// skip unexported fields
+			if f.PkgPath != "" && !f.Anonymous {
 				continue
 			}
-
 			frv := rv.Field(i)
-
-			// Treat anonymous struct fields with tag names as though they are
-			// not anonymous, like encoding/json does.
-			//
-			// Non-struct anonymous fields use the normal encoding logic.
 			if f.Anonymous {
 				t := f.Type
 				switch t.Kind() {
 				case reflect.Struct:
+					// Treat anonymous struct fields with
+					// tag names as though they are not
+					// anonymous, like encoding/json does.
 					if getOptions(f.Tag).name == "" {
-						addFields(t, frv, append(start, f.Index...))
+						addFields(t, frv, f.Index)
 						continue
 					}
 				case reflect.Ptr:
-					if t.Elem().Kind() == reflect.Struct && getOptions(f.Tag).name == "" {
+					if t.Elem().Kind() == reflect.Struct &&
+						getOptions(f.Tag).name == "" {
 						if !frv.IsNil() {
-							addFields(t.Elem(), frv.Elem(), append(start, f.Index...))
+							addFields(t.Elem(), frv.Elem(), f.Index)
 						}
 						continue
 					}
+					// Fall through to the normal field encoding logic below
+					// for non-struct anonymous fields.
 				}
 			}
 
@@ -417,49 +344,35 @@ func (enc *Encoder) eStruct(key Key, rv reflect.Value, inline bool) {
 	}
 	addFields(rt, rv, nil)
 
-	writeFields := func(fields [][]int) {
+	var writeFields = func(fields [][]int) {
 		for _, fieldIndex := range fields {
-			fieldType := rt.FieldByIndex(fieldIndex)
-			fieldVal := rv.FieldByIndex(fieldIndex)
-
-			if isNil(fieldVal) { /// Don't write anything for nil fields.
+			sft := rt.FieldByIndex(fieldIndex)
+			sf := rv.FieldByIndex(fieldIndex)
+			if isNil(sf) {
+				// Don't write anything for nil fields.
 				continue
 			}
 
-			opts := getOptions(fieldType.Tag)
+			opts := getOptions(sft.Tag)
 			if opts.skip {
 				continue
 			}
-			keyName := fieldType.Name
+			keyName := sft.Name
 			if opts.name != "" {
 				keyName = opts.name
 			}
-			if opts.omitempty && isEmpty(fieldVal) {
+			if opts.omitempty && isEmpty(sf) {
 				continue
 			}
-			if opts.omitzero && isZero(fieldVal) {
+			if opts.omitzero && isZero(sf) {
 				continue
 			}
 
-			if inline {
-				enc.writeKeyValue(Key{keyName}, fieldVal, true)
-				if fieldIndex[0] != len(fields)-1 {
-					enc.wf(", ")
-				}
-			} else {
-				enc.encode(key.add(keyName), fieldVal)
-			}
+			enc.encode(key.add(keyName), sf)
 		}
 	}
-
-	if inline {
-		enc.wf("{")
-	}
 	writeFields(fieldsDirect)
 	writeFields(fieldsSub)
-	if inline {
-		enc.wf("}")
-	}
 }
 
 // tomlTypeName returns the TOML type name of the Go value's type. It is
@@ -498,26 +411,13 @@ func tomlTypeOfGo(rv reflect.Value) tomlType {
 		switch rv.Interface().(type) {
 		case time.Time:
 			return tomlDatetime
-		case encoding.TextMarshaler:
+		case TextMarshaler:
 			return tomlString
 		default:
-			// Someone used a pointer receiver: we can make it work for pointer
-			// values.
-			if rv.CanAddr() {
-				_, ok := rv.Addr().Interface().(encoding.TextMarshaler)
-				if ok {
-					return tomlString
-				}
-			}
 			return tomlHash
 		}
 	default:
-		_, ok := rv.Interface().(encoding.TextMarshaler)
-		if ok {
-			return tomlString
-		}
-		encPanic(errors.New("unsupported type: " + rv.Kind().String()))
-		panic("") // Need *some* return value
+		panic("unexpected reflect.Kind: " + rv.Kind().String())
 	}
 }
 
@@ -530,19 +430,30 @@ func tomlArrayType(rv reflect.Value) tomlType {
 	if isNil(rv) || !rv.IsValid() || rv.Len() == 0 {
 		return nil
 	}
-
-	/// Don't allow nil.
-	rvlen := rv.Len()
-	for i := 1; i < rvlen; i++ {
-		if tomlTypeOfGo(rv.Index(i)) == nil {
-			encPanic(errArrayNilElement)
-		}
-	}
-
 	firstType := tomlTypeOfGo(rv.Index(0))
 	if firstType == nil {
 		encPanic(errArrayNilElement)
 	}
+
+	rvlen := rv.Len()
+	for i := 1; i < rvlen; i++ {
+		elem := rv.Index(i)
+		switch elemType := tomlTypeOfGo(elem); {
+		case elemType == nil:
+			encPanic(errArrayNilElement)
+		case !typeEqual(firstType, elemType):
+			encPanic(errArrayMixedElementTypes)
+		}
+	}
+	// If we have a nested array, then we must make sure that the nested
+	// array contains ONLY primitives.
+	// This checks arbitrarily nested arrays.
+	if typeEqual(firstType, tomlArray) || typeEqual(firstType, tomlArrayHash) {
+		nest := tomlArrayType(eindirect(rv.Index(0)))
+		if typeEqual(nest, tomlHash) || typeEqual(nest, tomlArrayHash) {
+			encPanic(errArrayNoTable)
+		}
+	}
 	return firstType
 }
 
@@ -600,20 +511,14 @@ func (enc *Encoder) newline() {
 	}
 }
 
-// Write a key/value pair:
-//
-//   key = <any value>
-//
-// If inline is true it won't add a newline at the end.
-func (enc *Encoder) writeKeyValue(key Key, val reflect.Value, inline bool) {
+func (enc *Encoder) keyEqElement(key Key, val reflect.Value) {
 	if len(key) == 0 {
 		encPanic(errNoKey)
 	}
+	panicIfInvalidKey(key)
 	enc.wf("%s%s = ", enc.indentStr(key), key.maybeQuoted(len(key)-1))
 	enc.eElement(val)
-	if !inline {
-		enc.newline()
-	}
+	enc.newline()
 }
 
 func (enc *Encoder) wf(format string, v ...interface{}) {
@@ -648,3 +553,16 @@ func isNil(rv reflect.Value) bool {
 		return false
 	}
 }
+
+func panicIfInvalidKey(key Key) {
+	for _, k := range key {
+		if len(k) == 0 {
+			encPanic(e("Key '%s' is not a valid table name. Key names "+
+				"cannot be empty.", key.maybeQuotedAll()))
+		}
+	}
+}
+
+func isValidKeyName(s string) bool {
+	return len(s) != 0
+}

vendor/github.com/BurntSushi/toml/encoding_types.go

@@ -0,0 +1,19 @@
+// +build go1.2
+
+package toml
+
+// In order to support Go 1.1, we define our own TextMarshaler and
+// TextUnmarshaler types. For Go 1.2+, we just alias them with the
+// standard library interfaces.
+
+import (
+	"encoding"
+)
+
+// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here
+// so that Go 1.1 can be supported.
+type TextMarshaler encoding.TextMarshaler
+
+// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined
+// here so that Go 1.1 can be supported.
+type TextUnmarshaler encoding.TextUnmarshaler