Merge pull request #1342 from containers/dev/tsweeney/v1.2.4

Bump to Skopeo v1.2.4, c/common to v0.38.12

.gitignore

@@ -1,2 +1,7 @@
-skopeo
-skopeo.1
+*.1
+/layers-*
+/skopeo
+result
+
+# ignore JetBrains IDEs (GoLand) config folder
+.idea

.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

@@ -0,0 +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/master/CODE-OF-CONDUCT.md).

CONTRIBUTING.md

@@ -0,0 +1,173 @@
+# Contributing to Skopeo
+
+We'd love to have you join the community! Below summarizes the processes
+that we follow.
+
+## Topics
+
+* [Reporting Issues](#reporting-issues)
+* [Submitting Pull Requests](#submitting-pull-requests)
+* [Communications](#communications)
+<!--
+* [Becoming a Maintainer](#becoming-a-maintainer)
+-->
+
+## Reporting Issues
+
+Before reporting an issue, check our backlog of 
+[open issues](https://github.com/containers/skopeo/issues)
+to see if someone else has already reported it. If so, feel free to add
+your scenario, or additional information, to the discussion. Or simply 
+"subscribe" to it to be notified when it is updated.
+
+If you find a new issue with the project we'd love to hear about it! The most
+important aspect of a bug report is that it includes enough information for
+us to reproduce it. So, please include as much detail as possible and try
+to remove the extra stuff that doesn't really relate to the issue itself.
+The easier it is for us to reproduce it, the faster it'll be fixed!
+
+Please don't include any private/sensitive information in your issue!
+
+## Submitting Pull Requests
+
+No Pull Request (PR) is too small! Typos, additional comments in the code,
+new testcases, bug fixes, new features, more documentation, ... it's all 
+welcome!
+
+While bug fixes can first be identified via an "issue", that is not required.
+It's ok to just open up a PR with the fix, but make sure you include the same
+information you would have included in an issue - like how to reproduce it.
+
+PRs for new features should include some background on what use cases the
+new code is trying to address. When possible and when it makes sense, try to break-up
+larger PRs into smaller ones - it's easier to review smaller
+code changes. But only if those smaller ones make sense as stand-alone PRs.
+
+Regardless of the type of PR, all PRs should include:
+* well documented code changes
+* additional testcases. Ideally, they should fail w/o your code change applied
+* documentation changes
+
+Squash your commits into logical pieces of work that might want to be reviewed
+separate from the rest of the PRs. Ideally, each commit should implement a single
+idea, and the PR branch should pass the tests at every commit.  GitHub makes it easy
+to review the cumulative effect of many commits; so, when in doubt, use smaller commits.
+
+PRs that fix issues should include a reference like `Closes #XXXX` in the
+commit message so that github will automatically close the referenced issue
+when the PR is merged.
+
+<!--
+All PRs require at least two LGTMs (Looks Good To Me) from maintainers.
+-->
+
+### Sign your PRs
+
+The sign-off is a line at the end of the explanation for the patch. Your
+signature certifies that you wrote the patch or otherwise have the right to pass
+it on as an open-source patch. The rules are simple: if you can certify
+the below (from [developercertificate.org](http://developercertificate.org/)):
+
+```
+Developer Certificate of Origin
+Version 1.1
+
+Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
+660 York Street, Suite 102,
+San Francisco, CA 94110 USA
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.
+```
+
+Then you just add a line to every git commit message:
+
+    Signed-off-by: Joe Smith <joe.smith@email.com>
+
+Use your real name (sorry, no pseudonyms or anonymous contributions.)
+
+If you set your `user.name` and `user.email` git configs, you can sign your
+commit automatically with `git commit -s`.
+
+### Dependencies management
+
+Make sure [`vndr`](https://github.com/LK4D4/vndr) is installed.
+
+In order to add a new dependency to this project:
+
+- 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:
+
+- 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
+- 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, 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
+
+## Communications
+
+For general questions, or discussions, please use the 
+IRC group on `irc.freenode.net` called `container-projects`
+that has been setup.
+
+For discussions around issues/bugs and features, you can use the github
+[issues](https://github.com/containers/skopeo/issues)
+and
+[PRs](https://github.com/containers/skopeo/pulls)
+tracking system.
+
+<!--
+## Becoming a Maintainer
+
+To become a maintainer you must first be nominated by an existing maintainer.
+If a majority (>50%) of maintainers agree then the proposal is adopted and
+you will be added to the list.
+
+Removing a maintainer requires at least 75% of the remaining maintainers
+approval, or if the person requests to be removed then it is automatic.
+Normally, a maintainer will only be removed if they are considered to be
+inactive for a long period of time or are viewed as disruptive to the community.
+
+The current list of maintainers can be found in the 
+[MAINTAINERS](MAINTAINERS) file.
+-->

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

Godeps/Godeps.json

@@ -1,240 +0,0 @@
-{
-	"ImportPath": "github.com/runcom/skopeo",
-	"GoVersion": "go1.5.3",
-	"Packages": [
-		"."
-	],
-	"Deps": [
-		{
-			"ImportPath": "github.com/Sirupsen/logrus",
-			"Comment": "v0.8.7-55-gf7f79f7",
-			"Rev": "f7f79f729e0fbe2fcc061db48a9ba0263f588252"
-		},
-		{
-			"ImportPath": "github.com/codegangsta/cli",
-			"Comment": "1.2.0-187-gc31a797",
-			"Rev": "c31a7975863e7810c92e2e288a9ab074f9a88f29"
-		},
-		{
-			"ImportPath": "github.com/docker/distribution",
-			"Comment": "v2.2.0-199-g0865082",
-			"Rev": "08650825fef9f21ea819972fb2ed875c0832a255"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/api",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/cliconfig",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/daemon/graphdriver",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/distribution",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/dockerversion",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/image",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/layer",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/opts",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/archive",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/chrootarchive",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/fileutils",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/homedir",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/httputils",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/idtools",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/ioutils",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/jsonlog",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/jsonmessage",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/mflag",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/parsers/kernel",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/pools",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/progress",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/promise",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/random",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/reexec",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/stringid",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/system",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/tarsum",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/term",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/useragent",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/pkg/version",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/reference",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/docker/registry",
-			"Comment": "v1.4.1-9391-g5537a92",
-			"Rev": "5537a92e450ea56e2002f83ff50bb70fdb2cc25e"
-		},
-		{
-			"ImportPath": "github.com/docker/engine-api/types",
-			"Comment": "v0.2.2-13-ge98ada9",
-			"Rev": "e98ada9b4fa351554aa7ee7cf857a2d6d26b1453"
-		},
-		{
-			"ImportPath": "github.com/docker/go-connections/nat",
-			"Comment": "v0.1.2-2-g082e382",
-			"Rev": "082e382836465660fe3fd21de06624a205f986eb"
-		},
-		{
-			"ImportPath": "github.com/docker/go-connections/tlsconfig",
-			"Comment": "v0.1.2-2-g082e382",
-			"Rev": "082e382836465660fe3fd21de06624a205f986eb"
-		},
-		{
-			"ImportPath": "github.com/docker/go-units",
-			"Comment": "v0.1.0-21-g0bbddae",
-			"Rev": "0bbddae09c5a5419a8c6dcdd7ff90da3d450393b"
-		},
-		{
-			"ImportPath": "github.com/docker/libtrust",
-			"Rev": "9cbd2a1374f46905c68a4eb3694a130610adc62a"
-		},
-		{
-			"ImportPath": "github.com/gorilla/context",
-			"Rev": "1c83b3eabd45b6d76072b66b746c20815fb2872d"
-		},
-		{
-			"ImportPath": "github.com/gorilla/mux",
-			"Rev": "26a6070f849969ba72b72256e9f14cf519751690"
-		},
-		{
-			"ImportPath": "github.com/opencontainers/runc/libcontainer/user",
-			"Comment": "v0.0.4-226-gbc46574",
-			"Rev": "bc465742ac61aad50dec8e9769a75f01d8d8e502"
-		},
-		{
-			"ImportPath": "github.com/vbatts/tar-split/archive/tar",
-			"Comment": "v0.9.11-1-gd50e5c9",
-			"Rev": "d50e5c9283da469398d84078519de569f617be6f"
-		},
-		{
-			"ImportPath": "github.com/vbatts/tar-split/tar/asm",
-			"Comment": "v0.9.11-1-gd50e5c9",
-			"Rev": "d50e5c9283da469398d84078519de569f617be6f"
-		},
-		{
-			"ImportPath": "github.com/vbatts/tar-split/tar/storage",
-			"Comment": "v0.9.11-1-gd50e5c9",
-			"Rev": "d50e5c9283da469398d84078519de569f617be6f"
-		},
-		{
-			"ImportPath": "golang.org/x/net/context",
-			"Rev": "b2ed34f6fc8d65cc6a090fb87692ea6b1162fddd"
-		}
-	]
-}

Godeps/Readme

@@ -1,5 +0,0 @@
-This directory tree is generated automatically by godep.
-
-Please do not edit.
-
-See https://github.com/tools/godep for more information.

Godeps/_workspace/.gitignore

@@ -1,2 +0,0 @@
-/pkg
-/bin

Godeps/_workspace/src/github.com/Sirupsen/logrus/.gitignore

@@ -1 +0,0 @@
-logrus

Godeps/_workspace/src/github.com/Sirupsen/logrus/.travis.yml

@@ -1,7 +0,0 @@
-language: go
-go:
-  - 1.3
-  - 1.4
-  - tip
-install:
-  - go get -t ./...

Godeps/_workspace/src/github.com/Sirupsen/logrus/CHANGELOG.md

@@ -1,55 +0,0 @@
-# 0.9.0 (Unreleased)
-
-* logrus/text_formatter: don't emit empty msg
-* logrus/hooks/airbrake: move out of main repository
-* logrus/hooks/sentry: move out of main repository
-* logrus/hooks/papertrail: move out of main repository
-* logrus/hooks/bugsnag: move out of main repository
-
-# 0.8.7
-
-* logrus/core: fix possible race (#216)
-* logrus/doc: small typo fixes and doc improvements
-
-
-# 0.8.6
-
-* hooks/raven: allow passing an initialized client
-
-# 0.8.5
-
-* logrus/core: revert #208
-
-# 0.8.4
-
-* formatter/text: fix data race (#218)
-
-# 0.8.3
-
-* logrus/core: fix entry log level (#208)
-* logrus/core: improve performance of text formatter by 40%
-* logrus/core: expose `LevelHooks` type
-* logrus/core: add support for DragonflyBSD and NetBSD
-* formatter/text: print structs more verbosely
-
-# 0.8.2
-
-* logrus: fix more Fatal family functions
-
-# 0.8.1
-
-* logrus: fix not exiting on `Fatalf` and `Fatalln`
-
-# 0.8.0
-
-* logrus: defaults to stderr instead of stdout
-* hooks/sentry: add special field for `*http.Request`
-* formatter/text: ignore Windows for colors
-
-# 0.7.3
-
-* formatter/\*: allow configuration of timestamp layout
-
-# 0.7.2
-
-* formatter/text: Add configuration option for time format (#158)

Godeps/_workspace/src/github.com/Sirupsen/logrus/README.md

@@ -1,365 +0,0 @@
-# Logrus <img src="http://i.imgur.com/hTeVwmJ.png" width="40" height="40" alt=":walrus:" class="emoji" title=":walrus:"/>&nbsp;[![Build Status](https://travis-ci.org/Sirupsen/logrus.svg?branch=master)](https://travis-ci.org/Sirupsen/logrus)&nbsp;[![godoc reference](https://godoc.org/github.com/Sirupsen/logrus?status.png)][godoc]
-
-Logrus is a structured logger for Go (golang), completely API compatible with
-the standard library logger. [Godoc][godoc]. **Please note the Logrus API is not
-yet stable (pre 1.0). Logrus itself is completely stable and has been used in
-many large deployments. The core API is unlikely to change much but please
-version control your Logrus to make sure you aren't fetching latest `master` on
-every build.**
-
-Nicely color-coded in development (when a TTY is attached, otherwise just
-plain text):
-
-![Colored](http://i.imgur.com/PY7qMwd.png)
-
-With `log.Formatter = new(logrus.JSONFormatter)`, for easy parsing by logstash
-or Splunk:
-
-```json
-{"animal":"walrus","level":"info","msg":"A group of walrus emerges from the
-ocean","size":10,"time":"2014-03-10 19:57:38.562264131 -0400 EDT"}
-
-{"level":"warning","msg":"The group's number increased tremendously!",
-"number":122,"omg":true,"time":"2014-03-10 19:57:38.562471297 -0400 EDT"}
-
-{"animal":"walrus","level":"info","msg":"A giant walrus appears!",
-"size":10,"time":"2014-03-10 19:57:38.562500591 -0400 EDT"}
-
-{"animal":"walrus","level":"info","msg":"Tremendously sized cow enters the ocean.",
-"size":9,"time":"2014-03-10 19:57:38.562527896 -0400 EDT"}
-
-{"level":"fatal","msg":"The ice breaks!","number":100,"omg":true,
-"time":"2014-03-10 19:57:38.562543128 -0400 EDT"}
-```
-
-With the default `log.Formatter = new(&log.TextFormatter{})` when a TTY is not
-attached, the output is compatible with the
-[logfmt](http://godoc.org/github.com/kr/logfmt) format:
-
-```text
-time="2015-03-26T01:27:38-04:00" level=debug msg="Started observing beach" animal=walrus number=8
-time="2015-03-26T01:27:38-04:00" level=info msg="A group of walrus emerges from the ocean" animal=walrus size=10
-time="2015-03-26T01:27:38-04:00" level=warning msg="The group's number increased tremendously!" number=122 omg=true
-time="2015-03-26T01:27:38-04:00" level=debug msg="Temperature changes" temperature=-4
-time="2015-03-26T01:27:38-04:00" level=panic msg="It's over 9000!" animal=orca size=9009
-time="2015-03-26T01:27:38-04:00" level=fatal msg="The ice breaks!" err=&{0x2082280c0 map[animal:orca size:9009] 2015-03-26 01:27:38.441574009 -0400 EDT panic It's over 9000!} number=100 omg=true
-exit status 1
-```
-
-#### Example
-
-The simplest way to use Logrus is simply the package-level exported logger:
-
-```go
-package main
-
-import (
-  log "github.com/Sirupsen/logrus"
-)
-
-func main() {
-  log.WithFields(log.Fields{
-    "animal": "walrus",
-  }).Info("A walrus appears")
-}
-```
-
-Note that it's completely api-compatible with the stdlib logger, so you can
-replace your `log` imports everywhere with `log "github.com/Sirupsen/logrus"`
-and you'll now have the flexibility of Logrus. You can customize it all you
-want:
-
-```go
-package main
-
-import (
-  "os"
-  log "github.com/Sirupsen/logrus"
-)
-
-func init() {
-  // Log as JSON instead of the default ASCII formatter.
-  log.SetFormatter(&log.JSONFormatter{})
-
-  // Output to stderr instead of stdout, could also be a file.
-  log.SetOutput(os.Stderr)
-
-  // Only log the warning severity or above.
-  log.SetLevel(log.WarnLevel)
-}
-
-func main() {
-  log.WithFields(log.Fields{
-    "animal": "walrus",
-    "size":   10,
-  }).Info("A group of walrus emerges from the ocean")
-
-  log.WithFields(log.Fields{
-    "omg":    true,
-    "number": 122,
-  }).Warn("The group's number increased tremendously!")
-
-  log.WithFields(log.Fields{
-    "omg":    true,
-    "number": 100,
-  }).Fatal("The ice breaks!")
-
-  // A common pattern is to re-use fields between logging statements by re-using
-  // the logrus.Entry returned from WithFields()
-  contextLogger := log.WithFields(log.Fields{
-    "common": "this is a common field",
-    "other": "I also should be logged always",
-  })
-
-  contextLogger.Info("I'll be logged with common and other field")
-  contextLogger.Info("Me too")
-}
-```
-
-For more advanced usage such as logging to multiple locations from the same
-application, you can also create an instance of the `logrus` Logger:
-
-```go
-package main
-
-import (
-  "github.com/Sirupsen/logrus"
-)
-
-// Create a new instance of the logger. You can have any number of instances.
-var log = logrus.New()
-
-func main() {
-  // The API for setting attributes is a little different than the package level
-  // exported logger. See Godoc.
-  log.Out = os.Stderr
-
-  log.WithFields(logrus.Fields{
-    "animal": "walrus",
-    "size":   10,
-  }).Info("A group of walrus emerges from the ocean")
-}
-```
-
-#### Fields
-
-Logrus encourages careful, structured logging though logging fields instead of
-long, unparseable error messages. For example, instead of: `log.Fatalf("Failed
-to send event %s to topic %s with key %d")`, you should log the much more
-discoverable:
-
-```go
-log.WithFields(log.Fields{
-  "event": event,
-  "topic": topic,
-  "key": key,
-}).Fatal("Failed to send event")
-```
-
-We've found this API forces you to think about logging in a way that produces
-much more useful logging messages. We've been in countless situations where just
-a single added field to a log statement that was already there would've saved us
-hours. The `WithFields` call is optional.
-
-In general, with Logrus using any of the `printf`-family functions should be
-seen as a hint you should add a field, however, you can still use the
-`printf`-family functions with Logrus.
-
-#### Hooks
-
-You can add hooks for logging levels. For example to send errors to an exception
-tracking service on `Error`, `Fatal` and `Panic`, info to StatsD or log to
-multiple places simultaneously, e.g. syslog.
-
-Logrus comes with [built-in hooks](hooks/). Add those, or your custom hook, in
-`init`:
-
-```go
-import (
-  log "github.com/Sirupsen/logrus"
-  "gopkg.in/gemnasium/logrus-airbrake-hook.v2" // the package is named "aibrake"
-  logrus_syslog "github.com/Sirupsen/logrus/hooks/syslog"
-  "log/syslog"
-)
-
-func init() {
-
-  // Use the Airbrake hook to report errors that have Error severity or above to
-  // an exception tracker. You can create custom hooks, see the Hooks section.
-  log.AddHook(airbrake.NewHook(123, "xyz", "production"))
-
-  hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
-  if err != nil {
-    log.Error("Unable to connect to local syslog daemon")
-  } else {
-    log.AddHook(hook)
-  }
-}
-```
-Note: Syslog hook also support connecting to local syslog (Ex. "/dev/log" or "/var/run/syslog" or "/var/run/log"). For the detail, please check the [syslog hook README](hooks/syslog/README.md).
-
-| Hook  | Description |
-| ----- | ----------- |
-| [Airbrake](https://github.com/gemnasium/logrus-airbrake-hook) | Send errors to the Airbrake API V3. Uses the official [`gobrake`](https://github.com/airbrake/gobrake) behind the scenes. |
-| [Airbrake "legacy"](https://github.com/gemnasium/logrus-airbrake-legacy-hook) | Send errors to an exception tracking service compatible with the Airbrake API V2. Uses [`airbrake-go`](https://github.com/tobi/airbrake-go) behind the scenes. |
-| [Papertrail](https://github.com/polds/logrus-papertrail-hook) | Send errors to the [Papertrail](https://papertrailapp.com) hosted logging service via UDP. |
-| [Syslog](https://github.com/Sirupsen/logrus/blob/master/hooks/syslog/syslog.go) | Send errors to remote syslog server. Uses standard library `log/syslog` behind the scenes. |
-| [Bugsnag](https://github.com/Shopify/logrus-bugsnag/blob/master/bugsnag.go) | Send errors to the Bugsnag exception tracking service. |
-| [Sentry](https://github.com/evalphobia/logrus_sentry) | Send errors to the Sentry error logging and aggregation service. |
-| [Hiprus](https://github.com/nubo/hiprus) | Send errors to a channel in hipchat. |
-| [Logrusly](https://github.com/sebest/logrusly) | Send logs to [Loggly](https://www.loggly.com/) |
-| [Slackrus](https://github.com/johntdyer/slackrus) | Hook for Slack chat. |
-| [Journalhook](https://github.com/wercker/journalhook) | Hook for logging to `systemd-journald` |
-| [Graylog](https://github.com/gemnasium/logrus-graylog-hook) | Hook for logging to [Graylog](http://graylog2.org/) |
-| [Raygun](https://github.com/squirkle/logrus-raygun-hook) | Hook for logging to [Raygun.io](http://raygun.io/) |
-| [LFShook](https://github.com/rifflock/lfshook) | Hook for logging to the local filesystem |
-| [Honeybadger](https://github.com/agonzalezro/logrus_honeybadger) | Hook for sending exceptions to Honeybadger |
-| [Mail](https://github.com/zbindenren/logrus_mail) | Hook for sending exceptions via mail |
-| [Rollrus](https://github.com/heroku/rollrus) | Hook for sending errors to rollbar |
-| [Fluentd](https://github.com/evalphobia/logrus_fluent) | Hook for logging to fluentd |
-| [Mongodb](https://github.com/weekface/mgorus) | Hook for logging to mongodb |
-| [InfluxDB](https://github.com/Abramovic/logrus_influxdb) | Hook for logging to influxdb |
-| [Octokit](https://github.com/dorajistyle/logrus-octokit-hook) | Hook for logging to github via octokit |
-| [DeferPanic](https://github.com/deferpanic/dp-logrus) | Hook for logging to DeferPanic |
-
-#### Level logging
-
-Logrus has six logging levels: Debug, Info, Warning, Error, Fatal and Panic.
-
-```go
-log.Debug("Useful debugging information.")
-log.Info("Something noteworthy happened!")
-log.Warn("You should probably take a look at this.")
-log.Error("Something failed but I'm not quitting.")
-// Calls os.Exit(1) after logging
-log.Fatal("Bye.")
-// Calls panic() after logging
-log.Panic("I'm bailing.")
-```
-
-You can set the logging level on a `Logger`, then it will only log entries with
-that severity or anything above it:
-
-```go
-// Will log anything that is info or above (warn, error, fatal, panic). Default.
-log.SetLevel(log.InfoLevel)
-```
-
-It may be useful to set `log.Level = logrus.DebugLevel` in a debug or verbose
-environment if your application has that.
-
-#### Entries
-
-Besides the fields added with `WithField` or `WithFields` some fields are
-automatically added to all logging events:
-
-1. `time`. The timestamp when the entry was created.
-2. `msg`. The logging message passed to `{Info,Warn,Error,Fatal,Panic}` after
-   the `AddFields` call. E.g. `Failed to send event.`
-3. `level`. The logging level. E.g. `info`.
-
-#### Environments
-
-Logrus has no notion of environment.
-
-If you wish for hooks and formatters to only be used in specific environments,
-you should handle that yourself. For example, if your application has a global
-variable `Environment`, which is a string representation of the environment you
-could do:
-
-```go
-import (
-  log "github.com/Sirupsen/logrus"
-)
-
-init() {
-  // do something here to set environment depending on an environment variable
-  // or command-line flag
-  if Environment == "production" {
-    log.SetFormatter(&log.JSONFormatter{})
-  } else {
-    // The TextFormatter is default, you don't actually have to do this.
-    log.SetFormatter(&log.TextFormatter{})
-  }
-}
-```
-
-This configuration is how `logrus` was intended to be used, but JSON in
-production is mostly only useful if you do log aggregation with tools like
-Splunk or Logstash.
-
-#### Formatters
-
-The built-in logging formatters are:
-
-* `logrus.TextFormatter`. Logs the event in colors if stdout is a tty, otherwise
-  without colors.
-  * *Note:* to force colored output when there is no TTY, set the `ForceColors`
-    field to `true`.  To force no colored output even if there is a TTY  set the
-    `DisableColors` field to `true`
-* `logrus.JSONFormatter`. Logs fields as JSON.
-* `logrus/formatters/logstash.LogstashFormatter`. Logs fields as [Logstash](http://logstash.net) Events.
-
-    ```go
-      logrus.SetFormatter(&logstash.LogstashFormatter{Type: "application_name"})
-    ```
-
-Third party logging formatters:
-
-* [`prefixed`](https://github.com/x-cray/logrus-prefixed-formatter). Displays log entry source along with alternative layout.
-* [`zalgo`](https://github.com/aybabtme/logzalgo). Invoking the P͉̫o̳̼̊w̖͈̰͎e̬͔̭͂r͚̼̹̲ ̫͓͉̳͈ō̠͕͖̚f̝͍̠ ͕̲̞͖͑Z̖̫̤̫ͪa͉̬͈̗l͖͎g̳̥o̰̥̅!̣͔̲̻͊̄ ̙̘̦̹̦.
-
-You can define your formatter by implementing the `Formatter` interface,
-requiring a `Format` method. `Format` takes an `*Entry`. `entry.Data` is a
-`Fields` type (`map[string]interface{}`) with all your fields as well as the
-default ones (see Entries section above):
-
-```go
-type MyJSONFormatter struct {
-}
-
-log.SetFormatter(new(MyJSONFormatter))
-
-func (f *MyJSONFormatter) Format(entry *Entry) ([]byte, error) {
-  // Note this doesn't include Time, Level and Message which are available on
-  // the Entry. Consult `godoc` on information about those fields or read the
-  // source of the official loggers.
-  serialized, err := json.Marshal(entry.Data)
-    if err != nil {
-      return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
-    }
-  return append(serialized, '\n'), nil
-}
-```
-
-#### Logger as an `io.Writer`
-
-Logrus can be transformed into an `io.Writer`. That writer is the end of an `io.Pipe` and it is your responsibility to close it.
-
-```go
-w := logger.Writer()
-defer w.Close()
-
-srv := http.Server{
-    // create a stdlib log.Logger that writes to
-    // logrus.Logger.
-    ErrorLog: log.New(w, "", 0),
-}
-```
-
-Each line written to that writer will be printed the usual way, using formatters
-and hooks. The level for those entries is `info`.
-
-#### Rotation
-
-Log rotation is not provided with Logrus. Log rotation should be done by an
-external program (like `logrotate(8)`) that can compress and delete old log
-entries. It should not be a feature of the application-level logger.
-
-#### Tools
-
-| Tool | Description |
-| ---- | ----------- |
-|[Logrus Mate](https://github.com/gogap/logrus_mate)|Logrus mate is a tool for Logrus to manage loggers, you can initial logger's level, hook and formatter by config file, the logger will generated with different config at different environment.|
-
-[godoc]: https://godoc.org/github.com/Sirupsen/logrus

Godeps/_workspace/src/github.com/Sirupsen/logrus/doc.go

@@ -1,26 +0,0 @@
-/*
-Package logrus is a structured logger for Go, completely API compatible with the standard library logger.
-
-
-The simplest way to use Logrus is simply the package-level exported logger:
-
-  package main
-
-  import (
-    log "github.com/Sirupsen/logrus"
-  )
-
-  func main() {
-    log.WithFields(log.Fields{
-      "animal": "walrus",
-      "number": 1,
-      "size":   10,
-    }).Info("A walrus appears")
-  }
-
-Output:
-  time="2015-09-07T08:48:33Z" level=info msg="A walrus appears" animal=walrus number=1 size=10
-
-For a full guide visit https://github.com/Sirupsen/logrus
-*/
-package logrus

Godeps/_workspace/src/github.com/Sirupsen/logrus/entry.go

@@ -1,264 +0,0 @@
-package logrus
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"os"
-	"time"
-)
-
-// Defines the key when adding errors using WithError.
-var ErrorKey = "error"
-
-// An entry is the final or intermediate Logrus logging entry. It contains all
-// the fields passed with WithField{,s}. It's finally logged when Debug, Info,
-// Warn, Error, Fatal or Panic is called on it. These objects can be reused and
-// passed around as much as you wish to avoid field duplication.
-type Entry struct {
-	Logger *Logger
-
-	// Contains all the fields set by the user.
-	Data Fields
-
-	// Time at which the log entry was created
-	Time time.Time
-
-	// Level the log entry was logged at: Debug, Info, Warn, Error, Fatal or Panic
-	Level Level
-
-	// Message passed to Debug, Info, Warn, Error, Fatal or Panic
-	Message string
-}
-
-func NewEntry(logger *Logger) *Entry {
-	return &Entry{
-		Logger: logger,
-		// Default is three fields, give a little extra room
-		Data: make(Fields, 5),
-	}
-}
-
-// Returns a reader for the entry, which is a proxy to the formatter.
-func (entry *Entry) Reader() (*bytes.Buffer, error) {
-	serialized, err := entry.Logger.Formatter.Format(entry)
-	return bytes.NewBuffer(serialized), err
-}
-
-// Returns the string representation from the reader and ultimately the
-// formatter.
-func (entry *Entry) String() (string, error) {
-	reader, err := entry.Reader()
-	if err != nil {
-		return "", err
-	}
-
-	return reader.String(), err
-}
-
-// Add an error as single field (using the key defined in ErrorKey) to the Entry.
-func (entry *Entry) WithError(err error) *Entry {
-	return entry.WithField(ErrorKey, err)
-}
-
-// Add a single field to the Entry.
-func (entry *Entry) WithField(key string, value interface{}) *Entry {
-	return entry.WithFields(Fields{key: value})
-}
-
-// Add a map of fields to the Entry.
-func (entry *Entry) WithFields(fields Fields) *Entry {
-	data := Fields{}
-	for k, v := range entry.Data {
-		data[k] = v
-	}
-	for k, v := range fields {
-		data[k] = v
-	}
-	return &Entry{Logger: entry.Logger, Data: data}
-}
-
-// This function is not declared with a pointer value because otherwise
-// race conditions will occur when using multiple goroutines
-func (entry Entry) log(level Level, msg string) {
-	entry.Time = time.Now()
-	entry.Level = level
-	entry.Message = msg
-
-	if err := entry.Logger.Hooks.Fire(level, &entry); err != nil {
-		entry.Logger.mu.Lock()
-		fmt.Fprintf(os.Stderr, "Failed to fire hook: %v\n", err)
-		entry.Logger.mu.Unlock()
-	}
-
-	reader, err := entry.Reader()
-	if err != nil {
-		entry.Logger.mu.Lock()
-		fmt.Fprintf(os.Stderr, "Failed to obtain reader, %v\n", err)
-		entry.Logger.mu.Unlock()
-	}
-
-	entry.Logger.mu.Lock()
-	defer entry.Logger.mu.Unlock()
-
-	_, err = io.Copy(entry.Logger.Out, reader)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Failed to write to log, %v\n", err)
-	}
-
-	// To avoid Entry#log() returning a value that only would make sense for
-	// panic() to use in Entry#Panic(), we avoid the allocation by checking
-	// directly here.
-	if level <= PanicLevel {
-		panic(&entry)
-	}
-}
-
-func (entry *Entry) Debug(args ...interface{}) {
-	if entry.Logger.Level >= DebugLevel {
-		entry.log(DebugLevel, fmt.Sprint(args...))
-	}
-}
-
-func (entry *Entry) Print(args ...interface{}) {
-	entry.Info(args...)
-}
-
-func (entry *Entry) Info(args ...interface{}) {
-	if entry.Logger.Level >= InfoLevel {
-		entry.log(InfoLevel, fmt.Sprint(args...))
-	}
-}
-
-func (entry *Entry) Warn(args ...interface{}) {
-	if entry.Logger.Level >= WarnLevel {
-		entry.log(WarnLevel, fmt.Sprint(args...))
-	}
-}
-
-func (entry *Entry) Warning(args ...interface{}) {
-	entry.Warn(args...)
-}
-
-func (entry *Entry) Error(args ...interface{}) {
-	if entry.Logger.Level >= ErrorLevel {
-		entry.log(ErrorLevel, fmt.Sprint(args...))
-	}
-}
-
-func (entry *Entry) Fatal(args ...interface{}) {
-	if entry.Logger.Level >= FatalLevel {
-		entry.log(FatalLevel, fmt.Sprint(args...))
-	}
-	os.Exit(1)
-}
-
-func (entry *Entry) Panic(args ...interface{}) {
-	if entry.Logger.Level >= PanicLevel {
-		entry.log(PanicLevel, fmt.Sprint(args...))
-	}
-	panic(fmt.Sprint(args...))
-}
-
-// Entry Printf family functions
-
-func (entry *Entry) Debugf(format string, args ...interface{}) {
-	if entry.Logger.Level >= DebugLevel {
-		entry.Debug(fmt.Sprintf(format, args...))
-	}
-}
-
-func (entry *Entry) Infof(format string, args ...interface{}) {
-	if entry.Logger.Level >= InfoLevel {
-		entry.Info(fmt.Sprintf(format, args...))
-	}
-}
-
-func (entry *Entry) Printf(format string, args ...interface{}) {
-	entry.Infof(format, args...)
-}
-
-func (entry *Entry) Warnf(format string, args ...interface{}) {
-	if entry.Logger.Level >= WarnLevel {
-		entry.Warn(fmt.Sprintf(format, args...))
-	}
-}
-
-func (entry *Entry) Warningf(format string, args ...interface{}) {
-	entry.Warnf(format, args...)
-}
-
-func (entry *Entry) Errorf(format string, args ...interface{}) {
-	if entry.Logger.Level >= ErrorLevel {
-		entry.Error(fmt.Sprintf(format, args...))
-	}
-}
-
-func (entry *Entry) Fatalf(format string, args ...interface{}) {
-	if entry.Logger.Level >= FatalLevel {
-		entry.Fatal(fmt.Sprintf(format, args...))
-	}
-	os.Exit(1)
-}
-
-func (entry *Entry) Panicf(format string, args ...interface{}) {
-	if entry.Logger.Level >= PanicLevel {
-		entry.Panic(fmt.Sprintf(format, args...))
-	}
-}
-
-// Entry Println family functions
-
-func (entry *Entry) Debugln(args ...interface{}) {
-	if entry.Logger.Level >= DebugLevel {
-		entry.Debug(entry.sprintlnn(args...))
-	}
-}
-
-func (entry *Entry) Infoln(args ...interface{}) {
-	if entry.Logger.Level >= InfoLevel {
-		entry.Info(entry.sprintlnn(args...))
-	}
-}
-
-func (entry *Entry) Println(args ...interface{}) {
-	entry.Infoln(args...)
-}
-
-func (entry *Entry) Warnln(args ...interface{}) {
-	if entry.Logger.Level >= WarnLevel {
-		entry.Warn(entry.sprintlnn(args...))
-	}
-}
-
-func (entry *Entry) Warningln(args ...interface{}) {
-	entry.Warnln(args...)
-}
-
-func (entry *Entry) Errorln(args ...interface{}) {
-	if entry.Logger.Level >= ErrorLevel {
-		entry.Error(entry.sprintlnn(args...))
-	}
-}
-
-func (entry *Entry) Fatalln(args ...interface{}) {
-	if entry.Logger.Level >= FatalLevel {
-		entry.Fatal(entry.sprintlnn(args...))
-	}
-	os.Exit(1)
-}
-
-func (entry *Entry) Panicln(args ...interface{}) {
-	if entry.Logger.Level >= PanicLevel {
-		entry.Panic(entry.sprintlnn(args...))
-	}
-}
-
-// Sprintlnn => Sprint no newline. This is to get the behavior of how
-// fmt.Sprintln where spaces are always added between operands, regardless of
-// their type. Instead of vendoring the Sprintln implementation to spare a
-// string allocation, we do the simplest thing.
-func (entry *Entry) sprintlnn(args ...interface{}) string {
-	msg := fmt.Sprintln(args...)
-	return msg[:len(msg)-1]
-}

Godeps/_workspace/src/github.com/Sirupsen/logrus/examples/basic/basic.go

@@ -1,50 +0,0 @@
-package main
-
-import (
-	"github.com/Sirupsen/logrus"
-)
-
-var log = logrus.New()
-
-func init() {
-	log.Formatter = new(logrus.JSONFormatter)
-	log.Formatter = new(logrus.TextFormatter) // default
-	log.Level = logrus.DebugLevel
-}
-
-func main() {
-	defer func() {
-		err := recover()
-		if err != nil {
-			log.WithFields(logrus.Fields{
-				"omg":    true,
-				"err":    err,
-				"number": 100,
-			}).Fatal("The ice breaks!")
-		}
-	}()
-
-	log.WithFields(logrus.Fields{
-		"animal": "walrus",
-		"number": 8,
-	}).Debug("Started observing beach")
-
-	log.WithFields(logrus.Fields{
-		"animal": "walrus",
-		"size":   10,
-	}).Info("A group of walrus emerges from the ocean")
-
-	log.WithFields(logrus.Fields{
-		"omg":    true,
-		"number": 122,
-	}).Warn("The group's number increased tremendously!")
-
-	log.WithFields(logrus.Fields{
-		"temperature": -4,
-	}).Debug("Temperature changes")
-
-	log.WithFields(logrus.Fields{
-		"animal": "orca",
-		"size":   9009,
-	}).Panic("It's over 9000!")
-}

Godeps/_workspace/src/github.com/Sirupsen/logrus/examples/hook/hook.go

@@ -1,30 +0,0 @@
-package main
-
-import (
-	"github.com/Sirupsen/logrus"
-	"gopkg.in/gemnasium/logrus-airbrake-hook.v2"
-)
-
-var log = logrus.New()
-
-func init() {
-	log.Formatter = new(logrus.TextFormatter) // default
-	log.Hooks.Add(airbrake.NewHook(123, "xyz", "development"))
-}
-
-func main() {
-	log.WithFields(logrus.Fields{
-		"animal": "walrus",
-		"size":   10,
-	}).Info("A group of walrus emerges from the ocean")
-
-	log.WithFields(logrus.Fields{
-		"omg":    true,
-		"number": 122,
-	}).Warn("The group's number increased tremendously!")
-
-	log.WithFields(logrus.Fields{
-		"omg":    true,
-		"number": 100,
-	}).Fatal("The ice breaks!")
-}

Godeps/_workspace/src/github.com/Sirupsen/logrus/exported.go

@@ -1,193 +0,0 @@
-package logrus
-
-import (
-	"io"
-)
-
-var (
-	// std is the name of the standard logger in stdlib `log`
-	std = New()
-)
-
-func StandardLogger() *Logger {
-	return std
-}
-
-// SetOutput sets the standard logger output.
-func SetOutput(out io.Writer) {
-	std.mu.Lock()
-	defer std.mu.Unlock()
-	std.Out = out
-}
-
-// SetFormatter sets the standard logger formatter.
-func SetFormatter(formatter Formatter) {
-	std.mu.Lock()
-	defer std.mu.Unlock()
-	std.Formatter = formatter
-}
-
-// SetLevel sets the standard logger level.
-func SetLevel(level Level) {
-	std.mu.Lock()
-	defer std.mu.Unlock()
-	std.Level = level
-}
-
-// GetLevel returns the standard logger level.
-func GetLevel() Level {
-	std.mu.Lock()
-	defer std.mu.Unlock()
-	return std.Level
-}
-
-// AddHook adds a hook to the standard logger hooks.
-func AddHook(hook Hook) {
-	std.mu.Lock()
-	defer std.mu.Unlock()
-	std.Hooks.Add(hook)
-}
-
-// WithError creates an entry from the standard logger and adds an error to it, using the value defined in ErrorKey as key.
-func WithError(err error) *Entry {
-	return std.WithField(ErrorKey, err)
-}
-
-// WithField creates an entry from the standard logger and adds a field to
-// it. If you want multiple fields, use `WithFields`.
-//
-// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
-// or Panic on the Entry it returns.
-func WithField(key string, value interface{}) *Entry {
-	return std.WithField(key, value)
-}
-
-// WithFields creates an entry from the standard logger and adds multiple
-// fields to it. This is simply a helper for `WithField`, invoking it
-// once for each field.
-//
-// Note that it doesn't log until you call Debug, Print, Info, Warn, Fatal
-// or Panic on the Entry it returns.
-func WithFields(fields Fields) *Entry {
-	return std.WithFields(fields)
-}
-
-// Debug logs a message at level Debug on the standard logger.
-func Debug(args ...interface{}) {
-	std.Debug(args...)
-}
-
-// Print logs a message at level Info on the standard logger.
-func Print(args ...interface{}) {
-	std.Print(args...)
-}
-
-// Info logs a message at level Info on the standard logger.
-func Info(args ...interface{}) {
-	std.Info(args...)
-}
-
-// Warn logs a message at level Warn on the standard logger.
-func Warn(args ...interface{}) {
-	std.Warn(args...)
-}
-
-// Warning logs a message at level Warn on the standard logger.
-func Warning(args ...interface{}) {
-	std.Warning(args...)
-}
-
-// Error logs a message at level Error on the standard logger.
-func Error(args ...interface{}) {
-	std.Error(args...)
-}
-
-// Panic logs a message at level Panic on the standard logger.
-func Panic(args ...interface{}) {
-	std.Panic(args...)
-}
-
-// Fatal logs a message at level Fatal on the standard logger.
-func Fatal(args ...interface{}) {
-	std.Fatal(args...)
-}
-
-// Debugf logs a message at level Debug on the standard logger.
-func Debugf(format string, args ...interface{}) {
-	std.Debugf(format, args...)
-}
-
-// Printf logs a message at level Info on the standard logger.
-func Printf(format string, args ...interface{}) {
-	std.Printf(format, args...)
-}
-
-// Infof logs a message at level Info on the standard logger.
-func Infof(format string, args ...interface{}) {
-	std.Infof(format, args...)
-}
-
-// Warnf logs a message at level Warn on the standard logger.
-func Warnf(format string, args ...interface{}) {
-	std.Warnf(format, args...)
-}
-
-// Warningf logs a message at level Warn on the standard logger.
-func Warningf(format string, args ...interface{}) {
-	std.Warningf(format, args...)
-}
-
-// Errorf logs a message at level Error on the standard logger.
-func Errorf(format string, args ...interface{}) {
-	std.Errorf(format, args...)
-}
-
-// Panicf logs a message at level Panic on the standard logger.
-func Panicf(format string, args ...interface{}) {
-	std.Panicf(format, args...)
-}
-
-// Fatalf logs a message at level Fatal on the standard logger.
-func Fatalf(format string, args ...interface{}) {
-	std.Fatalf(format, args...)
-}
-
-// Debugln logs a message at level Debug on the standard logger.
-func Debugln(args ...interface{}) {
-	std.Debugln(args...)
-}
-
-// Println logs a message at level Info on the standard logger.
-func Println(args ...interface{}) {
-	std.Println(args...)
-}
-
-// Infoln logs a message at level Info on the standard logger.
-func Infoln(args ...interface{}) {
-	std.Infoln(args...)
-}
-
-// Warnln logs a message at level Warn on the standard logger.
-func Warnln(args ...interface{}) {
-	std.Warnln(args...)
-}
-
-// Warningln logs a message at level Warn on the standard logger.
-func Warningln(args ...interface{}) {
-	std.Warningln(args...)
-}
-
-// Errorln logs a message at level Error on the standard logger.
-func Errorln(args ...interface{}) {
-	std.Errorln(args...)
-}
-
-// Panicln logs a message at level Panic on the standard logger.
-func Panicln(args ...interface{}) {
-	std.Panicln(args...)
-}
-
-// Fatalln logs a message at level Fatal on the standard logger.
-func Fatalln(args ...interface{}) {
-	std.Fatalln(args...)
-}

Godeps/_workspace/src/github.com/Sirupsen/logrus/formatter.go

@@ -1,48 +0,0 @@
-package logrus
-
-import "time"
-
-const DefaultTimestampFormat = time.RFC3339
-
-// The Formatter interface is used to implement a custom Formatter. It takes an
-// `Entry`. It exposes all the fields, including the default ones:
-//
-// * `entry.Data["msg"]`. The message passed from Info, Warn, Error ..
-// * `entry.Data["time"]`. The timestamp.
-// * `entry.Data["level"]. The level the entry was logged at.
-//
-// Any additional fields added with `WithField` or `WithFields` are also in
-// `entry.Data`. Format is expected to return an array of bytes which are then
-// logged to `logger.Out`.
-type Formatter interface {
-	Format(*Entry) ([]byte, error)
-}
-
-// This is to not silently overwrite `time`, `msg` and `level` fields when
-// dumping it. If this code wasn't there doing:
-//
-//  logrus.WithField("level", 1).Info("hello")
-//
-// Would just silently drop the user provided level. Instead with this code
-// it'll logged as:
-//
-//  {"level": "info", "fields.level": 1, "msg": "hello", "time": "..."}
-//
-// It's not exported because it's still using Data in an opinionated way. It's to
-// avoid code duplication between the two default formatters.
-func prefixFieldClashes(data Fields) {
-	_, ok := data["time"]
-	if ok {
-		data["fields.time"] = data["time"]
-	}
-
-	_, ok = data["msg"]
-	if ok {
-		data["fields.msg"] = data["msg"]
-	}
-
-	_, ok = data["level"]
-	if ok {
-		data["fields.level"] = data["level"]
-	}
-}

Godeps/_workspace/src/github.com/Sirupsen/logrus/formatters/logstash/logstash.go

@@ -1,61 +0,0 @@
-package logstash
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/Sirupsen/logrus"
-)
-
-// Formatter generates json in logstash format.
-// Logstash site: http://logstash.net/
-type LogstashFormatter struct {
-	Type string // if not empty use for logstash type field.
-
-	// TimestampFormat sets the format used for timestamps.
-	TimestampFormat string
-}
-
-func (f *LogstashFormatter) Format(entry *logrus.Entry) ([]byte, error) {
-	fields := make(logrus.Fields)
-	for k, v := range entry.Data {
-		fields[k] = v
-	}
-
-	fields["@version"] = 1
-
-	if f.TimestampFormat == "" {
-		f.TimestampFormat = logrus.DefaultTimestampFormat
-	}
-
-	fields["@timestamp"] = entry.Time.Format(f.TimestampFormat)
-
-	// set message field
-	v, ok := entry.Data["message"]
-	if ok {
-		fields["fields.message"] = v
-	}
-	fields["message"] = entry.Message
-
-	// set level field
-	v, ok = entry.Data["level"]
-	if ok {
-		fields["fields.level"] = v
-	}
-	fields["level"] = entry.Level.String()
-
-	// set type field
-	if f.Type != "" {
-		v, ok = entry.Data["type"]
-		if ok {
-			fields["fields.type"] = v
-		}
-		fields["type"] = f.Type
-	}
-
-	serialized, err := json.Marshal(fields)
-	if err != nil {
-		return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
-	}
-	return append(serialized, '\n'), nil
-}

Godeps/_workspace/src/github.com/Sirupsen/logrus/hooks/syslog/README.md

@@ -1,39 +0,0 @@
-# Syslog Hooks for Logrus <img src="http://i.imgur.com/hTeVwmJ.png" width="40" height="40" alt=":walrus:" class="emoji" title=":walrus:"/>
-
-## Usage
-
-```go
-import (
-  "log/syslog"
-  "github.com/Sirupsen/logrus"
-  logrus_syslog "github.com/Sirupsen/logrus/hooks/syslog"
-)
-
-func main() {
-  log       := logrus.New()
-  hook, err := logrus_syslog.NewSyslogHook("udp", "localhost:514", syslog.LOG_INFO, "")
-
-  if err == nil {
-    log.Hooks.Add(hook)
-  }
-}
-```
-
-If you want to connect to local syslog (Ex. "/dev/log" or "/var/run/syslog" or "/var/run/log"). Just assign empty string to the first two parameters of `NewSyslogHook`. It should look like the following.
-
-```go
-import (
-  "log/syslog"
-  "github.com/Sirupsen/logrus"
-  logrus_syslog "github.com/Sirupsen/logrus/hooks/syslog"
-)
-
-func main() {
-  log       := logrus.New()
-  hook, err := logrus_syslog.NewSyslogHook("", "", syslog.LOG_INFO, "")
-
-  if err == nil {
-    log.Hooks.Add(hook)
-  }
-}
-```

Godeps/_workspace/src/github.com/Sirupsen/logrus/hooks/syslog/syslog.go

@@ -1,61 +0,0 @@
-// +build !windows,!nacl,!plan9
-
-package logrus_syslog
-
-import (
-	"fmt"
-	"github.com/Sirupsen/logrus"
-	"log/syslog"
-	"os"
-)
-
-// SyslogHook to send logs via syslog.
-type SyslogHook struct {
-	Writer        *syslog.Writer
-	SyslogNetwork string
-	SyslogRaddr   string
-}
-
-// Creates a hook to be added to an instance of logger. This is called with
-// `hook, err := NewSyslogHook("udp", "localhost:514", syslog.LOG_DEBUG, "")`
-// `if err == nil { log.Hooks.Add(hook) }`
-func NewSyslogHook(network, raddr string, priority syslog.Priority, tag string) (*SyslogHook, error) {
-	w, err := syslog.Dial(network, raddr, priority, tag)
-	return &SyslogHook{w, network, raddr}, err
-}
-
-func (hook *SyslogHook) Fire(entry *logrus.Entry) error {
-	line, err := entry.String()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Unable to read entry, %v", err)
-		return err
-	}
-
-	switch entry.Level {
-	case logrus.PanicLevel:
-		return hook.Writer.Crit(line)
-	case logrus.FatalLevel:
-		return hook.Writer.Crit(line)
-	case logrus.ErrorLevel:
-		return hook.Writer.Err(line)
-	case logrus.WarnLevel:
-		return hook.Writer.Warning(line)
-	case logrus.InfoLevel:
-		return hook.Writer.Info(line)
-	case logrus.DebugLevel:
-		return hook.Writer.Debug(line)
-	default:
-		return nil
-	}
-}
-
-func (hook *SyslogHook) Levels() []logrus.Level {
-	return []logrus.Level{
-		logrus.PanicLevel,
-		logrus.FatalLevel,
-		logrus.ErrorLevel,
-		logrus.WarnLevel,
-		logrus.InfoLevel,
-		logrus.DebugLevel,
-	}
-}

Godeps/_workspace/src/github.com/Sirupsen/logrus/json_formatter.go

@@ -1,41 +0,0 @@
-package logrus
-
-import (
-	"encoding/json"
-	"fmt"
-)
-
-type JSONFormatter struct {
-	// TimestampFormat sets the format used for marshaling timestamps.
-	TimestampFormat string
-}
-
-func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {
-	data := make(Fields, len(entry.Data)+3)
-	for k, v := range entry.Data {
-		switch v := v.(type) {
-		case error:
-			// Otherwise errors are ignored by `encoding/json`
-			// https://github.com/Sirupsen/logrus/issues/137
-			data[k] = v.Error()
-		default:
-			data[k] = v
-		}
-	}
-	prefixFieldClashes(data)
-
-	timestampFormat := f.TimestampFormat
-	if timestampFormat == "" {
-		timestampFormat = DefaultTimestampFormat
-	}
-
-	data["time"] = entry.Time.Format(timestampFormat)
-	data["msg"] = entry.Message
-	data["level"] = entry.Level.String()
-
-	serialized, err := json.Marshal(data)
-	if err != nil {
-		return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)
-	}
-	return append(serialized, '\n'), nil
-}

Godeps/_workspace/src/github.com/Sirupsen/logrus/logger.go

@@ -1,212 +0,0 @@
-package logrus
-
-import (
-	"io"
-	"os"
-	"sync"
-)
-
-type Logger struct {
-	// The logs are `io.Copy`'d to this in a mutex. It's common to set this to a
-	// file, or leave it default which is `os.Stderr`. You can also set this to
-	// something more adventorous, such as logging to Kafka.
-	Out io.Writer
-	// Hooks for the logger instance. These allow firing events based on logging
-	// levels and log entries. For example, to send errors to an error tracking
-	// service, log to StatsD or dump the core on fatal errors.
-	Hooks LevelHooks
-	// All log entries pass through the formatter before logged to Out. The
-	// included formatters are `TextFormatter` and `JSONFormatter` for which
-	// TextFormatter is the default. In development (when a TTY is attached) it
-	// logs with colors, but to a file it wouldn't. You can easily implement your
-	// own that implements the `Formatter` interface, see the `README` or included
-	// formatters for examples.
-	Formatter Formatter
-	// The logging level the logger should log at. This is typically (and defaults
-	// to) `logrus.Info`, which allows Info(), Warn(), Error() and Fatal() to be
-	// logged. `logrus.Debug` is useful in
-	Level Level
-	// Used to sync writing to the log.
-	mu sync.Mutex
-}
-
-// Creates a new logger. Configuration should be set by changing `Formatter`,
-// `Out` and `Hooks` directly on the default logger instance. You can also just
-// instantiate your own:
-//
-//    var log = &Logger{
-//      Out: os.Stderr,
-//      Formatter: new(JSONFormatter),
-//      Hooks: make(LevelHooks),
-//      Level: logrus.DebugLevel,
-//    }
-//
-// It's recommended to make this a global instance called `log`.
-func New() *Logger {
-	return &Logger{
-		Out:       os.Stderr,
-		Formatter: new(TextFormatter),
-		Hooks:     make(LevelHooks),
-		Level:     InfoLevel,
-	}
-}
-
-// Adds a field to the log entry, note that you it doesn't log until you call
-// Debug, Print, Info, Warn, Fatal or Panic. It only creates a log entry.
-// If you want multiple fields, use `WithFields`.
-func (logger *Logger) WithField(key string, value interface{}) *Entry {
-	return NewEntry(logger).WithField(key, value)
-}
-
-// Adds a struct of fields to the log entry. All it does is call `WithField` for
-// each `Field`.
-func (logger *Logger) WithFields(fields Fields) *Entry {
-	return NewEntry(logger).WithFields(fields)
-}
-
-// Add an error as single field to the log entry.  All it does is call
-// `WithError` for the given `error`.
-func (logger *Logger) WithError(err error) *Entry {
-	return NewEntry(logger).WithError(err)
-}
-
-func (logger *Logger) Debugf(format string, args ...interface{}) {
-	if logger.Level >= DebugLevel {
-		NewEntry(logger).Debugf(format, args...)
-	}
-}
-
-func (logger *Logger) Infof(format string, args ...interface{}) {
-	if logger.Level >= InfoLevel {
-		NewEntry(logger).Infof(format, args...)
-	}
-}
-
-func (logger *Logger) Printf(format string, args ...interface{}) {
-	NewEntry(logger).Printf(format, args...)
-}
-
-func (logger *Logger) Warnf(format string, args ...interface{}) {
-	if logger.Level >= WarnLevel {
-		NewEntry(logger).Warnf(format, args...)
-	}
-}
-
-func (logger *Logger) Warningf(format string, args ...interface{}) {
-	if logger.Level >= WarnLevel {
-		NewEntry(logger).Warnf(format, args...)
-	}
-}
-
-func (logger *Logger) Errorf(format string, args ...interface{}) {
-	if logger.Level >= ErrorLevel {
-		NewEntry(logger).Errorf(format, args...)
-	}
-}
-
-func (logger *Logger) Fatalf(format string, args ...interface{}) {
-	if logger.Level >= FatalLevel {
-		NewEntry(logger).Fatalf(format, args...)
-	}
-	os.Exit(1)
-}
-
-func (logger *Logger) Panicf(format string, args ...interface{}) {
-	if logger.Level >= PanicLevel {
-		NewEntry(logger).Panicf(format, args...)
-	}
-}
-
-func (logger *Logger) Debug(args ...interface{}) {
-	if logger.Level >= DebugLevel {
-		NewEntry(logger).Debug(args...)
-	}
-}
-
-func (logger *Logger) Info(args ...interface{}) {
-	if logger.Level >= InfoLevel {
-		NewEntry(logger).Info(args...)
-	}
-}
-
-func (logger *Logger) Print(args ...interface{}) {
-	NewEntry(logger).Info(args...)
-}
-
-func (logger *Logger) Warn(args ...interface{}) {
-	if logger.Level >= WarnLevel {
-		NewEntry(logger).Warn(args...)
-	}
-}
-
-func (logger *Logger) Warning(args ...interface{}) {
-	if logger.Level >= WarnLevel {
-		NewEntry(logger).Warn(args...)
-	}
-}
-
-func (logger *Logger) Error(args ...interface{}) {
-	if logger.Level >= ErrorLevel {
-		NewEntry(logger).Error(args...)
-	}
-}
-
-func (logger *Logger) Fatal(args ...interface{}) {
-	if logger.Level >= FatalLevel {
-		NewEntry(logger).Fatal(args...)
-	}
-	os.Exit(1)
-}
-
-func (logger *Logger) Panic(args ...interface{}) {
-	if logger.Level >= PanicLevel {
-		NewEntry(logger).Panic(args...)
-	}
-}
-
-func (logger *Logger) Debugln(args ...interface{}) {
-	if logger.Level >= DebugLevel {
-		NewEntry(logger).Debugln(args...)
-	}
-}
-
-func (logger *Logger) Infoln(args ...interface{}) {
-	if logger.Level >= InfoLevel {
-		NewEntry(logger).Infoln(args...)
-	}
-}
-
-func (logger *Logger) Println(args ...interface{}) {
-	NewEntry(logger).Println(args...)
-}
-
-func (logger *Logger) Warnln(args ...interface{}) {
-	if logger.Level >= WarnLevel {
-		NewEntry(logger).Warnln(args...)
-	}
-}
-
-func (logger *Logger) Warningln(args ...interface{}) {
-	if logger.Level >= WarnLevel {
-		NewEntry(logger).Warnln(args...)
-	}
-}
-
-func (logger *Logger) Errorln(args ...interface{}) {
-	if logger.Level >= ErrorLevel {
-		NewEntry(logger).Errorln(args...)
-	}
-}
-
-func (logger *Logger) Fatalln(args ...interface{}) {
-	if logger.Level >= FatalLevel {
-		NewEntry(logger).Fatalln(args...)
-	}
-	os.Exit(1)
-}
-
-func (logger *Logger) Panicln(args ...interface{}) {
-	if logger.Level >= PanicLevel {
-		NewEntry(logger).Panicln(args...)
-	}
-}

Godeps/_workspace/src/github.com/Sirupsen/logrus/logrus.go

@@ -1,98 +0,0 @@
-package logrus
-
-import (
-	"fmt"
-	"log"
-)
-
-// Fields type, used to pass to `WithFields`.
-type Fields map[string]interface{}
-
-// Level type
-type Level uint8
-
-// Convert the Level to a string. E.g. PanicLevel becomes "panic".
-func (level Level) String() string {
-	switch level {
-	case DebugLevel:
-		return "debug"
-	case InfoLevel:
-		return "info"
-	case WarnLevel:
-		return "warning"
-	case ErrorLevel:
-		return "error"
-	case FatalLevel:
-		return "fatal"
-	case PanicLevel:
-		return "panic"
-	}
-
-	return "unknown"
-}
-
-// ParseLevel takes a string level and returns the Logrus log level constant.
-func ParseLevel(lvl string) (Level, error) {
-	switch lvl {
-	case "panic":
-		return PanicLevel, nil
-	case "fatal":
-		return FatalLevel, nil
-	case "error":
-		return ErrorLevel, nil
-	case "warn", "warning":
-		return WarnLevel, nil
-	case "info":
-		return InfoLevel, nil
-	case "debug":
-		return DebugLevel, nil
-	}
-
-	var l Level
-	return l, fmt.Errorf("not a valid logrus Level: %q", lvl)
-}
-
-// These are the different logging levels. You can set the logging level to log
-// on your instance of logger, obtained with `logrus.New()`.
-const (
-	// PanicLevel level, highest level of severity. Logs and then calls panic with the
-	// message passed to Debug, Info, ...
-	PanicLevel Level = iota
-	// FatalLevel level. Logs and then calls `os.Exit(1)`. It will exit even if the
-	// logging level is set to Panic.
-	FatalLevel
-	// ErrorLevel level. Logs. Used for errors that should definitely be noted.
-	// Commonly used for hooks to send errors to an error tracking service.
-	ErrorLevel
-	// WarnLevel level. Non-critical entries that deserve eyes.
-	WarnLevel
-	// InfoLevel level. General operational entries about what's going on inside the
-	// application.
-	InfoLevel
-	// DebugLevel level. Usually only enabled when debugging. Very verbose logging.
-	DebugLevel
-)
-
-// Won't compile if StdLogger can't be realized by a log.Logger
-var (
-	_ StdLogger = &log.Logger{}
-	_ StdLogger = &Entry{}
-	_ StdLogger = &Logger{}
-)
-
-// StdLogger is what your logrus-enabled library should take, that way
-// it'll accept a stdlib logger and a logrus logger. There's no standard
-// interface, this is the closest we get, unfortunately.
-type StdLogger interface {
-	Print(...interface{})
-	Printf(string, ...interface{})
-	Println(...interface{})
-
-	Fatal(...interface{})
-	Fatalf(string, ...interface{})
-	Fatalln(...interface{})
-
-	Panic(...interface{})
-	Panicf(string, ...interface{})
-	Panicln(...interface{})
-}

Godeps/_workspace/src/github.com/Sirupsen/logrus/terminal_bsd.go

@@ -1,9 +0,0 @@
-// +build darwin freebsd openbsd netbsd dragonfly
-
-package logrus
-
-import "syscall"
-
-const ioctlReadTermios = syscall.TIOCGETA
-
-type Termios syscall.Termios

Godeps/_workspace/src/github.com/Sirupsen/logrus/terminal_linux.go

@@ -1,12 +0,0 @@
-// Based on ssh/terminal:
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package logrus
-
-import "syscall"
-
-const ioctlReadTermios = syscall.TCGETS
-
-type Termios syscall.Termios

Godeps/_workspace/src/github.com/Sirupsen/logrus/terminal_notwindows.go

@@ -1,21 +0,0 @@
-// Based on ssh/terminal:
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build linux darwin freebsd openbsd netbsd dragonfly
-
-package logrus
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-// IsTerminal returns true if stderr's file descriptor is a terminal.
-func IsTerminal() bool {
-	fd := syscall.Stderr
-	var termios Termios
-	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, uintptr(fd), ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
-	return err == 0
-}

Godeps/_workspace/src/github.com/Sirupsen/logrus/terminal_solaris.go

@@ -1,15 +0,0 @@
-// +build solaris
-
-package logrus
-
-import (
-	"os"
-
-	"golang.org/x/sys/unix"
-)
-
-// IsTerminal returns true if the given file descriptor is a terminal.
-func IsTerminal() bool {
-	_, err := unix.IoctlGetTermios(int(os.Stdout.Fd()), unix.TCGETA)
-	return err == nil
-}

Godeps/_workspace/src/github.com/Sirupsen/logrus/terminal_windows.go

@@ -1,27 +0,0 @@
-// Based on ssh/terminal:
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build windows
-
-package logrus
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-var kernel32 = syscall.NewLazyDLL("kernel32.dll")
-
-var (
-	procGetConsoleMode = kernel32.NewProc("GetConsoleMode")
-)
-
-// IsTerminal returns true if stderr's file descriptor is a terminal.
-func IsTerminal() bool {
-	fd := syscall.Stderr
-	var st uint32
-	r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, uintptr(fd), uintptr(unsafe.Pointer(&st)), 0)
-	return r != 0 && e == 0
-}

Godeps/_workspace/src/github.com/Sirupsen/logrus/text_formatter.go

@@ -1,161 +0,0 @@
-package logrus
-
-import (
-	"bytes"
-	"fmt"
-	"runtime"
-	"sort"
-	"strings"
-	"time"
-)
-
-const (
-	nocolor = 0
-	red     = 31
-	green   = 32
-	yellow  = 33
-	blue    = 34
-	gray    = 37
-)
-
-var (
-	baseTimestamp time.Time
-	isTerminal    bool
-)
-
-func init() {
-	baseTimestamp = time.Now()
-	isTerminal = IsTerminal()
-}
-
-func miniTS() int {
-	return int(time.Since(baseTimestamp) / time.Second)
-}
-
-type TextFormatter struct {
-	// Set to true to bypass checking for a TTY before outputting colors.
-	ForceColors bool
-
-	// Force disabling colors.
-	DisableColors bool
-
-	// Disable timestamp logging. useful when output is redirected to logging
-	// system that already adds timestamps.
-	DisableTimestamp bool
-
-	// Enable logging the full timestamp when a TTY is attached instead of just
-	// the time passed since beginning of execution.
-	FullTimestamp bool
-
-	// TimestampFormat to use for display when a full timestamp is printed
-	TimestampFormat string
-
-	// The fields are sorted by default for a consistent output. For applications
-	// that log extremely frequently and don't use the JSON formatter this may not
-	// be desired.
-	DisableSorting bool
-}
-
-func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {
-	var keys []string = make([]string, 0, len(entry.Data))
-	for k := range entry.Data {
-		keys = append(keys, k)
-	}
-
-	if !f.DisableSorting {
-		sort.Strings(keys)
-	}
-
-	b := &bytes.Buffer{}
-
-	prefixFieldClashes(entry.Data)
-
-	isColorTerminal := isTerminal && (runtime.GOOS != "windows")
-	isColored := (f.ForceColors || isColorTerminal) && !f.DisableColors
-
-	timestampFormat := f.TimestampFormat
-	if timestampFormat == "" {
-		timestampFormat = DefaultTimestampFormat
-	}
-	if isColored {
-		f.printColored(b, entry, keys, timestampFormat)
-	} else {
-		if !f.DisableTimestamp {
-			f.appendKeyValue(b, "time", entry.Time.Format(timestampFormat))
-		}
-		f.appendKeyValue(b, "level", entry.Level.String())
-		if entry.Message != "" {
-			f.appendKeyValue(b, "msg", entry.Message)
-		}
-		for _, key := range keys {
-			f.appendKeyValue(b, key, entry.Data[key])
-		}
-	}
-
-	b.WriteByte('\n')
-	return b.Bytes(), nil
-}
-
-func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []string, timestampFormat string) {
-	var levelColor int
-	switch entry.Level {
-	case DebugLevel:
-		levelColor = gray
-	case WarnLevel:
-		levelColor = yellow
-	case ErrorLevel, FatalLevel, PanicLevel:
-		levelColor = red
-	default:
-		levelColor = blue
-	}
-
-	levelText := strings.ToUpper(entry.Level.String())[0:4]
-
-	if !f.FullTimestamp {
-		fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%04d] %-44s ", levelColor, levelText, miniTS(), entry.Message)
-	} else {
-		fmt.Fprintf(b, "\x1b[%dm%s\x1b[0m[%s] %-44s ", levelColor, levelText, entry.Time.Format(timestampFormat), entry.Message)
-	}
-	for _, k := range keys {
-		v := entry.Data[k]
-		fmt.Fprintf(b, " \x1b[%dm%s\x1b[0m=%+v", levelColor, k, v)
-	}
-}
-
-func needsQuoting(text string) bool {
-	for _, ch := range text {
-		if !((ch >= 'a' && ch <= 'z') ||
-			(ch >= 'A' && ch <= 'Z') ||
-			(ch >= '0' && ch <= '9') ||
-			ch == '-' || ch == '.') {
-			return false
-		}
-	}
-	return true
-}
-
-func (f *TextFormatter) appendKeyValue(b *bytes.Buffer, key string, value interface{}) {
-
-	b.WriteString(key)
-	b.WriteByte('=')
-
-	switch value := value.(type) {
-	case string:
-		if needsQuoting(value) {
-			b.WriteString(value)
-		} else {
-			fmt.Fprintf(b, "%q", value)
-		}
-	case error:
-		errmsg := value.Error()
-		if needsQuoting(errmsg) {
-			b.WriteString(errmsg)
-		} else {
-			fmt.Fprintf(b, "%q", value)
-		}
-	default:
-		fmt.Fprint(b, value)
-	}
-
-	b.WriteByte(' ')
-}

Godeps/_workspace/src/github.com/Sirupsen/logrus/writer.go

@@ -1,31 +0,0 @@
-package logrus
-
-import (
-	"bufio"
-	"io"
-	"runtime"
-)
-
-func (logger *Logger) Writer() *io.PipeWriter {
-	reader, writer := io.Pipe()
-
-	go logger.writerScanner(reader)
-	runtime.SetFinalizer(writer, writerFinalizer)
-
-	return writer
-}
-
-func (logger *Logger) writerScanner(reader *io.PipeReader) {
-	scanner := bufio.NewScanner(reader)
-	for scanner.Scan() {
-		logger.Print(scanner.Text())
-	}
-	if err := scanner.Err(); err != nil {
-		logger.Errorf("Error while reading from Writer: %s", err)
-	}
-	reader.Close()
-}
-
-func writerFinalizer(writer *io.PipeWriter) {
-	writer.Close()
-}

Godeps/_workspace/src/github.com/codegangsta/cli/.travis.yml

@@ -1,19 +0,0 @@
-language: go
-sudo: false
-
-go:
-- 1.0.3
-- 1.1.2
-- 1.2.2
-- 1.3.3
-- 1.4.2
-- 1.5.1
-- tip
-
-matrix:
-  allow_failures:
-    - go: tip
-
-script:
-- go vet ./...
-- go test -v ./...

Godeps/_workspace/src/github.com/codegangsta/cli/LICENSE

@@ -1,21 +0,0 @@
-Copyright (C) 2013 Jeremy Saenz
-All Rights Reserved.
-
-MIT LICENSE
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Godeps/_workspace/src/github.com/codegangsta/cli/README.md

@@ -1,341 +0,0 @@
-[![Coverage](http://gocover.io/_badge/github.com/codegangsta/cli?0)](http://gocover.io/github.com/codegangsta/cli)
-[![Build Status](https://travis-ci.org/codegangsta/cli.png?branch=master)](https://travis-ci.org/codegangsta/cli)
-[![GoDoc](https://godoc.org/github.com/codegangsta/cli?status.svg)](https://godoc.org/github.com/codegangsta/cli)
-
-# cli.go
-`cli.go` is simple, fast, and fun package for building command line apps in Go. The goal is to enable developers to write fast and distributable command line applications in an expressive way.
-
-## Overview
-Command line apps are usually so tiny that there is absolutely no reason why your code should *not* be self-documenting. Things like generating help text and parsing command flags/options should not hinder productivity when writing a command line app.
-
-**This is where `cli.go` comes into play.** `cli.go` makes command line programming fun, organized, and expressive!
-
-## Installation
-Make sure you have a working Go environment (go 1.1+ is *required*). [See the install instructions](http://golang.org/doc/install.html).
-
-To install `cli.go`, simply run:
-```
-$ go get github.com/codegangsta/cli
-```
-
-Make sure your `PATH` includes to the `$GOPATH/bin` directory so your commands can be easily used:
-```
-export PATH=$PATH:$GOPATH/bin
-```
-
-## Getting Started
-One of the philosophies behind `cli.go` is that an API should be playful and full of discovery. So a `cli.go` app can be as little as one line of code in `main()`. 
-
-``` go
-package main
-
-import (
-  "os"
-  "github.com/codegangsta/cli"
-)
-
-func main() {
-  cli.NewApp().Run(os.Args)
-}
-```
-
-This app will run and show help text, but is not very useful. Let's give an action to execute and some help documentation:
-
-``` go
-package main
-
-import (
-  "os"
-  "github.com/codegangsta/cli"
-)
-
-func main() {
-  app := cli.NewApp()
-  app.Name = "boom"
-  app.Usage = "make an explosive entrance"
-  app.Action = func(c *cli.Context) {
-    println("boom! I say!")
-  }
-  
-  app.Run(os.Args)
-}
-```
-
-Running this already gives you a ton of functionality, plus support for things like subcommands and flags, which are covered below.
-
-## Example
-
-Being a programmer can be a lonely job. Thankfully by the power of automation that is not the case! Let's create a greeter app to fend off our demons of loneliness!
-
-Start by creating a directory named `greet`, and within it, add a file, `greet.go` with the following code in it:
-
-``` go
-package main
-
-import (
-  "os"
-  "github.com/codegangsta/cli"
-)
-
-func main() {
-  app := cli.NewApp()
-  app.Name = "greet"
-  app.Usage = "fight the loneliness!"
-  app.Action = func(c *cli.Context) {
-    println("Hello friend!")
-  }
-
-  app.Run(os.Args)
-}
-```
-
-Install our command to the `$GOPATH/bin` directory:
-
-```
-$ go install
-```
-
-Finally run our new command:
-
-```
-$ greet
-Hello friend!
-```
-
-`cli.go` also generates neat help text:
-
-```
-$ greet help
-NAME:
-    greet - fight the loneliness!
-
-USAGE:
-    greet [global options] command [command options] [arguments...]
-
-VERSION:
-    0.0.0
-
-COMMANDS:
-    help, h  Shows a list of commands or help for one command
-
-GLOBAL OPTIONS
-    --version	Shows version information
-```
-
-### Arguments
-You can lookup arguments by calling the `Args` function on `cli.Context`.
-
-``` go
-...
-app.Action = func(c *cli.Context) {
-  println("Hello", c.Args()[0])
-}
-...
-```
-
-### Flags
-Setting and querying flags is simple.
-``` go
-...
-app.Flags = []cli.Flag {
-  cli.StringFlag{
-    Name: "lang",
-    Value: "english",
-    Usage: "language for the greeting",
-  },
-}
-app.Action = func(c *cli.Context) {
-  name := "someone"
-  if len(c.Args()) > 0 {
-    name = c.Args()[0]
-  }
-  if c.String("lang") == "spanish" {
-    println("Hola", name)
-  } else {
-    println("Hello", name)
-  }
-}
-...
-```
-
-You can also set a destination variable for a flag, to which the content will be scanned.
-``` go
-...
-var language string
-app.Flags = []cli.Flag {
-  cli.StringFlag{
-    Name:        "lang",
-    Value:       "english",
-    Usage:       "language for the greeting",
-    Destination: &language,
-  },
-}
-app.Action = func(c *cli.Context) {
-  name := "someone"
-  if len(c.Args()) > 0 {
-    name = c.Args()[0]
-  }
-  if language == "spanish" {
-    println("Hola", name)
-  } else {
-    println("Hello", name)
-  }
-}
-...
-```
-
-See full list of flags at http://godoc.org/github.com/codegangsta/cli
-
-#### Alternate Names
-
-You can set alternate (or short) names for flags by providing a comma-delimited list for the `Name`. e.g.
-
-``` go
-app.Flags = []cli.Flag {
-  cli.StringFlag{
-    Name: "lang, l",
-    Value: "english",
-    Usage: "language for the greeting",
-  },
-}
-```
-
-That flag can then be set with `--lang spanish` or `-l spanish`. Note that giving two different forms of the same flag in the same command invocation is an error.
-
-#### Values from the Environment
-
-You can also have the default value set from the environment via `EnvVar`.  e.g.
-
-``` go
-app.Flags = []cli.Flag {
-  cli.StringFlag{
-    Name: "lang, l",
-    Value: "english",
-    Usage: "language for the greeting",
-    EnvVar: "APP_LANG",
-  },
-}
-```
-
-The `EnvVar` may also be given as a comma-delimited "cascade", where the first environment variable that resolves is used as the default.
-
-``` go
-app.Flags = []cli.Flag {
-  cli.StringFlag{
-    Name: "lang, l",
-    Value: "english",
-    Usage: "language for the greeting",
-    EnvVar: "LEGACY_COMPAT_LANG,APP_LANG,LANG",
-  },
-}
-```
-
-### Subcommands
-
-Subcommands can be defined for a more git-like command line app.
-```go
-...
-app.Commands = []cli.Command{
-  {
-    Name:      "add",
-    Aliases:     []string{"a"},
-    Usage:     "add a task to the list",
-    Action: func(c *cli.Context) {
-      println("added task: ", c.Args().First())
-    },
-  },
-  {
-    Name:      "complete",
-    Aliases:     []string{"c"},
-    Usage:     "complete a task on the list",
-    Action: func(c *cli.Context) {
-      println("completed task: ", c.Args().First())
-    },
-  },
-  {
-    Name:      "template",
-    Aliases:     []string{"r"},
-    Usage:     "options for task templates",
-    Subcommands: []cli.Command{
-      {
-        Name:  "add",
-        Usage: "add a new template",
-        Action: func(c *cli.Context) {
-            println("new task template: ", c.Args().First())
-        },
-      },
-      {
-        Name:  "remove",
-        Usage: "remove an existing template",
-        Action: func(c *cli.Context) {
-          println("removed task template: ", c.Args().First())
-        },
-      },
-    },
-  },
-}
-...
-```
-
-### Bash Completion
-
-You can enable completion commands by setting the `EnableBashCompletion`
-flag on the `App` object.  By default, this setting will only auto-complete to
-show an app's subcommands, but you can write your own completion methods for
-the App or its subcommands.
-```go
-...
-var tasks = []string{"cook", "clean", "laundry", "eat", "sleep", "code"}
-app := cli.NewApp()
-app.EnableBashCompletion = true
-app.Commands = []cli.Command{
-  {
-    Name:  "complete",
-    Aliases: []string{"c"},
-    Usage: "complete a task on the list",
-    Action: func(c *cli.Context) {
-       println("completed task: ", c.Args().First())
-    },
-    BashComplete: func(c *cli.Context) {
-      // This will complete if no args are passed
-      if len(c.Args()) > 0 {
-        return
-      }
-      for _, t := range tasks {
-        fmt.Println(t)
-      }
-    },
-  }
-}
-...
-```
-
-#### To Enable
-
-Source the `autocomplete/bash_autocomplete` file in your `.bashrc` file while
-setting the `PROG` variable to the name of your program:
-
-`PROG=myprogram source /.../cli/autocomplete/bash_autocomplete`
-
-#### To Distribute
-
-Copy `autocomplete/bash_autocomplete` into `/etc/bash_completion.d/` and rename
-it to the name of the program you wish to add autocomplete support for (or
-automatically install it there if you are distributing a package). Don't forget
-to source the file to make it active in the current shell.
-
-```
-   sudo cp src/bash_autocomplete /etc/bash_completion.d/<myprogram>
-   source /etc/bash_completion.d/<myprogram>
-```
-
-Alternatively, you can just document that users should source the generic
-`autocomplete/bash_autocomplete` in their bash configuration with `$PROG` set
-to the name of their program (as above).
-
-## Contribution Guidelines
-Feel free to put up a pull request to fix a bug or maybe add a feature. I will give it a code review and make sure that it does not break backwards compatibility. If I or any other collaborators agree that it is in line with the vision of the project, we will work with you to get the code into a mergeable state and merge it into the master branch.
-
-If you have contributed something significant to the project, I will most likely add you as a collaborator. As a collaborator you are given the ability to merge others pull requests. It is very important that new code does not break existing code, so be careful about what code you do choose to merge. If you have any questions feel free to link @codegangsta to the issue in question and we can review it together.
-
-If you feel like you have contributed to the project but have not yet been added as a collaborator, I probably forgot to add you. Hit @codegangsta up over email and we will get it figured out.

Godeps/_workspace/src/github.com/codegangsta/cli/app.go

@@ -1,334 +0,0 @@
-package cli
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path"
-	"time"
-)
-
-// App is the main structure of a cli application. It is recomended that
-// an app be created with the cli.NewApp() function
-type App struct {
-	// The name of the program. Defaults to path.Base(os.Args[0])
-	Name string
-	// Full name of command for help, defaults to Name
-	HelpName string
-	// Description of the program.
-	Usage string
-	// Description of the program argument format.
-	ArgsUsage string
-	// Version of the program
-	Version string
-	// List of commands to execute
-	Commands []Command
-	// List of flags to parse
-	Flags []Flag
-	// Boolean to enable bash completion commands
-	EnableBashCompletion bool
-	// Boolean to hide built-in help command
-	HideHelp bool
-	// Boolean to hide built-in version flag
-	HideVersion bool
-	// An action to execute when the bash-completion flag is set
-	BashComplete func(context *Context)
-	// An action to execute before any subcommands are run, but after the context is ready
-	// If a non-nil error is returned, no subcommands are run
-	Before func(context *Context) error
-	// An action to execute after any subcommands are run, but after the subcommand has finished
-	// It is run even if Action() panics
-	After func(context *Context) error
-	// The action to execute when no subcommands are specified
-	Action func(context *Context)
-	// Execute this function if the proper command cannot be found
-	CommandNotFound func(context *Context, command string)
-	// Compilation date
-	Compiled time.Time
-	// List of all authors who contributed
-	Authors []Author
-	// Copyright of the binary if any
-	Copyright string
-	// Name of Author (Note: Use App.Authors, this is deprecated)
-	Author string
-	// Email of Author (Note: Use App.Authors, this is deprecated)
-	Email string
-	// Writer writer to write output to
-	Writer io.Writer
-}
-
-// Tries to find out when this binary was compiled.
-// Returns the current time if it fails to find it.
-func compileTime() time.Time {
-	info, err := os.Stat(os.Args[0])
-	if err != nil {
-		return time.Now()
-	}
-	return info.ModTime()
-}
-
-// Creates a new cli Application with some reasonable defaults for Name, Usage, Version and Action.
-func NewApp() *App {
-	return &App{
-		Name:         path.Base(os.Args[0]),
-		HelpName:     path.Base(os.Args[0]),
-		Usage:        "A new cli application",
-		Version:      "0.0.0",
-		BashComplete: DefaultAppComplete,
-		Action:       helpCommand.Action,
-		Compiled:     compileTime(),
-		Writer:       os.Stdout,
-	}
-}
-
-// Entry point to the cli app. Parses the arguments slice and routes to the proper flag/args combination
-func (a *App) Run(arguments []string) (err error) {
-	if a.Author != "" || a.Email != "" {
-		a.Authors = append(a.Authors, Author{Name: a.Author, Email: a.Email})
-	}
-
-	newCmds := []Command{}
-	for _, c := range a.Commands {
-		if c.HelpName == "" {
-			c.HelpName = fmt.Sprintf("%s %s", a.HelpName, c.Name)
-		}
-		newCmds = append(newCmds, c)
-	}
-	a.Commands = newCmds
-
-	// append help to commands
-	if a.Command(helpCommand.Name) == nil && !a.HideHelp {
-		a.Commands = append(a.Commands, helpCommand)
-		if (HelpFlag != BoolFlag{}) {
-			a.appendFlag(HelpFlag)
-		}
-	}
-
-	//append version/help flags
-	if a.EnableBashCompletion {
-		a.appendFlag(BashCompletionFlag)
-	}
-
-	if !a.HideVersion {
-		a.appendFlag(VersionFlag)
-	}
-
-	// parse flags
-	set := flagSet(a.Name, a.Flags)
-	set.SetOutput(ioutil.Discard)
-	err = set.Parse(arguments[1:])
-	nerr := normalizeFlags(a.Flags, set)
-	if nerr != nil {
-		fmt.Fprintln(a.Writer, nerr)
-		context := NewContext(a, set, nil)
-		ShowAppHelp(context)
-		return nerr
-	}
-	context := NewContext(a, set, nil)
-
-	if checkCompletions(context) {
-		return nil
-	}
-
-	if err != nil {
-		fmt.Fprintln(a.Writer, "Incorrect Usage.")
-		fmt.Fprintln(a.Writer)
-		ShowAppHelp(context)
-		return err
-	}
-
-	if !a.HideHelp && checkHelp(context) {
-		ShowAppHelp(context)
-		return nil
-	}
-
-	if !a.HideVersion && checkVersion(context) {
-		ShowVersion(context)
-		return nil
-	}
-
-	if a.After != nil {
-		defer func() {
-			afterErr := a.After(context)
-			if afterErr != nil {
-				if err != nil {
-					err = NewMultiError(err, afterErr)
-				} else {
-					err = afterErr
-				}
-			}
-		}()
-	}
-
-	if a.Before != nil {
-		err := a.Before(context)
-		if err != nil {
-			return err
-		}
-	}
-
-	args := context.Args()
-	if args.Present() {
-		name := args.First()
-		c := a.Command(name)
-		if c != nil {
-			return c.Run(context)
-		}
-	}
-
-	// Run default Action
-	a.Action(context)
-	return nil
-}
-
-// Another entry point to the cli app, takes care of passing arguments and error handling
-func (a *App) RunAndExitOnError() {
-	if err := a.Run(os.Args); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}
-
-// Invokes the subcommand given the context, parses ctx.Args() to generate command-specific flags
-func (a *App) RunAsSubcommand(ctx *Context) (err error) {
-	// append help to commands
-	if len(a.Commands) > 0 {
-		if a.Command(helpCommand.Name) == nil && !a.HideHelp {
-			a.Commands = append(a.Commands, helpCommand)
-			if (HelpFlag != BoolFlag{}) {
-				a.appendFlag(HelpFlag)
-			}
-		}
-	}
-
-	newCmds := []Command{}
-	for _, c := range a.Commands {
-		if c.HelpName == "" {
-			c.HelpName = fmt.Sprintf("%s %s", a.HelpName, c.Name)
-		}
-		newCmds = append(newCmds, c)
-	}
-	a.Commands = newCmds
-
-	// append flags
-	if a.EnableBashCompletion {
-		a.appendFlag(BashCompletionFlag)
-	}
-
-	// parse flags
-	set := flagSet(a.Name, a.Flags)
-	set.SetOutput(ioutil.Discard)
-	err = set.Parse(ctx.Args().Tail())
-	nerr := normalizeFlags(a.Flags, set)
-	context := NewContext(a, set, ctx)
-
-	if nerr != nil {
-		fmt.Fprintln(a.Writer, nerr)
-		fmt.Fprintln(a.Writer)
-		if len(a.Commands) > 0 {
-			ShowSubcommandHelp(context)
-		} else {
-			ShowCommandHelp(ctx, context.Args().First())
-		}
-		return nerr
-	}
-
-	if checkCompletions(context) {
-		return nil
-	}
-
-	if err != nil {
-		fmt.Fprintln(a.Writer, "Incorrect Usage.")
-		fmt.Fprintln(a.Writer)
-		ShowSubcommandHelp(context)
-		return err
-	}
-
-	if len(a.Commands) > 0 {
-		if checkSubcommandHelp(context) {
-			return nil
-		}
-	} else {
-		if checkCommandHelp(ctx, context.Args().First()) {
-			return nil
-		}
-	}
-
-	if a.After != nil {
-		defer func() {
-			afterErr := a.After(context)
-			if afterErr != nil {
-				if err != nil {
-					err = NewMultiError(err, afterErr)
-				} else {
-					err = afterErr
-				}
-			}
-		}()
-	}
-
-	if a.Before != nil {
-		err := a.Before(context)
-		if err != nil {
-			return err
-		}
-	}
-
-	args := context.Args()
-	if args.Present() {
-		name := args.First()
-		c := a.Command(name)
-		if c != nil {
-			return c.Run(context)
-		}
-	}
-
-	// Run default Action
-	a.Action(context)
-
-	return nil
-}
-
-// Returns the named command on App. Returns nil if the command does not exist
-func (a *App) Command(name string) *Command {
-	for _, c := range a.Commands {
-		if c.HasName(name) {
-			return &c
-		}
-	}
-
-	return nil
-}
-
-func (a *App) hasFlag(flag Flag) bool {
-	for _, f := range a.Flags {
-		if flag == f {
-			return true
-		}
-	}
-
-	return false
-}
-
-func (a *App) appendFlag(flag Flag) {
-	if !a.hasFlag(flag) {
-		a.Flags = append(a.Flags, flag)
-	}
-}
-
-// Author represents someone who has contributed to a cli project.
-type Author struct {
-	Name  string // The Authors name
-	Email string // The Authors email
-}
-
-// String makes Author comply to the Stringer interface, to allow an easy print in the templating process
-func (a Author) String() string {
-	e := ""
-	if a.Email != "" {
-		e = "<" + a.Email + "> "
-	}
-
-	return fmt.Sprintf("%v %v", a.Name, e)
-}

Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/bash_autocomplete

@@ -1,14 +0,0 @@
-#! /bin/bash
-
-: ${PROG:=$(basename ${BASH_SOURCE})}
-
-_cli_bash_autocomplete() {
-     local cur opts base
-     COMPREPLY=()
-     cur="${COMP_WORDS[COMP_CWORD]}"
-     opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-bash-completion )
-     COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
-     return 0
- }
-  
- complete -F _cli_bash_autocomplete $PROG

Godeps/_workspace/src/github.com/codegangsta/cli/autocomplete/zsh_autocomplete

@@ -1,5 +0,0 @@
-autoload -U compinit && compinit
-autoload -U bashcompinit && bashcompinit
-
-script_dir=$(dirname $0)
-source ${script_dir}/bash_autocomplete

Godeps/_workspace/src/github.com/codegangsta/cli/cli.go

@@ -1,40 +0,0 @@
-// Package cli provides a minimal framework for creating and organizing command line
-// Go applications. cli is designed to be easy to understand and write, the most simple
-// cli application can be written as follows:
-//   func main() {
-//     cli.NewApp().Run(os.Args)
-//   }
-//
-// Of course this application does not do much, so let's make this an actual application:
-//   func main() {
-//     app := cli.NewApp()
-//     app.Name = "greet"
-//     app.Usage = "say a greeting"
-//     app.Action = func(c *cli.Context) {
-//       println("Greetings")
-//     }
-//
-//     app.Run(os.Args)
-//   }
-package cli
-
-import (
-	"strings"
-)
-
-type MultiError struct {
-	Errors []error
-}
-
-func NewMultiError(err ...error) MultiError {
-	return MultiError{Errors: err}
-}
-
-func (m MultiError) Error() string {
-	errs := make([]string, len(m.Errors))
-	for i, err := range m.Errors {
-		errs[i] = err.Error()
-	}
-
-	return strings.Join(errs, "\n")
-}

Godeps/_workspace/src/github.com/codegangsta/cli/command.go

@@ -1,216 +0,0 @@
-package cli
-
-import (
-	"fmt"
-	"io/ioutil"
-	"strings"
-)
-
-// Command is a subcommand for a cli.App.
-type Command struct {
-	// The name of the command
-	Name string
-	// short name of the command. Typically one character (deprecated, use `Aliases`)
-	ShortName string
-	// A list of aliases for the command
-	Aliases []string
-	// A short description of the usage of this command
-	Usage string
-	// A longer explanation of how the command works
-	Description string
-	// A short description of the arguments of this command
-	ArgsUsage string
-	// The function to call when checking for bash command completions
-	BashComplete func(context *Context)
-	// An action to execute before any sub-subcommands are run, but after the context is ready
-	// If a non-nil error is returned, no sub-subcommands are run
-	Before func(context *Context) error
-	// An action to execute after any subcommands are run, but after the subcommand has finished
-	// It is run even if Action() panics
-	After func(context *Context) error
-	// The function to call when this command is invoked
-	Action func(context *Context)
-	// List of child commands
-	Subcommands []Command
-	// List of flags to parse
-	Flags []Flag
-	// Treat all flags as normal arguments if true
-	SkipFlagParsing bool
-	// Boolean to hide built-in help command
-	HideHelp bool
-
-	// Full name of command for help, defaults to full command name, including parent commands.
-	HelpName        string
-	commandNamePath []string
-}
-
-// Returns the full name of the command.
-// For subcommands this ensures that parent commands are part of the command path
-func (c Command) FullName() string {
-	if c.commandNamePath == nil {
-		return c.Name
-	}
-	return strings.Join(c.commandNamePath, " ")
-}
-
-// Invokes the command given the context, parses ctx.Args() to generate command-specific flags
-func (c Command) Run(ctx *Context) error {
-	if len(c.Subcommands) > 0 || c.Before != nil || c.After != nil {
-		return c.startApp(ctx)
-	}
-
-	if !c.HideHelp && (HelpFlag != BoolFlag{}) {
-		// append help to flags
-		c.Flags = append(
-			c.Flags,
-			HelpFlag,
-		)
-	}
-
-	if ctx.App.EnableBashCompletion {
-		c.Flags = append(c.Flags, BashCompletionFlag)
-	}
-
-	set := flagSet(c.Name, c.Flags)
-	set.SetOutput(ioutil.Discard)
-
-	var err error
-	if !c.SkipFlagParsing {
-		firstFlagIndex := -1
-		terminatorIndex := -1
-		for index, arg := range ctx.Args() {
-			if arg == "--" {
-				terminatorIndex = index
-				break
-			} else if strings.HasPrefix(arg, "-") && firstFlagIndex == -1 {
-				firstFlagIndex = index
-			}
-		}
-
-		if firstFlagIndex > -1 {
-			args := ctx.Args()
-			regularArgs := make([]string, len(args[1:firstFlagIndex]))
-			copy(regularArgs, args[1:firstFlagIndex])
-
-			var flagArgs []string
-			if terminatorIndex > -1 {
-				flagArgs = args[firstFlagIndex:terminatorIndex]
-				regularArgs = append(regularArgs, args[terminatorIndex:]...)
-			} else {
-				flagArgs = args[firstFlagIndex:]
-			}
-
-			err = set.Parse(append(flagArgs, regularArgs...))
-		} else {
-			err = set.Parse(ctx.Args().Tail())
-		}
-	} else {
-		if c.SkipFlagParsing {
-			err = set.Parse(append([]string{"--"}, ctx.Args().Tail()...))
-		}
-	}
-
-	if err != nil {
-		fmt.Fprintln(ctx.App.Writer, "Incorrect Usage.")
-		fmt.Fprintln(ctx.App.Writer)
-		ShowCommandHelp(ctx, c.Name)
-		return err
-	}
-
-	nerr := normalizeFlags(c.Flags, set)
-	if nerr != nil {
-		fmt.Fprintln(ctx.App.Writer, nerr)
-		fmt.Fprintln(ctx.App.Writer)
-		ShowCommandHelp(ctx, c.Name)
-		return nerr
-	}
-	context := NewContext(ctx.App, set, ctx)
-
-	if checkCommandCompletions(context, c.Name) {
-		return nil
-	}
-
-	if checkCommandHelp(context, c.Name) {
-		return nil
-	}
-	context.Command = c
-	c.Action(context)
-	return nil
-}
-
-func (c Command) Names() []string {
-	names := []string{c.Name}
-
-	if c.ShortName != "" {
-		names = append(names, c.ShortName)
-	}
-
-	return append(names, c.Aliases...)
-}
-
-// Returns true if Command.Name or Command.ShortName matches given name
-func (c Command) HasName(name string) bool {
-	for _, n := range c.Names() {
-		if n == name {
-			return true
-		}
-	}
-	return false
-}
-
-func (c Command) startApp(ctx *Context) error {
-	app := NewApp()
-
-	// set the name and usage
-	app.Name = fmt.Sprintf("%s %s", ctx.App.Name, c.Name)
-	if c.HelpName == "" {
-		app.HelpName = c.HelpName
-	} else {
-		app.HelpName = fmt.Sprintf("%s %s", ctx.App.Name, c.Name)
-	}
-
-	if c.Description != "" {
-		app.Usage = c.Description
-	} else {
-		app.Usage = c.Usage
-	}
-
-	// set CommandNotFound
-	app.CommandNotFound = ctx.App.CommandNotFound
-
-	// set the flags and commands
-	app.Commands = c.Subcommands
-	app.Flags = c.Flags
-	app.HideHelp = c.HideHelp
-
-	app.Version = ctx.App.Version
-	app.HideVersion = ctx.App.HideVersion
-	app.Compiled = ctx.App.Compiled
-	app.Author = ctx.App.Author
-	app.Email = ctx.App.Email
-	app.Writer = ctx.App.Writer
-
-	// bash completion
-	app.EnableBashCompletion = ctx.App.EnableBashCompletion
-	if c.BashComplete != nil {
-		app.BashComplete = c.BashComplete
-	}
-
-	// set the actions
-	app.Before = c.Before
-	app.After = c.After
-	if c.Action != nil {
-		app.Action = c.Action
-	} else {
-		app.Action = helpSubcommand.Action
-	}
-
-	var newCmds []Command
-	for _, cc := range app.Commands {
-		cc.commandNamePath = []string{c.Name, cc.Name}
-		newCmds = append(newCmds, cc)
-	}
-	app.Commands = newCmds
-
-	return app.RunAsSubcommand(ctx)
-}

Godeps/_workspace/src/github.com/codegangsta/cli/context.go

@@ -1,388 +0,0 @@
-package cli
-
-import (
-	"errors"
-	"flag"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// Context is a type that is passed through to
-// each Handler action in a cli application. Context
-// can be used to retrieve context-specific Args and
-// parsed command-line options.
-type Context struct {
-	App            *App
-	Command        Command
-	flagSet        *flag.FlagSet
-	setFlags       map[string]bool
-	globalSetFlags map[string]bool
-	parentContext  *Context
-}
-
-// Creates a new context. For use in when invoking an App or Command action.
-func NewContext(app *App, set *flag.FlagSet, parentCtx *Context) *Context {
-	return &Context{App: app, flagSet: set, parentContext: parentCtx}
-}
-
-// Looks up the value of a local int flag, returns 0 if no int flag exists
-func (c *Context) Int(name string) int {
-	return lookupInt(name, c.flagSet)
-}
-
-// Looks up the value of a local time.Duration flag, returns 0 if no time.Duration flag exists
-func (c *Context) Duration(name string) time.Duration {
-	return lookupDuration(name, c.flagSet)
-}
-
-// Looks up the value of a local float64 flag, returns 0 if no float64 flag exists
-func (c *Context) Float64(name string) float64 {
-	return lookupFloat64(name, c.flagSet)
-}
-
-// Looks up the value of a local bool flag, returns false if no bool flag exists
-func (c *Context) Bool(name string) bool {
-	return lookupBool(name, c.flagSet)
-}
-
-// Looks up the value of a local boolT flag, returns false if no bool flag exists
-func (c *Context) BoolT(name string) bool {
-	return lookupBoolT(name, c.flagSet)
-}
-
-// Looks up the value of a local string flag, returns "" if no string flag exists
-func (c *Context) String(name string) string {
-	return lookupString(name, c.flagSet)
-}
-
-// Looks up the value of a local string slice flag, returns nil if no string slice flag exists
-func (c *Context) StringSlice(name string) []string {
-	return lookupStringSlice(name, c.flagSet)
-}
-
-// Looks up the value of a local int slice flag, returns nil if no int slice flag exists
-func (c *Context) IntSlice(name string) []int {
-	return lookupIntSlice(name, c.flagSet)
-}
-
-// Looks up the value of a local generic flag, returns nil if no generic flag exists
-func (c *Context) Generic(name string) interface{} {
-	return lookupGeneric(name, c.flagSet)
-}
-
-// Looks up the value of a global int flag, returns 0 if no int flag exists
-func (c *Context) GlobalInt(name string) int {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupInt(name, fs)
-	}
-	return 0
-}
-
-// Looks up the value of a global time.Duration flag, returns 0 if no time.Duration flag exists
-func (c *Context) GlobalDuration(name string) time.Duration {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupDuration(name, fs)
-	}
-	return 0
-}
-
-// Looks up the value of a global bool flag, returns false if no bool flag exists
-func (c *Context) GlobalBool(name string) bool {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupBool(name, fs)
-	}
-	return false
-}
-
-// Looks up the value of a global string flag, returns "" if no string flag exists
-func (c *Context) GlobalString(name string) string {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupString(name, fs)
-	}
-	return ""
-}
-
-// Looks up the value of a global string slice flag, returns nil if no string slice flag exists
-func (c *Context) GlobalStringSlice(name string) []string {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupStringSlice(name, fs)
-	}
-	return nil
-}
-
-// Looks up the value of a global int slice flag, returns nil if no int slice flag exists
-func (c *Context) GlobalIntSlice(name string) []int {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupIntSlice(name, fs)
-	}
-	return nil
-}
-
-// Looks up the value of a global generic flag, returns nil if no generic flag exists
-func (c *Context) GlobalGeneric(name string) interface{} {
-	if fs := lookupGlobalFlagSet(name, c); fs != nil {
-		return lookupGeneric(name, fs)
-	}
-	return nil
-}
-
-// Returns the number of flags set
-func (c *Context) NumFlags() int {
-	return c.flagSet.NFlag()
-}
-
-// Determines if the flag was actually set
-func (c *Context) IsSet(name string) bool {
-	if c.setFlags == nil {
-		c.setFlags = make(map[string]bool)
-		c.flagSet.Visit(func(f *flag.Flag) {
-			c.setFlags[f.Name] = true
-		})
-	}
-	return c.setFlags[name] == true
-}
-
-// Determines if the global flag was actually set
-func (c *Context) GlobalIsSet(name string) bool {
-	if c.globalSetFlags == nil {
-		c.globalSetFlags = make(map[string]bool)
-		ctx := c
-		if ctx.parentContext != nil {
-			ctx = ctx.parentContext
-		}
-		for ; ctx != nil && c.globalSetFlags[name] == false; ctx = ctx.parentContext {
-			ctx.flagSet.Visit(func(f *flag.Flag) {
-				c.globalSetFlags[f.Name] = true
-			})
-		}
-	}
-	return c.globalSetFlags[name]
-}
-
-// Returns a slice of flag names used in this context.
-func (c *Context) FlagNames() (names []string) {
-	for _, flag := range c.Command.Flags {
-		name := strings.Split(flag.GetName(), ",")[0]
-		if name == "help" {
-			continue
-		}
-		names = append(names, name)
-	}
-	return
-}
-
-// Returns a slice of global flag names used by the app.
-func (c *Context) GlobalFlagNames() (names []string) {
-	for _, flag := range c.App.Flags {
-		name := strings.Split(flag.GetName(), ",")[0]
-		if name == "help" || name == "version" {
-			continue
-		}
-		names = append(names, name)
-	}
-	return
-}
-
-// Returns the parent context, if any
-func (c *Context) Parent() *Context {
-	return c.parentContext
-}
-
-type Args []string
-
-// Returns the command line arguments associated with the context.
-func (c *Context) Args() Args {
-	args := Args(c.flagSet.Args())
-	return args
-}
-
-// Returns the nth argument, or else a blank string
-func (a Args) Get(n int) string {
-	if len(a) > n {
-		return a[n]
-	}
-	return ""
-}
-
-// Returns the first argument, or else a blank string
-func (a Args) First() string {
-	return a.Get(0)
-}
-
-// Return the rest of the arguments (not the first one)
-// or else an empty string slice
-func (a Args) Tail() []string {
-	if len(a) >= 2 {
-		return []string(a)[1:]
-	}
-	return []string{}
-}
-
-// Checks if there are any arguments present
-func (a Args) Present() bool {
-	return len(a) != 0
-}
-
-// Swaps arguments at the given indexes
-func (a Args) Swap(from, to int) error {
-	if from >= len(a) || to >= len(a) {
-		return errors.New("index out of range")
-	}
-	a[from], a[to] = a[to], a[from]
-	return nil
-}
-
-func lookupGlobalFlagSet(name string, ctx *Context) *flag.FlagSet {
-	if ctx.parentContext != nil {
-		ctx = ctx.parentContext
-	}
-	for ; ctx != nil; ctx = ctx.parentContext {
-		if f := ctx.flagSet.Lookup(name); f != nil {
-			return ctx.flagSet
-		}
-	}
-	return nil
-}
-
-func lookupInt(name string, set *flag.FlagSet) int {
-	f := set.Lookup(name)
-	if f != nil {
-		val, err := strconv.Atoi(f.Value.String())
-		if err != nil {
-			return 0
-		}
-		return val
-	}
-
-	return 0
-}
-
-func lookupDuration(name string, set *flag.FlagSet) time.Duration {
-	f := set.Lookup(name)
-	if f != nil {
-		val, err := time.ParseDuration(f.Value.String())
-		if err == nil {
-			return val
-		}
-	}
-
-	return 0
-}
-
-func lookupFloat64(name string, set *flag.FlagSet) float64 {
-	f := set.Lookup(name)
-	if f != nil {
-		val, err := strconv.ParseFloat(f.Value.String(), 64)
-		if err != nil {
-			return 0
-		}
-		return val
-	}
-
-	return 0
-}
-
-func lookupString(name string, set *flag.FlagSet) string {
-	f := set.Lookup(name)
-	if f != nil {
-		return f.Value.String()
-	}
-
-	return ""
-}
-
-func lookupStringSlice(name string, set *flag.FlagSet) []string {
-	f := set.Lookup(name)
-	if f != nil {
-		return (f.Value.(*StringSlice)).Value()
-
-	}
-
-	return nil
-}
-
-func lookupIntSlice(name string, set *flag.FlagSet) []int {
-	f := set.Lookup(name)
-	if f != nil {
-		return (f.Value.(*IntSlice)).Value()
-
-	}
-
-	return nil
-}
-
-func lookupGeneric(name string, set *flag.FlagSet) interface{} {
-	f := set.Lookup(name)
-	if f != nil {
-		return f.Value
-	}
-	return nil
-}
-
-func lookupBool(name string, set *flag.FlagSet) bool {
-	f := set.Lookup(name)
-	if f != nil {
-		val, err := strconv.ParseBool(f.Value.String())
-		if err != nil {
-			return false
-		}
-		return val
-	}
-
-	return false
-}
-
-func lookupBoolT(name string, set *flag.FlagSet) bool {
-	f := set.Lookup(name)
-	if f != nil {
-		val, err := strconv.ParseBool(f.Value.String())
-		if err != nil {
-			return true
-		}
-		return val
-	}
-
-	return false
-}
-
-func copyFlag(name string, ff *flag.Flag, set *flag.FlagSet) {
-	switch ff.Value.(type) {
-	case *StringSlice:
-	default:
-		set.Set(name, ff.Value.String())
-	}
-}
-
-func normalizeFlags(flags []Flag, set *flag.FlagSet) error {
-	visited := make(map[string]bool)
-	set.Visit(func(f *flag.Flag) {
-		visited[f.Name] = true
-	})
-	for _, f := range flags {
-		parts := strings.Split(f.GetName(), ",")
-		if len(parts) == 1 {
-			continue
-		}
-		var ff *flag.Flag
-		for _, name := range parts {
-			name = strings.Trim(name, " ")
-			if visited[name] {
-				if ff != nil {
-					return errors.New("Cannot use two forms of the same flag: " + name + " " + ff.Name)
-				}
-				ff = set.Lookup(name)
-			}
-		}
-		if ff == nil {
-			continue
-		}
-		for _, name := range parts {
-			name = strings.Trim(name, " ")
-			if !visited[name] {
-				copyFlag(name, ff, set)
-			}
-		}
-	}
-	return nil
-}

Godeps/_workspace/src/github.com/codegangsta/cli/flag.go

@@ -1,527 +0,0 @@
-package cli
-
-import (
-	"flag"
-	"fmt"
-	"os"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// This flag enables bash-completion for all commands and subcommands
-var BashCompletionFlag = BoolFlag{
-	Name: "generate-bash-completion",
-}
-
-// This flag prints the version for the application
-var VersionFlag = BoolFlag{
-	Name:  "version, v",
-	Usage: "print the version",
-}
-
-// This flag prints the help for all commands and subcommands
-// Set to the zero value (BoolFlag{}) to disable flag -- keeps subcommand
-// unless HideHelp is set to true)
-var HelpFlag = BoolFlag{
-	Name:  "help, h",
-	Usage: "show help",
-}
-
-// Flag is a common interface related to parsing flags in cli.
-// For more advanced flag parsing techniques, it is recomended that
-// this interface be implemented.
-type Flag interface {
-	fmt.Stringer
-	// Apply Flag settings to the given flag set
-	Apply(*flag.FlagSet)
-	GetName() string
-}
-
-func flagSet(name string, flags []Flag) *flag.FlagSet {
-	set := flag.NewFlagSet(name, flag.ContinueOnError)
-
-	for _, f := range flags {
-		f.Apply(set)
-	}
-	return set
-}
-
-func eachName(longName string, fn func(string)) {
-	parts := strings.Split(longName, ",")
-	for _, name := range parts {
-		name = strings.Trim(name, " ")
-		fn(name)
-	}
-}
-
-// Generic is a generic parseable type identified by a specific flag
-type Generic interface {
-	Set(value string) error
-	String() string
-}
-
-// GenericFlag is the flag type for types implementing Generic
-type GenericFlag struct {
-	Name   string
-	Value  Generic
-	Usage  string
-	EnvVar string
-}
-
-// String returns the string representation of the generic flag to display the
-// help text to the user (uses the String() method of the generic flag to show
-// the value)
-func (f GenericFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s%s \"%v\"\t%v", prefixFor(f.Name), f.Name, f.Value, f.Usage))
-}
-
-// Apply takes the flagset and calls Set on the generic flag with the value
-// provided by the user for parsing by the flag
-func (f GenericFlag) Apply(set *flag.FlagSet) {
-	val := f.Value
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				val.Set(envVal)
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		set.Var(f.Value, name, f.Usage)
-	})
-}
-
-func (f GenericFlag) GetName() string {
-	return f.Name
-}
-
-// StringSlice is an opaque type for []string to satisfy flag.Value
-type StringSlice []string
-
-// Set appends the string value to the list of values
-func (f *StringSlice) Set(value string) error {
-	*f = append(*f, value)
-	return nil
-}
-
-// String returns a readable representation of this value (for usage defaults)
-func (f *StringSlice) String() string {
-	return fmt.Sprintf("%s", *f)
-}
-
-// Value returns the slice of strings set by this flag
-func (f *StringSlice) Value() []string {
-	return *f
-}
-
-// StringSlice is a string flag that can be specified multiple times on the
-// command-line
-type StringSliceFlag struct {
-	Name   string
-	Value  *StringSlice
-	Usage  string
-	EnvVar string
-}
-
-// String returns the usage
-func (f StringSliceFlag) String() string {
-	firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
-	pref := prefixFor(firstName)
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s [%v]\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
-}
-
-// Apply populates the flag given the flag set and environment
-func (f StringSliceFlag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				newVal := &StringSlice{}
-				for _, s := range strings.Split(envVal, ",") {
-					s = strings.TrimSpace(s)
-					newVal.Set(s)
-				}
-				f.Value = newVal
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Value == nil {
-			f.Value = &StringSlice{}
-		}
-		set.Var(f.Value, name, f.Usage)
-	})
-}
-
-func (f StringSliceFlag) GetName() string {
-	return f.Name
-}
-
-// StringSlice is an opaque type for []int to satisfy flag.Value
-type IntSlice []int
-
-// Set parses the value into an integer and appends it to the list of values
-func (f *IntSlice) Set(value string) error {
-	tmp, err := strconv.Atoi(value)
-	if err != nil {
-		return err
-	} else {
-		*f = append(*f, tmp)
-	}
-	return nil
-}
-
-// String returns a readable representation of this value (for usage defaults)
-func (f *IntSlice) String() string {
-	return fmt.Sprintf("%d", *f)
-}
-
-// Value returns the slice of ints set by this flag
-func (f *IntSlice) Value() []int {
-	return *f
-}
-
-// IntSliceFlag is an int flag that can be specified multiple times on the
-// command-line
-type IntSliceFlag struct {
-	Name   string
-	Value  *IntSlice
-	Usage  string
-	EnvVar string
-}
-
-// String returns the usage
-func (f IntSliceFlag) String() string {
-	firstName := strings.Trim(strings.Split(f.Name, ",")[0], " ")
-	pref := prefixFor(firstName)
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s [%v]\t%v", prefixedNames(f.Name), pref+firstName+" option "+pref+firstName+" option", f.Usage))
-}
-
-// Apply populates the flag given the flag set and environment
-func (f IntSliceFlag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				newVal := &IntSlice{}
-				for _, s := range strings.Split(envVal, ",") {
-					s = strings.TrimSpace(s)
-					err := newVal.Set(s)
-					if err != nil {
-						fmt.Fprintf(os.Stderr, err.Error())
-					}
-				}
-				f.Value = newVal
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Value == nil {
-			f.Value = &IntSlice{}
-		}
-		set.Var(f.Value, name, f.Usage)
-	})
-}
-
-func (f IntSliceFlag) GetName() string {
-	return f.Name
-}
-
-// BoolFlag is a switch that defaults to false
-type BoolFlag struct {
-	Name        string
-	Usage       string
-	EnvVar      string
-	Destination *bool
-}
-
-// String returns a readable representation of this value (for usage defaults)
-func (f BoolFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
-}
-
-// Apply populates the flag given the flag set and environment
-func (f BoolFlag) Apply(set *flag.FlagSet) {
-	val := false
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValBool, err := strconv.ParseBool(envVal)
-				if err == nil {
-					val = envValBool
-				}
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.BoolVar(f.Destination, name, val, f.Usage)
-			return
-		}
-		set.Bool(name, val, f.Usage)
-	})
-}
-
-func (f BoolFlag) GetName() string {
-	return f.Name
-}
-
-// BoolTFlag this represents a boolean flag that is true by default, but can
-// still be set to false by --some-flag=false
-type BoolTFlag struct {
-	Name        string
-	Usage       string
-	EnvVar      string
-	Destination *bool
-}
-
-// String returns a readable representation of this value (for usage defaults)
-func (f BoolTFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s\t%v", prefixedNames(f.Name), f.Usage))
-}
-
-// Apply populates the flag given the flag set and environment
-func (f BoolTFlag) Apply(set *flag.FlagSet) {
-	val := true
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValBool, err := strconv.ParseBool(envVal)
-				if err == nil {
-					val = envValBool
-					break
-				}
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.BoolVar(f.Destination, name, val, f.Usage)
-			return
-		}
-		set.Bool(name, val, f.Usage)
-	})
-}
-
-func (f BoolTFlag) GetName() string {
-	return f.Name
-}
-
-// StringFlag represents a flag that takes as string value
-type StringFlag struct {
-	Name        string
-	Value       string
-	Usage       string
-	EnvVar      string
-	Destination *string
-}
-
-// String returns the usage
-func (f StringFlag) String() string {
-	var fmtString string
-	fmtString = "%s %v\t%v"
-
-	if len(f.Value) > 0 {
-		fmtString = "%s \"%v\"\t%v"
-	} else {
-		fmtString = "%s %v\t%v"
-	}
-
-	return withEnvHint(f.EnvVar, fmt.Sprintf(fmtString, prefixedNames(f.Name), f.Value, f.Usage))
-}
-
-// Apply populates the flag given the flag set and environment
-func (f StringFlag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				f.Value = envVal
-				break
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.StringVar(f.Destination, name, f.Value, f.Usage)
-			return
-		}
-		set.String(name, f.Value, f.Usage)
-	})
-}
-
-func (f StringFlag) GetName() string {
-	return f.Name
-}
-
-// IntFlag is a flag that takes an integer
-// Errors if the value provided cannot be parsed
-type IntFlag struct {
-	Name        string
-	Value       int
-	Usage       string
-	EnvVar      string
-	Destination *int
-}
-
-// String returns the usage
-func (f IntFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
-}
-
-// Apply populates the flag given the flag set and environment
-func (f IntFlag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValInt, err := strconv.ParseInt(envVal, 0, 64)
-				if err == nil {
-					f.Value = int(envValInt)
-					break
-				}
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.IntVar(f.Destination, name, f.Value, f.Usage)
-			return
-		}
-		set.Int(name, f.Value, f.Usage)
-	})
-}
-
-func (f IntFlag) GetName() string {
-	return f.Name
-}
-
-// DurationFlag is a flag that takes a duration specified in Go's duration
-// format: https://golang.org/pkg/time/#ParseDuration
-type DurationFlag struct {
-	Name        string
-	Value       time.Duration
-	Usage       string
-	EnvVar      string
-	Destination *time.Duration
-}
-
-// String returns a readable representation of this value (for usage defaults)
-func (f DurationFlag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
-}
-
-// Apply populates the flag given the flag set and environment
-func (f DurationFlag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValDuration, err := time.ParseDuration(envVal)
-				if err == nil {
-					f.Value = envValDuration
-					break
-				}
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.DurationVar(f.Destination, name, f.Value, f.Usage)
-			return
-		}
-		set.Duration(name, f.Value, f.Usage)
-	})
-}
-
-func (f DurationFlag) GetName() string {
-	return f.Name
-}
-
-// Float64Flag is a flag that takes an float value
-// Errors if the value provided cannot be parsed
-type Float64Flag struct {
-	Name        string
-	Value       float64
-	Usage       string
-	EnvVar      string
-	Destination *float64
-}
-
-// String returns the usage
-func (f Float64Flag) String() string {
-	return withEnvHint(f.EnvVar, fmt.Sprintf("%s \"%v\"\t%v", prefixedNames(f.Name), f.Value, f.Usage))
-}
-
-// Apply populates the flag given the flag set and environment
-func (f Float64Flag) Apply(set *flag.FlagSet) {
-	if f.EnvVar != "" {
-		for _, envVar := range strings.Split(f.EnvVar, ",") {
-			envVar = strings.TrimSpace(envVar)
-			if envVal := os.Getenv(envVar); envVal != "" {
-				envValFloat, err := strconv.ParseFloat(envVal, 10)
-				if err == nil {
-					f.Value = float64(envValFloat)
-				}
-			}
-		}
-	}
-
-	eachName(f.Name, func(name string) {
-		if f.Destination != nil {
-			set.Float64Var(f.Destination, name, f.Value, f.Usage)
-			return
-		}
-		set.Float64(name, f.Value, f.Usage)
-	})
-}
-
-func (f Float64Flag) GetName() string {
-	return f.Name
-}
-
-func prefixFor(name string) (prefix string) {
-	if len(name) == 1 {
-		prefix = "-"
-	} else {
-		prefix = "--"
-	}
-
-	return
-}
-
-func prefixedNames(fullName string) (prefixed string) {
-	parts := strings.Split(fullName, ",")
-	for i, name := range parts {
-		name = strings.Trim(name, " ")
-		prefixed += prefixFor(name) + name
-		if i < len(parts)-1 {
-			prefixed += ", "
-		}
-	}
-	return
-}
-
-func withEnvHint(envVar, str string) string {
-	envText := ""
-	if envVar != "" {
-		envText = fmt.Sprintf(" [$%s]", strings.Join(strings.Split(envVar, ","), ", $"))
-	}
-	return str + envText
-}

Godeps/_workspace/src/github.com/codegangsta/cli/help.go

@@ -1,246 +0,0 @@
-package cli
-
-import (
-	"fmt"
-	"io"
-	"strings"
-	"text/tabwriter"
-	"text/template"
-)
-
-// The text template for the Default help topic.
-// cli.go uses text/template to render templates. You can
-// render custom help text by setting this variable.
-var AppHelpTemplate = `NAME:
-   {{.Name}} - {{.Usage}}
-
-USAGE:
-   {{.HelpName}} {{if .Flags}}[global options]{{end}}{{if .Commands}} command [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}
-   {{if .Version}}
-VERSION:
-   {{.Version}}
-   {{end}}{{if len .Authors}}
-AUTHOR(S):
-   {{range .Authors}}{{ . }}{{end}}
-   {{end}}{{if .Commands}}
-COMMANDS:
-   {{range .Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
-   {{end}}{{end}}{{if .Flags}}
-GLOBAL OPTIONS:
-   {{range .Flags}}{{.}}
-   {{end}}{{end}}{{if .Copyright }}
-COPYRIGHT:
-   {{.Copyright}}
-   {{end}}
-`
-
-// The text template for the command help topic.
-// cli.go uses text/template to render templates. You can
-// render custom help text by setting this variable.
-var CommandHelpTemplate = `NAME:
-   {{.HelpName}} - {{.Usage}}
-
-USAGE:
-   {{.HelpName}}{{if .Flags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}{{if .Description}}
-
-DESCRIPTION:
-   {{.Description}}{{end}}{{if .Flags}}
-
-OPTIONS:
-   {{range .Flags}}{{.}}
-   {{end}}{{ end }}
-`
-
-// The text template for the subcommand help topic.
-// cli.go uses text/template to render templates. You can
-// render custom help text by setting this variable.
-var SubcommandHelpTemplate = `NAME:
-   {{.HelpName}} - {{.Usage}}
-
-USAGE:
-   {{.HelpName}} command{{if .Flags}} [command options]{{end}} {{if .ArgsUsage}}{{.ArgsUsage}}{{else}}[arguments...]{{end}}
-
-COMMANDS:
-   {{range .Commands}}{{join .Names ", "}}{{ "\t" }}{{.Usage}}
-   {{end}}{{if .Flags}}
-OPTIONS:
-   {{range .Flags}}{{.}}
-   {{end}}{{end}}
-`
-
-var helpCommand = Command{
-	Name:      "help",
-	Aliases:   []string{"h"},
-	Usage:     "Shows a list of commands or help for one command",
-	ArgsUsage: "[command]",
-	Action: func(c *Context) {
-		args := c.Args()
-		if args.Present() {
-			ShowCommandHelp(c, args.First())
-		} else {
-			ShowAppHelp(c)
-		}
-	},
-}
-
-var helpSubcommand = Command{
-	Name:      "help",
-	Aliases:   []string{"h"},
-	Usage:     "Shows a list of commands or help for one command",
-	ArgsUsage: "[command]",
-	Action: func(c *Context) {
-		args := c.Args()
-		if args.Present() {
-			ShowCommandHelp(c, args.First())
-		} else {
-			ShowSubcommandHelp(c)
-		}
-	},
-}
-
-// Prints help for the App or Command
-type helpPrinter func(w io.Writer, templ string, data interface{})
-
-var HelpPrinter helpPrinter = printHelp
-
-// Prints version for the App
-var VersionPrinter = printVersion
-
-func ShowAppHelp(c *Context) {
-	HelpPrinter(c.App.Writer, AppHelpTemplate, c.App)
-}
-
-// Prints the list of subcommands as the default app completion method
-func DefaultAppComplete(c *Context) {
-	for _, command := range c.App.Commands {
-		for _, name := range command.Names() {
-			fmt.Fprintln(c.App.Writer, name)
-		}
-	}
-}
-
-// Prints help for the given command
-func ShowCommandHelp(ctx *Context, command string) {
-	// show the subcommand help for a command with subcommands
-	if command == "" {
-		HelpPrinter(ctx.App.Writer, SubcommandHelpTemplate, ctx.App)
-		return
-	}
-
-	for _, c := range ctx.App.Commands {
-		if c.HasName(command) {
-			HelpPrinter(ctx.App.Writer, CommandHelpTemplate, c)
-			return
-		}
-	}
-
-	if ctx.App.CommandNotFound != nil {
-		ctx.App.CommandNotFound(ctx, command)
-	} else {
-		fmt.Fprintf(ctx.App.Writer, "No help topic for '%v'\n", command)
-	}
-}
-
-// Prints help for the given subcommand
-func ShowSubcommandHelp(c *Context) {
-	ShowCommandHelp(c, c.Command.Name)
-}
-
-// Prints the version number of the App
-func ShowVersion(c *Context) {
-	VersionPrinter(c)
-}
-
-func printVersion(c *Context) {
-	fmt.Fprintf(c.App.Writer, "%v version %v\n", c.App.Name, c.App.Version)
-}
-
-// Prints the lists of commands within a given context
-func ShowCompletions(c *Context) {
-	a := c.App
-	if a != nil && a.BashComplete != nil {
-		a.BashComplete(c)
-	}
-}
-
-// Prints the custom completions for a given command
-func ShowCommandCompletions(ctx *Context, command string) {
-	c := ctx.App.Command(command)
-	if c != nil && c.BashComplete != nil {
-		c.BashComplete(ctx)
-	}
-}
-
-func printHelp(out io.Writer, templ string, data interface{}) {
-	funcMap := template.FuncMap{
-		"join": strings.Join,
-	}
-
-	w := tabwriter.NewWriter(out, 0, 8, 1, '\t', 0)
-	t := template.Must(template.New("help").Funcs(funcMap).Parse(templ))
-	err := t.Execute(w, data)
-	if err != nil {
-		panic(err)
-	}
-	w.Flush()
-}
-
-func checkVersion(c *Context) bool {
-	found := false
-	if VersionFlag.Name != "" {
-		eachName(VersionFlag.Name, func(name string) {
-			if c.GlobalBool(name) || c.Bool(name) {
-				found = true
-			}
-		})
-	}
-	return found
-}
-
-func checkHelp(c *Context) bool {
-	found := false
-	if HelpFlag.Name != "" {
-		eachName(HelpFlag.Name, func(name string) {
-			if c.GlobalBool(name) || c.Bool(name) {
-				found = true
-			}
-		})
-	}
-	return found
-}
-
-func checkCommandHelp(c *Context, name string) bool {
-	if c.Bool("h") || c.Bool("help") {
-		ShowCommandHelp(c, name)
-		return true
-	}
-
-	return false
-}
-
-func checkSubcommandHelp(c *Context) bool {
-	if c.GlobalBool("h") || c.GlobalBool("help") {
-		ShowSubcommandHelp(c)
-		return true
-	}
-
-	return false
-}
-
-func checkCompletions(c *Context) bool {
-	if (c.GlobalBool(BashCompletionFlag.Name) || c.Bool(BashCompletionFlag.Name)) && c.App.EnableBashCompletion {
-		ShowCompletions(c)
-		return true
-	}
-
-	return false
-}
-
-func checkCommandCompletions(c *Context, name string) bool {
-	if c.Bool(BashCompletionFlag.Name) && c.App.EnableBashCompletion {
-		ShowCommandCompletions(c, name)
-		return true
-	}
-
-	return false
-}

Godeps/_workspace/src/github.com/docker/distribution/.drone.yml

@@ -1,38 +0,0 @@
-image: dmp42/go:stable
-
-script:
-  # To be spoofed back into the test image
-  - go get github.com/modocache/gover
-
-  - go get -t ./...
-
-  # Go fmt
-  - test -z "$(gofmt -s -l -w .     | tee /dev/stderr)"
-  # Go lint
-  - test -z "$(golint ./...          | tee /dev/stderr)"
-  # Go vet
-  - go vet ./...
-  # Go test
-  - go test -v -race -cover ./...
-  # Helper to concatenate reports
-  - gover
-  # Send to coverall
-  - goveralls -service drone.io -coverprofile=gover.coverprofile -repotoken {{COVERALLS_TOKEN}}
-
-  # Do we want these as well?
-  # - go get code.google.com/p/go.tools/cmd/goimports
-  # - test -z "$(goimports -l -w ./... | tee /dev/stderr)"
-  # http://labix.org/gocheck
-
-notify:
-    email:
-        recipients:
-            - distribution@docker.com
-
-    slack:
-        team: docker
-        channel: "#dt"
-        username: mom
-        token: {{SLACK_TOKEN}}
-        on_success: true
-        on_failure: true

Godeps/_workspace/src/github.com/docker/distribution/.gitignore

@@ -1,37 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-*.test
-*.prof
-
-# never checkin from the bin file (for now)
-bin/*
-
-# Test key files
-*.pem
-
-# Cover profiles
-*.out
-
-# Editor/IDE specific files.
-*.sublime-project
-*.sublime-workspace

Godeps/_workspace/src/github.com/docker/distribution/.mailmap

@@ -1,14 +0,0 @@
-Stephen J Day <stephen.day@docker.com>  Stephen Day <stevvooe@users.noreply.github.com>
-Stephen J Day <stephen.day@docker.com>  Stephen Day <stevvooe@gmail.com>
-Olivier Gambier <olivier@docker.com>    Olivier Gambier <dmp42@users.noreply.github.com>
-Brian Bland <brian.bland@docker.com>    Brian Bland <r4nd0m1n4t0r@gmail.com>
-Josh Hawn <josh.hawn@docker.com>        Josh Hawn <jlhawn@berkeley.edu>
-Richard Scothern <richard.scothern@docker.com> Richard <richard.scothern@gmail.com>
-Richard Scothern <richard.scothern@docker.com> Richard Scothern <richard.scothern@gmail.com>
-Andrew Meredith <andymeredith@gmail.com> Andrew Meredith <kendru@users.noreply.github.com>
-harche <p.harshal@gmail.com> harche <harche@users.noreply.github.com>
-Jessie Frazelle <jessie@docker.com>  <jfrazelle@users.noreply.github.com>
-Sharif Nassar <sharif@mrwacky.com> Sharif Nassar <mrwacky42@users.noreply.github.com>
-Sven Dowideit <SvenDowideit@home.org.au> Sven Dowideit <SvenDowideit@users.noreply.github.com>
-Vincent Giersch <vincent.giersch@ovh.net> Vincent Giersch <vincent@giersch.fr>
-davidli <wenquan.li@hp.com> davidli <wenquan.li@hpe.com>

Godeps/_workspace/src/github.com/docker/distribution/AUTHORS

@@ -1,104 +0,0 @@
-Aaron Lehmann <aaron.lehmann@docker.com>
-Aaron Vinson <avinson.public@gmail.com>
-Adam Enger <adamenger@gmail.com>
-Adrian Mouat <adrian.mouat@gmail.com>
-Ahmet Alp Balkan <ahmetalpbalkan@gmail.com>
-Alex Chan <alex.chan@metaswitch.com>
-Alex Elman <aelman@indeed.com>
-amitshukla <ashukla73@hotmail.com>
-Amy Lindburg <amy.lindburg@docker.com>
-Andrew Meredith <andymeredith@gmail.com>
-Andrey Kostov <kostov.andrey@gmail.com>
-Andy Goldstein <agoldste@redhat.com>
-Anton Tiurin <noxiouz@yandex.ru>
-Antonio Mercado <amercado@thinknode.com>
-Arnaud Porterie <arnaud.porterie@docker.com>
-Arthur Baars <arthur@semmle.com>
-Avi Miller <avi.miller@oracle.com>
-Ayose Cazorla <ayosec@gmail.com>
-BadZen <dave.trombley@gmail.com>
-Ben Firshman <ben@firshman.co.uk>
-bin liu <liubin0329@gmail.com>
-Brian Bland <brian.bland@docker.com>
-burnettk <burnettk@gmail.com>
-Chris Dillon <squarism@gmail.com>
-Daisuke Fujita <dtanshi45@gmail.com>
-Darren Shepherd <darren@rancher.com>
-Dave Trombley <dave.trombley@gmail.com>
-Dave Tucker <dt@docker.com>
-David Lawrence <david.lawrence@docker.com>
-David Verhasselt <david@crowdway.com>
-David Xia <dxia@spotify.com>
-davidli <wenquan.li@hp.com>
-Dejan Golja <dejan@golja.org>
-Derek McGowan <derek@mcgstyle.net>
-Diogo Mónica <diogo.monica@gmail.com>
-Donald Huang <don.hcd@gmail.com>
-Doug Davis <dug@us.ibm.com>
-farmerworking <farmerworking@gmail.com>
-Florentin Raud <florentin.raud@gmail.com>
-Frederick F. Kautz IV <fkautz@alumni.cmu.edu>
-harche <p.harshal@gmail.com>
-Henri Gomez <henri.gomez@gmail.com>
-Hu Keping <hukeping@huawei.com>
-Hua Wang <wanghua.humble@gmail.com>
-Ian Babrou <ibobrik@gmail.com>
-Jack Griffin <jackpg14@gmail.com>
-Jason Freidman <jason.freidman@gmail.com>
-Jeff Nickoloff <jeff@allingeek.com>
-Jessie Frazelle <jessie@docker.com>
-Jianqing Wang <tsing@jianqing.org>
-Jon Poler <jonathan.poler@apcera.com>
-Jonathan Boulle <jonathanboulle@gmail.com>
-Jordan Liggitt <jliggitt@redhat.com>
-Josh Hawn <josh.hawn@docker.com>
-Julien Fernandez <julien.fernandez@gmail.com>
-Kelsey Hightower <kelsey.hightower@gmail.com>
-Kenneth Lim <kennethlimcp@gmail.com>
-Li Yi <denverdino@gmail.com>
-Louis Kottmann <louis.kottmann@gmail.com>
-Luke Carpenter <x@rubynerd.net>
-Mary Anthony <mary@docker.com>
-Matt Bentley <mbentley@mbentley.net>
-Matt Moore <mattmoor@google.com>
-Matt Robenolt <matt@ydekproductions.com>
-Michael Prokop <mika@grml.org>
-Miquel Sabaté <msabate@suse.com>
-Morgan Bauer <mbauer@us.ibm.com>
-moxiegirl <mary@docker.com>
-Nathan Sullivan <nathan@nightsys.net>
-nevermosby <robolwq@qq.com>
-Nghia Tran <tcnghia@gmail.com>
-Nuutti Kotivuori <nuutti.kotivuori@poplatek.fi>
-Oilbeater <liumengxinfly@gmail.com>
-Olivier Gambier <olivier@docker.com>
-Olivier Jacques <olivier.jacques@hp.com>
-Patrick Devine <patrick.devine@docker.com>
-Philip Misiowiec <philip@atlashealth.com>
-Richard Scothern <richard.scothern@docker.com>
-Rusty Conover <rusty@luckydinosaur.com>
-Sebastiaan van Stijn <github@gone.nl>
-Sharif Nassar <sharif@mrwacky.com>
-Shawn Falkner-Horine <dreadpirateshawn@gmail.com>
-Shreyas Karnik <karnik.shreyas@gmail.com>
-Simon Thulbourn <simon+github@thulbourn.com>
-Spencer Rinehart <anubis@overthemonkey.com>
-Stephen J Day <stephen.day@docker.com>
-Sungho Moon <sungho.moon@navercorp.com>
-Sven Dowideit <SvenDowideit@home.org.au>
-Sylvain Baubeau <sbaubeau@redhat.com>
-Ted Reed <ted.reed@gmail.com>
-tgic <farmer1992@gmail.com>
-Thomas Sjögren <konstruktoid@users.noreply.github.com>
-Tianon Gravi <admwiggin@gmail.com>
-Tibor Vass <teabee89@gmail.com>
-Tonis Tiigi <tonistiigi@gmail.com>
-Troels Thomsen <troels@thomsen.io>
-Vincent Batts <vbatts@redhat.com>
-Vincent Demeester <vincent@sbr.pm>
-Vincent Giersch <vincent.giersch@ovh.net>
-W. Trevor King <wking@tremily.us>
-xg.song <xg.song@venusource.com>
-xiekeyang <xiekeyang@huawei.com>
-Yann ROBERT <yann.robert@anantaplex.fr>
-yuzou <zouyu7@huawei.com>

Godeps/_workspace/src/github.com/docker/distribution/CONTRIBUTING.md

@@ -1,140 +0,0 @@
-# Contributing to the registry
-
-## Before reporting an issue...
-
-### If your problem is with...
-
- - automated builds
- - your account on the [Docker Hub](https://hub.docker.com/)
- - any other [Docker Hub](https://hub.docker.com/) issue
-
-Then please do not report your issue here - you should instead report it to [https://support.docker.com](https://support.docker.com)
-
-### If you...
-
- - need help setting up your registry
- - can't figure out something
- - are not sure what's going on or what your problem is
-
-Then please do not open an issue here yet - you should first try one of the following support forums:
-
- - irc: #docker-distribution on freenode
- - mailing-list: <distribution@dockerproject.org> or https://groups.google.com/a/dockerproject.org/forum/#!forum/distribution
-
-## Reporting an issue properly
-
-By following these simple rules you will get better and faster feedback on your issue.
-
- - search the bugtracker for an already reported issue
-
-### If you found an issue that describes your problem:
-
- - please read other user comments first, and confirm this is the same issue: a given error condition might be indicative of different problems - you may also find a workaround in the comments
- - please refrain from adding "same thing here" or "+1" comments
- - you don't need to comment on an issue to get notified of updates: just hit the "subscribe" button
- - comment if you have some new, technical and relevant information to add to the case
- - __DO NOT__ comment on closed issues or merged PRs. If you think you have a related problem, open up a new issue and reference the PR or issue.
-
-### If you have not found an existing issue that describes your problem:
-
- 1. create a new issue, with a succinct title that describes your issue:
-   - bad title: "It doesn't work with my docker"
-   - good title: "Private registry push fail: 400 error with E_INVALID_DIGEST"
- 2. copy the output of:
-   - `docker version`
-   - `docker info`
-   - `docker exec <registry-container> registry -version`
- 3. copy the command line you used to launch your Registry
- 4. restart your docker daemon in debug mode (add `-D` to the daemon launch arguments)
- 5. reproduce your problem and get your docker daemon logs showing the error
- 6. if relevant, copy your registry logs that show the error
- 7. provide any relevant detail about your specific Registry configuration (e.g., storage backend used)
- 8. indicate if you are using an enterprise proxy, Nginx, or anything else between you and your Registry
-
-## Contributing a patch for a known bug, or a small correction
-
-You should follow the basic GitHub workflow:
-
- 1. fork
- 2. commit a change
- 3. make sure the tests pass
- 4. PR
-
-Additionally, you must [sign your commits](https://github.com/docker/docker/blob/master/CONTRIBUTING.md#sign-your-work). It's very simple:
-
- - configure your name with git: `git config user.name "Real Name" && git config user.email mail@example.com`
- - sign your commits using `-s`: `git commit -s -m "My commit"`
-
-Some simple rules to ensure quick merge:
-
- - clearly point to the issue(s) you want to fix in your PR comment (e.g., `closes #12345`)
- - prefer multiple (smaller) PRs addressing individual issues over a big one trying to address multiple issues at once
- - if you need to amend your PR following comments, please squash instead of adding more commits
-
-## Contributing new features
-
-You are heavily encouraged to first discuss what you want to do. You can do so on the irc channel, or by opening an issue that clearly describes the use case you want to fulfill, or the problem you are trying to solve.
-
-If this is a major new feature, you should then submit a proposal that describes your technical solution and reasoning.
-If you did discuss it first, this will likely be greenlighted very fast. It's advisable to address all feedback on this proposal before starting actual work. 
-
-Then you should submit your implementation, clearly linking to the issue (and possible proposal).
-
-Your PR will be reviewed by the community, then ultimately by the project maintainers, before being merged.
-
-It's mandatory to:
-
- - interact respectfully with other community members and maintainers - more generally, you are expected to abide by the [Docker community rules](https://github.com/docker/docker/blob/master/CONTRIBUTING.md#docker-community-guidelines)
- - address maintainers' comments and modify your submission accordingly
- - write tests for any new code
-
-Complying to these simple rules will greatly accelerate the review process, and will ensure you have a pleasant experience in contributing code to the Registry.
-
-Have a look at a great, succesful contribution: the [Ceph driver PR](https://github.com/docker/distribution/pull/443)
-
-## Coding Style
-
-Unless explicitly stated, we follow all coding guidelines from the Go
-community. While some of these standards may seem arbitrary, they somehow seem
-to result in a solid, consistent codebase.
-
-It is possible that the code base does not currently comply with these
-guidelines. We are not looking for a massive PR that fixes this, since that
-goes against the spirit of the guidelines. All new contributions should make a
-best effort to clean up and make the code base better than they left it.
-Obviously, apply your best judgement. Remember, the goal here is to make the
-code base easier for humans to navigate and understand. Always keep that in
-mind when nudging others to comply.
-
-The rules:
-
-1. All code should be formatted with `gofmt -s`.
-2. All code should pass the default levels of
-   [`golint`](https://github.com/golang/lint).
-3. All code should follow the guidelines covered in [Effective
-   Go](http://golang.org/doc/effective_go.html) and [Go Code Review
-   Comments](https://github.com/golang/go/wiki/CodeReviewComments).
-4. Comment the code. Tell us the why, the history and the context.
-5. Document _all_ declarations and methods, even private ones. Declare
-   expectations, caveats and anything else that may be important. If a type
-   gets exported, having the comments already there will ensure it's ready.
-6. Variable name length should be proportional to its context and no longer.
-   `noCommaALongVariableNameLikeThisIsNotMoreClearWhenASimpleCommentWouldDo`.
-   In practice, short methods will have short variable names and globals will
-   have longer names.
-7. No underscores in package names. If you need a compound name, step back,
-   and re-examine why you need a compound name. If you still think you need a
-   compound name, lose the underscore.
-8. No utils or helpers packages. If a function is not general enough to
-   warrant its own package, it has not been written generally enough to be a
-   part of a util package. Just leave it unexported and well-documented.
-9. All tests should run with `go test` and outside tooling should not be
-   required. No, we don't need another unit testing framework. Assertion
-   packages are acceptable if they provide _real_ incremental value.
-10. Even though we call these "rules" above, they are actually just
-    guidelines. Since you've read all the rules, you now know that.
-
-If you are having trouble getting into the mood of idiomatic Go, we recommend
-reading through [Effective Go](http://golang.org/doc/effective_go.html). The
-[Go Blog](http://blog.golang.org/) is also a great resource. Drinking the
-kool-aid is a lot easier than going thirsty.

Godeps/_workspace/src/github.com/docker/distribution/Dockerfile

@@ -1,19 +0,0 @@
-FROM golang:1.5.3
-
-RUN apt-get update && \
-    apt-get install -y librados-dev apache2-utils && \
-    rm -rf /var/lib/apt/lists/*
-
-ENV DISTRIBUTION_DIR /go/src/github.com/docker/distribution
-ENV GOPATH $DISTRIBUTION_DIR/Godeps/_workspace:$GOPATH
-ENV DOCKER_BUILDTAGS include_rados include_oss include_gcs
-
-WORKDIR $DISTRIBUTION_DIR
-COPY . $DISTRIBUTION_DIR
-COPY cmd/registry/config-dev.yml /etc/docker/registry/config.yml
-RUN make PREFIX=/go clean binaries
-
-VOLUME ["/var/lib/registry"]
-EXPOSE 5000
-ENTRYPOINT ["registry"]
-CMD ["/etc/docker/registry/config.yml"]

Godeps/_workspace/src/github.com/docker/distribution/Godeps/Godeps.json

@@ -1,181 +0,0 @@
-{
-	"ImportPath": "github.com/docker/distribution",
-	"GoVersion": "go1.4.2",
-	"Packages": [
-		"./..."
-	],
-	"Deps": [
-		{
-			"ImportPath": "golang.org/x/oauth2",
-			"Rev": "8914e5017ca260f2a3a1575b1e6868874050d95e"
-		},
-		{
-			"ImportPath": "golang.org/x/oauth2/google",
-			"Rev": "8914e5017ca260f2a3a1575b1e6868874050d95e"
-		},
-		{
-			"ImportPath": "google.golang.org/api/storage/v1",
-			"Rev": "18450f4e95c7e76ce3a5dc3a8cb7178ab6d56121"
-		},
-		{
-			"ImportPath": "google.golang.org/cloud",
-			"Rev": "2400193c85c3561d13880d34e0e10c4315bb02af"
-		},
-		{
-			"ImportPath": "google.golang.org/api",
-			"Rev": "18450f4e95c7e76ce3a5dc3a8cb7178ab6d56121"
-		},
-		{
-			"ImportPath": "google.golang.org/grpc",
-			"Rev": "91c8b79535eb6045d70ec671d302213f88a3ab95"
-		},
-		{
-			"ImportPath": "github.com/bradfitz/http2",
-			"Rev": "f8202bc903bda493ebba4aa54922d78430c2c42f"
-		},
-		{
-			"ImportPath": "github.com/golang/protobuf",
-			"Rev": "0f7a9caded1fb3c9cc5a9b4bcf2ff633cc8ae644"
-		},
-		{
-			"ImportPath": "google.golang.org/cloud/storage",
-			"Rev": "2400193c85c3561d13880d34e0e10c4315bb02af"
-		},
-		{
-			"ImportPath": "github.com/AdRoll/goamz/aws",
-			"Rev": "aa6e716d710a0c7941cb2075cfbb9661f16d21f1"
-		},
-		{
-			"ImportPath": "github.com/AdRoll/goamz/cloudfront",
-			"Rev": "aa6e716d710a0c7941cb2075cfbb9661f16d21f1"
-		},
-		{
-			"ImportPath": "github.com/AdRoll/goamz/s3",
-			"Rev": "aa6e716d710a0c7941cb2075cfbb9661f16d21f1"
-		},
-		{
-			"ImportPath": "github.com/Azure/azure-sdk-for-go/storage",
-			"Rev": "97d9593768bbbbd316f9c055dfc5f780933cd7fc"
-		},
-		{
-			"ImportPath": "github.com/Sirupsen/logrus",
-			"Comment": "v0.7.3",
-			"Rev": "55eb11d21d2a31a3cc93838241d04800f52e823d"
-		},
-		{
-			"ImportPath": "github.com/bugsnag/bugsnag-go",
-			"Comment": "v1.0.2-5-gb1d1530",
-			"Rev": "b1d153021fcd90ca3f080db36bec96dc690fb274"
-		},
-		{
-			"ImportPath": "github.com/bugsnag/osext",
-			"Rev": "0dd3f918b21bec95ace9dc86c7e70266cfc5c702"
-		},
-		{
-			"ImportPath": "github.com/bugsnag/panicwrap",
-			"Rev": "e2c28503fcd0675329da73bf48b33404db873782"
-		},
-		{
-			"ImportPath": "github.com/denverdino/aliyungo/oss",
-			"Rev": "6ffb587da9da6d029d0ce517b85fecc82172d502"
-		},
-		{
-			"ImportPath": "github.com/denverdino/aliyungo/util",
-			"Rev": "6ffb587da9da6d029d0ce517b85fecc82172d502"
-		},
-		{
-			"ImportPath": "github.com/denverdino/aliyungo/common",
-			"Rev": "6ffb587da9da6d029d0ce517b85fecc82172d502"
-		},
-		{
-			"ImportPath": "github.com/docker/libtrust",
-			"Rev": "fa567046d9b14f6aa788882a950d69651d230b21"
-		},
-		{
-			"ImportPath": "github.com/garyburd/redigo/internal",
-			"Rev": "535138d7bcd717d6531c701ef5933d98b1866257"
-		},
-		{
-			"ImportPath": "github.com/garyburd/redigo/redis",
-			"Rev": "535138d7bcd717d6531c701ef5933d98b1866257"
-		},
-		{
-			"ImportPath": "github.com/gorilla/context",
-			"Rev": "14f550f51af52180c2eefed15e5fd18d63c0a64a"
-		},
-		{
-			"ImportPath": "github.com/gorilla/handlers",
-			"Rev": "60c7bfde3e33c201519a200a4507a158cc03a17b"
-		},
-		{
-			"ImportPath": "github.com/gorilla/mux",
-			"Rev": "e444e69cbd2e2e3e0749a2f3c717cec491552bbf"
-		},
-		{
-			"ImportPath": "github.com/inconshreveable/mousetrap",
-			"Rev": "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
-		},
-		{
-			"ImportPath": "github.com/mitchellh/mapstructure",
-			"Rev": "482a9fd5fa83e8c4e7817413b80f3eb8feec03ef"
-		},
-		{
-			"ImportPath": "github.com/ncw/swift",
-			"Rev": "c54732e87b0b283d1baf0a18db689d0aea460ba3"
-		},
-		{
-			"ImportPath": "github.com/noahdesu/go-ceph/rados",
-			"Comment": "v.0.3.0-29-gb15639c",
-			"Rev": "b15639c44c05368348355229070361395d9152ee"
-		},
-		{
-			"ImportPath": "github.com/spf13/cobra",
-			"Rev": "312092086bed4968099259622145a0c9ae280064"
-		},
-		{
-			"ImportPath": "github.com/spf13/pflag",
-			"Rev": "5644820622454e71517561946e3d94b9f9db6842"
-		},
-		{
-			"ImportPath": "github.com/stevvooe/resumable",
-			"Rev": "51ad44105773cafcbe91927f70ac68e1bf78f8b4"
-		},
-		{
-			"ImportPath": "github.com/yvasiyarov/go-metrics",
-			"Rev": "57bccd1ccd43f94bb17fdd8bf3007059b802f85e"
-		},
-		{
-			"ImportPath": "github.com/yvasiyarov/gorelic",
-			"Comment": "v0.0.6-8-ga9bba5b",
-			"Rev": "a9bba5b9ab508a086f9a12b8c51fab68478e2128"
-		},
-		{
-			"ImportPath": "github.com/yvasiyarov/newrelic_platform_go",
-			"Rev": "b21fdbd4370f3717f3bbd2bf41c223bc273068e6"
-		},
-		{
-			"ImportPath": "golang.org/x/crypto/bcrypt",
-			"Rev": "c10c31b5e94b6f7a0283272dc2bb27163dcea24b"
-		},
-		{
-			"ImportPath": "golang.org/x/crypto/blowfish",
-			"Rev": "c10c31b5e94b6f7a0283272dc2bb27163dcea24b"
-		},
-		{
-			"ImportPath": "golang.org/x/net/context",
-			"Rev": "2cba614e8ff920c60240d2677bc019af32ee04e5"
-		},
-		{
-			"ImportPath": "golang.org/x/net/trace",
-			"Rev": "2cba614e8ff920c60240d2677bc019af32ee04e5"
-		},
-		{
-			"ImportPath": "gopkg.in/check.v1",
-			"Rev": "64131543e7896d5bcc6bd5a76287eb75ea96c673"
-		},
-		{
-			"ImportPath": "gopkg.in/yaml.v2",
-			"Rev": "bef53efd0c76e49e6de55ead051f886bea7e9420"
-		}
-	]
-}

Godeps/_workspace/src/github.com/docker/distribution/Godeps/Readme

@@ -1,5 +0,0 @@
-This directory tree is generated automatically by godep.
-
-Please do not edit.
-
-See https://github.com/tools/godep for more information.

Godeps/_workspace/src/github.com/docker/distribution/MAINTAINERS

@@ -1,58 +0,0 @@
-# Distribution maintainers file
-#
-# This file describes who runs the docker/distribution project and how.
-# This is a living document - if you see something out of date or missing, speak up!
-#
-# It is structured to be consumable by both humans and programs.
-# To extract its contents programmatically, use any TOML-compliant parser.
-#
-# This file is compiled into the MAINTAINERS file in docker/opensource.
-#
-[Org]
-	[Org."Core maintainers"]
-		people = [
-			"aaronlehmann",
-			"dmcgowan",
-			"dmp42",
-			"richardscothern",
-			"shykes",
-			"stevvooe",
-		]
-
-[people]
-
-# A reference list of all people associated with the project.
-# All other sections should refer to people by their canonical key
-# in the people section.
-
-	# ADD YOURSELF HERE IN ALPHABETICAL ORDER
-
-	[people.aaronlehmann]
-	Name = "Aaron Lehmann"
-	Email = "aaron.lehmann@docker.com"
-	GitHub = "aaronlehmann"
-
-	[people.dmcgowan]
-	Name = "Derek McGowan"
-	Email = "derek@mcgstyle.net"
-	GitHub = "dmcgowan"
-
-	[people.dmp42]
-	Name = "Olivier Gambier"
-	Email = "olivier@docker.com"
-	GitHub = "dmp42"
-
-	[people.richardscothern]
-	Name = "Richard Scothern"
-	Email = "richard.scothern@gmail.com"
-	GitHub = "richardscothern"
-
-	[people.shykes]
-	Name = "Solomon Hykes"
-	Email = "solomon@docker.com"
-	GitHub = "shykes"
-
-	[people.stevvooe]
-	Name = "Stephen Day"
-	Email = "stephen.day@docker.com"
-	GitHub = "stevvooe"

Godeps/_workspace/src/github.com/docker/distribution/Makefile

@@ -1,74 +0,0 @@
-# Set an output prefix, which is the local directory if not specified
-PREFIX?=$(shell pwd)
-
-
-# Used to populate version variable in main package.
-VERSION=$(shell git describe --match 'v[0-9]*' --dirty='.m' --always)
-
-# Allow turning off function inlining and variable registerization
-ifeq (${DISABLE_OPTIMIZATION},true)
-	GO_GCFLAGS=-gcflags "-N -l"
-	VERSION:="$(VERSION)-noopt"
-endif
-
-GO_LDFLAGS=-ldflags "-X `go list ./version`.Version=$(VERSION)"
-
-.PHONY: clean all fmt vet lint build test binaries
-.DEFAULT: default
-all: AUTHORS clean fmt vet fmt lint build test binaries
-
-AUTHORS: .mailmap .git/HEAD
-	 git log --format='%aN <%aE>' | sort -fu > $@
-
-# This only needs to be generated by hand when cutting full releases.
-version/version.go:
-	./version/version.sh > $@
-
-${PREFIX}/bin/registry: version/version.go $(shell find . -type f -name '*.go')
-	@echo "+ $@"
-	@go build -tags "${DOCKER_BUILDTAGS}" -o $@ ${GO_LDFLAGS}  ${GO_GCFLAGS} ./cmd/registry
-
-${PREFIX}/bin/digest: version/version.go $(shell find . -type f -name '*.go')
-	@echo "+ $@"
-	@go build -tags "${DOCKER_BUILDTAGS}" -o $@ ${GO_LDFLAGS}  ${GO_GCFLAGS} ./cmd/digest
-
-${PREFIX}/bin/registry-api-descriptor-template: version/version.go $(shell find . -type f -name '*.go')
-	@echo "+ $@"
-	@go build -o $@ ${GO_LDFLAGS} ${GO_GCFLAGS} ./cmd/registry-api-descriptor-template
-
-docs/spec/api.md: docs/spec/api.md.tmpl ${PREFIX}/bin/registry-api-descriptor-template
-	./bin/registry-api-descriptor-template $< > $@
-
-# Depends on binaries because vet will silently fail if it can't load compiled
-# imports
-vet: binaries
-	@echo "+ $@"
-	@go vet ./...
-
-fmt:
-	@echo "+ $@"
-	@test -z "$$(gofmt -s -l . | grep -v Godeps/_workspace/src/ | tee /dev/stderr)" || \
-		echo "+ please format Go code with 'gofmt -s'"
-
-lint:
-	@echo "+ $@"
-	@test -z "$$(golint ./... | grep -v Godeps/_workspace/src/ | tee /dev/stderr)"
-
-build:
-	@echo "+ $@"
-	@go build -tags "${DOCKER_BUILDTAGS}" -v ${GO_LDFLAGS} ./...
-
-test:
-	@echo "+ $@"
-	@go test -test.short -tags "${DOCKER_BUILDTAGS}" ./...
-
-test-full:
-	@echo "+ $@"
-	@go test ./...
-
-binaries: ${PREFIX}/bin/registry ${PREFIX}/bin/digest ${PREFIX}/bin/registry-api-descriptor-template
-	@echo "+ $@"
-
-clean:
-	@echo "+ $@"
-	@rm -rf "${PREFIX}/bin/registry" "${PREFIX}/bin/registry-api-descriptor-template"

Godeps/_workspace/src/github.com/docker/distribution/README.md

@@ -1,131 +0,0 @@
-# Distribution
-
-The Docker toolset to pack, ship, store, and deliver content.
-
-This repository's main product is the Docker Registry 2.0 implementation
-for storing and distributing Docker images. It supersedes the
-[docker/docker-registry](https://github.com/docker/docker-registry)
-project with a new API design, focused around security and performance.
-
-<img src="https://www.docker.com/sites/default/files/oyster-registry-3.png" width=200px/>
-
-[![Circle CI](https://circleci.com/gh/docker/distribution/tree/master.svg?style=svg)](https://circleci.com/gh/docker/distribution/tree/master)
-[![GoDoc](https://godoc.org/github.com/docker/distribution?status.svg)](https://godoc.org/github.com/docker/distribution)
-
-This repository contains the following components:
-
-|**Component**       |Description                                                                                                                                                                                         |
-|--------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| **registry**       | An implementation of the [Docker Registry HTTP API V2](docs/spec/api.md) for use with docker 1.6+.                                                                                                  |
-| **libraries**      | A rich set of libraries for interacting with,distribution components. Please see [godoc](https://godoc.org/github.com/docker/distribution) for details. **Note**: These libraries are **unstable**. |
-| **specifications** | _Distribution_ related specifications are available in [docs/spec](docs/spec)                                                                                                                        |
-| **documentation**  | Docker's full documentation set is available at [docs.docker.com](https://docs.docker.com). This repository [contains the subset](docs/index.md) related just to the registry.                                                                                                                                          |
-
-### How does this integrate with Docker engine?
-
-This project should provide an implementation to a V2 API for use in the [Docker
-core project](https://github.com/docker/docker). The API should be embeddable
-and simplify the process of securely pulling and pushing content from `docker`
-daemons.
-
-### What are the long term goals of the Distribution project?
-
-The _Distribution_ project has the further long term goal of providing a
-secure tool chain for distributing content. The specifications, APIs and tools
-should be as useful with Docker as they are without.
-
-Our goal is to design a professional grade and extensible content distribution
-system that allow users to:
-
-* Enjoy an efficient, secured and reliable way to store, manage, package and
-  exchange content
-* Hack/roll their own on top of healthy open-source components
-* Implement their own home made solution through good specs, and solid
-  extensions mechanism.
-
-## More about Registry 2.0
-
-The new registry implementation provides the following benefits:
-
-- faster push and pull
-- new, more efficient implementation
-- simplified deployment
-- pluggable storage backend
-- webhook notifications
-
-For information on upcoming functionality, please see [ROADMAP.md](ROADMAP.md).
-
-### Who needs to deploy a registry?
-
-By default, Docker users pull images from Docker's public registry instance.
-[Installing Docker](https://docs.docker.com/engine/installation/) gives users this
-ability. Users can also push images to a repository on Docker's public registry,
-if they have a [Docker Hub](https://hub.docker.com/) account. 
-
-For some users and even companies, this default behavior is sufficient. For
-others, it is not. 
-
-For example, users with their own software products may want to maintain a
-registry for private, company images. Also, you may wish to deploy your own
-image repository for images used to test or in continuous integration. For these
-use cases and others, [deploying your own registry instance](docs/deploying.md)
-may be the better choice.
-
-### Migration to Registry 2.0
-
-For those who have previously deployed their own registry based on the Registry
-1.0 implementation and wish to deploy a Registry 2.0 while retaining images,
-data migration is required. A tool to assist with migration efforts has been
-created. For more information see [docker/migrator]
-(https://github.com/docker/migrator).
-
-## Contribute
-
-Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute
-issues, fixes, and patches to this project. If you are contributing code, see
-the instructions for [building a development environment](docs/building.md).
-
-## Support
-
-If any issues are encountered while using the _Distribution_ project, several
-avenues are available for support:
-
-<table>
-<tr>
-	<th align="left">
-	IRC
-	</th>
-	<td>
-	#docker-distribution on FreeNode
-	</td>
-</tr>
-<tr>
-	<th align="left">
-	Issue Tracker
-	</th>
-	<td>
-	github.com/docker/distribution/issues
-	</td>
-</tr>
-<tr>
-	<th align="left">
-	Google Groups
-	</th>
-	<td>
-	https://groups.google.com/a/dockerproject.org/forum/#!forum/distribution
-	</td>
-</tr>
-<tr>
-	<th align="left">
-	Mailing List
-	</th>
-	<td>
-	docker@dockerproject.org
-	</td>
-</tr>
-</table>
-
-
-## License
-
-This project is distributed under [Apache License, Version 2.0](LICENSE.md).

Godeps/_workspace/src/github.com/docker/distribution/circle.yml

@@ -1,90 +0,0 @@
-# Pony-up!
-machine:
-  pre:
-  # Install gvm
-    - bash < <(curl -s -S -L https://raw.githubusercontent.com/moovweb/gvm/1.0.22/binscripts/gvm-installer)
-  # Install ceph to test rados driver & create pool
-    - sudo -i ~/distribution/contrib/ceph/ci-setup.sh
-    - ceph osd pool create docker-distribution 1
-  # Install codecov for coverage
-    - pip install --user codecov
-
-  post:
-  # go
-    - gvm install go1.5.3 --prefer-binary --name=stable
-
-  environment:
-  # Convenient shortcuts to "common" locations
-    CHECKOUT: /home/ubuntu/$CIRCLE_PROJECT_REPONAME
-    BASE_DIR: src/github.com/$CIRCLE_PROJECT_USERNAME/$CIRCLE_PROJECT_REPONAME
-  # Trick circle brainflat "no absolute path" behavior
-    BASE_STABLE: ../../../$HOME/.gvm/pkgsets/stable/global/$BASE_DIR
-    DOCKER_BUILDTAGS: "include_rados include_oss include_gcs"
-  # Workaround Circle parsing dumb bugs and/or YAML wonkyness
-    CIRCLE_PAIN: "mode: set"
-  # Ceph config
-    RADOS_POOL: "docker-distribution"
-
-  hosts:
-  # Not used yet
-    fancy: 127.0.0.1
-
-dependencies:
-  pre:
-  # Copy the code to the gopath of all go versions
-    - >
-      gvm use stable &&
-      mkdir -p "$(dirname $BASE_STABLE)" &&
-      cp -R "$CHECKOUT" "$BASE_STABLE"
-
-  override:
-  # Install dependencies for every copied clone/go version
-    - gvm use stable && go get github.com/tools/godep:
-        pwd: $BASE_STABLE
-
-  post:
-  # For the stable go version, additionally install linting tools
-    - >
-      gvm use stable &&
-      go get github.com/axw/gocov/gocov github.com/golang/lint/golint
-
-test:
-  pre:
-  # Output the go versions we are going to test
-    # - gvm use old && go version
-    - gvm use stable && go version
-
-  # First thing: build everything. This will catch compile errors, and it's
-  # also necessary for go vet to work properly (see #807).
-    - gvm use stable && godep go install ./...:
-        pwd: $BASE_STABLE
-
-  # FMT
-    - gvm use stable && test -z "$(gofmt -s -l . | grep -v Godeps/_workspace/src/ | tee /dev/stderr)":
-        pwd: $BASE_STABLE
-
-   # VET
-    - gvm use stable && go vet ./...:
-        pwd: $BASE_STABLE
-
-  # LINT
-    - gvm use stable && test -z "$(golint ./... | grep -v Godeps/_workspace/src/ | tee /dev/stderr)":
-        pwd: $BASE_STABLE
-
-  override:
-  # Test stable, and report
-     - gvm use stable; export ROOT_PACKAGE=$(go list .); go list -tags "$DOCKER_BUILDTAGS" ./... | xargs -L 1 -I{} bash -c 'export PACKAGE={}; godep go test -tags "$DOCKER_BUILDTAGS" -test.short -coverprofile=$GOPATH/src/$PACKAGE/coverage.out -coverpkg=$(./coverpkg.sh $PACKAGE $ROOT_PACKAGE) $PACKAGE':
-         timeout: 600
-         pwd: $BASE_STABLE
-
-  post:
-  # Report to codecov
-    - bash <(curl -s https://codecov.io/bash):
-        pwd: $BASE_STABLE
-
-  ## Notes
-  # Disabled the -race detector due to massive memory usage.
-  # Do we want these as well?
-  # - go get code.google.com/p/go.tools/cmd/goimports
-  # - test -z "$(goimports -l -w ./... | tee /dev/stderr)"
-  # http://labix.org/gocheck

Godeps/_workspace/src/github.com/docker/distribution/cmd/digest/main.go

@@ -1,97 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"io"
-	"log"
-	"os"
-
-	"github.com/docker/distribution/digest"
-	"github.com/docker/distribution/version"
-)
-
-var (
-	algorithm   = digest.Canonical
-	showVersion bool
-)
-
-type job struct {
-	name   string
-	reader io.Reader
-}
-
-func init() {
-	flag.Var(&algorithm, "a", "select the digest algorithm (shorthand)")
-	flag.Var(&algorithm, "algorithm", "select the digest algorithm")
-	flag.BoolVar(&showVersion, "version", false, "show the version and exit")
-
-	log.SetFlags(0)
-	log.SetPrefix(os.Args[0] + ": ")
-}
-
-func usage() {
-	fmt.Fprintf(os.Stderr, "usage: %s [files...]\n", os.Args[0])
-	fmt.Fprintf(os.Stderr, `
-Calculate the digest of one or more input files, emitting the result
-to standard out. If no files are provided, the digest of stdin will
-be calculated.
-
-`)
-	flag.PrintDefaults()
-}
-
-func unsupported() {
-	log.Fatalf("unsupported digest algorithm: %v", algorithm)
-}
-
-func main() {
-	var jobs []job
-
-	flag.Usage = usage
-	flag.Parse()
-	if showVersion {
-		version.PrintVersion()
-		return
-	}
-
-	var fail bool // if we fail on one item, foul the exit code
-	if flag.NArg() > 0 {
-		for _, path := range flag.Args() {
-			fp, err := os.Open(path)
-
-			if err != nil {
-				log.Printf("%s: %v", path, err)
-				fail = true
-				continue
-			}
-			defer fp.Close()
-
-			jobs = append(jobs, job{name: path, reader: fp})
-		}
-	} else {
-		// just read stdin
-		jobs = append(jobs, job{name: "-", reader: os.Stdin})
-	}
-
-	digestFn := algorithm.FromReader
-
-	if !algorithm.Available() {
-		unsupported()
-	}
-
-	for _, job := range jobs {
-		dgst, err := digestFn(job.reader)
-		if err != nil {
-			log.Printf("%s: %v", job.name, err)
-			fail = true
-			continue
-		}
-
-		fmt.Printf("%v\t%s\n", dgst, job.name)
-	}
-
-	if fail {
-		os.Exit(1)
-	}
-}

Godeps/_workspace/src/github.com/docker/distribution/cmd/registry-api-descriptor-template/main.go

@@ -1,131 +0,0 @@
-// registry-api-descriptor-template uses the APIDescriptor defined in the
-// api/v2 package to execute templates passed to the command line.
-//
-// For example, to generate a new API specification, one would execute the
-// following command from the repo root:
-//
-// 	$ registry-api-descriptor-template docs/spec/api.md.tmpl > docs/spec/api.md
-//
-// The templates are passed in the api/v2.APIDescriptor object. Please see the
-// package documentation for fields available on that object. The template
-// syntax is from Go's standard library text/template package. For information
-// on Go's template syntax, please see golang.org/pkg/text/template.
-package main
-
-import (
-	"log"
-	"net/http"
-	"os"
-	"path/filepath"
-	"regexp"
-	"text/template"
-
-	"github.com/docker/distribution/registry/api/errcode"
-	"github.com/docker/distribution/registry/api/v2"
-)
-
-var spaceRegex = regexp.MustCompile(`\n\s*`)
-
-func main() {
-
-	if len(os.Args) != 2 {
-		log.Fatalln("please specify a template to execute.")
-	}
-
-	path := os.Args[1]
-	filename := filepath.Base(path)
-
-	funcMap := template.FuncMap{
-		"removenewlines": func(s string) string {
-			return spaceRegex.ReplaceAllString(s, " ")
-		},
-		"statustext":    http.StatusText,
-		"prettygorilla": prettyGorillaMuxPath,
-	}
-
-	tmpl := template.Must(template.New(filename).Funcs(funcMap).ParseFiles(path))
-
-	data := struct {
-		RouteDescriptors []v2.RouteDescriptor
-		ErrorDescriptors []errcode.ErrorDescriptor
-	}{
-		RouteDescriptors: v2.APIDescriptor.RouteDescriptors,
-		ErrorDescriptors: append(errcode.GetErrorCodeGroup("registry.api.v2"),
-			// The following are part of the specification but provided by errcode default.
-			errcode.ErrorCodeUnauthorized.Descriptor(),
-			errcode.ErrorCodeDenied.Descriptor(),
-			errcode.ErrorCodeUnsupported.Descriptor()),
-	}
-
-	if err := tmpl.Execute(os.Stdout, data); err != nil {
-		log.Fatalln(err)
-	}
-}
-
-// prettyGorillaMuxPath removes the regular expressions from a gorilla/mux
-// route string, making it suitable for documentation.
-func prettyGorillaMuxPath(s string) string {
-	// Stateful parser that removes regular expressions from gorilla
-	// routes. It correctly handles balanced bracket pairs.
-
-	var output string
-	var label string
-	var level int
-
-start:
-	if s[0] == '{' {
-		s = s[1:]
-		level++
-		goto capture
-	}
-
-	output += string(s[0])
-	s = s[1:]
-
-	goto end
-capture:
-	switch s[0] {
-	case '{':
-		level++
-	case '}':
-		level--
-
-		if level == 0 {
-			s = s[1:]
-			goto label
-		}
-	case ':':
-		s = s[1:]
-		goto skip
-	default:
-		label += string(s[0])
-	}
-	s = s[1:]
-	goto capture
-skip:
-	switch s[0] {
-	case '{':
-		level++
-	case '}':
-		level--
-	}
-	s = s[1:]
-
-	if level == 0 {
-		goto label
-	}
-
-	goto skip
-label:
-	if label != "" {
-		output += "<" + label + ">"
-		label = ""
-	}
-end:
-	if s != "" {
-		goto start
-	}
-
-	return output
-
-}

Godeps/_workspace/src/github.com/docker/distribution/cmd/registry/config-cache.yml

@@ -1,55 +0,0 @@
-version: 0.1
-log:
-  level: debug
-  fields:
-    service: registry
-    environment: development
-storage:
-    cache:
-        blobdescriptor: redis
-    filesystem:
-        rootdirectory: /var/lib/registry-cache
-    maintenance:
-        uploadpurging:
-            enabled: false
-http:
-    addr: :5000
-    secret: asecretforlocaldevelopment
-    debug:
-        addr: localhost:5001
-    headers:
-        X-Content-Type-Options: [nosniff]
-redis:
-  addr: localhost:6379
-  pool:
-    maxidle: 16
-    maxactive: 64
-    idletimeout: 300s
-  dialtimeout: 10ms
-  readtimeout: 10ms
-  writetimeout: 10ms
-notifications:
-    endpoints:
-        - name: local-8082
-          url: http://localhost:5003/callback
-          headers:
-             Authorization: [Bearer <an example token>]
-          timeout: 1s
-          threshold: 10
-          backoff: 1s
-          disabled: true
-        - name: local-8083
-          url: http://localhost:8083/callback
-          timeout: 1s
-          threshold: 10
-          backoff: 1s
-          disabled: true
-proxy:
-  remoteurl: https://registry-1.docker.io
-  username: username
-  password: password
-health:
-  storagedriver:
-    enabled: true
-    interval: 10s
-    threshold: 3

Godeps/_workspace/src/github.com/docker/distribution/cmd/registry/config-dev.yml

@@ -1,66 +0,0 @@
-version: 0.1
-log:
-  level: debug
-  fields:
-    service: registry
-    environment: development
-  hooks:
-    - type: mail
-      disabled: true
-      levels:
-        - panic
-      options:
-        smtp:
-          addr: mail.example.com:25
-          username: mailuser
-          password: password
-          insecure: true
-        from: sender@example.com
-        to:
-          - errors@example.com
-storage:
-    delete:
-      enabled: true
-    cache:
-        blobdescriptor: redis
-    filesystem:
-        rootdirectory: /var/lib/registry
-    maintenance:
-        uploadpurging:
-            enabled: false
-http:
-    addr: :5000
-    debug:
-        addr: localhost:5001
-    headers:
-        X-Content-Type-Options: [nosniff]
-redis:
-  addr: localhost:6379
-  pool:
-    maxidle: 16
-    maxactive: 64
-    idletimeout: 300s
-  dialtimeout: 10ms
-  readtimeout: 10ms
-  writetimeout: 10ms
-notifications:
-    endpoints:
-        - name: local-5003
-          url: http://localhost:5003/callback
-          headers:
-             Authorization: [Bearer <an example token>]
-          timeout: 1s
-          threshold: 10
-          backoff: 1s
-          disabled: true
-        - name: local-8083
-          url: http://localhost:8083/callback
-          timeout: 1s
-          threshold: 10
-          backoff: 1s
-          disabled: true 
-health:
-  storagedriver:
-    enabled: true
-    interval: 10s
-    threshold: 3

Godeps/_workspace/src/github.com/docker/distribution/cmd/registry/config-example.yml

@@ -1,18 +0,0 @@
-version: 0.1
-log:
-  fields:
-    service: registry
-storage:
-    cache:
-        blobdescriptor: inmemory
-    filesystem:
-        rootdirectory: /var/lib/registry
-http:
-    addr: :5000
-    headers:
-        X-Content-Type-Options: [nosniff]
-health:
-  storagedriver:
-    enabled: true
-    interval: 10s
-    threshold: 3

Godeps/_workspace/src/github.com/docker/distribution/cmd/registry/main.go

@@ -1,23 +0,0 @@
-package main
-
-import (
-	_ "net/http/pprof"
-
-	"github.com/docker/distribution/registry"
-	_ "github.com/docker/distribution/registry/auth/htpasswd"
-	_ "github.com/docker/distribution/registry/auth/silly"
-	_ "github.com/docker/distribution/registry/auth/token"
-	_ "github.com/docker/distribution/registry/proxy"
-	_ "github.com/docker/distribution/registry/storage/driver/azure"
-	_ "github.com/docker/distribution/registry/storage/driver/filesystem"
-	_ "github.com/docker/distribution/registry/storage/driver/gcs"
-	_ "github.com/docker/distribution/registry/storage/driver/inmemory"
-	_ "github.com/docker/distribution/registry/storage/driver/middleware/cloudfront"
-	_ "github.com/docker/distribution/registry/storage/driver/oss"
-	_ "github.com/docker/distribution/registry/storage/driver/s3"
-	_ "github.com/docker/distribution/registry/storage/driver/swift"
-)
-
-func main() {
-	registry.Cmd.Execute()
-}

Godeps/_workspace/src/github.com/docker/distribution/cmd/registry/rados.go

@@ -1,5 +0,0 @@
-// +build include_rados
-
-package main
-
-import _ "github.com/docker/distribution/registry/storage/driver/rados"

Godeps/_workspace/src/github.com/docker/distribution/configuration/configuration.go

@@ -1,571 +0,0 @@
-package configuration
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"reflect"
-	"strings"
-	"time"
-)
-
-// Configuration is a versioned registry configuration, intended to be provided by a yaml file, and
-// optionally modified by environment variables.
-//
-// Note that yaml field names should never include _ characters, since this is the separator used
-// in environment variable names.
-type Configuration struct {
-	// Version is the version which defines the format of the rest of the configuration
-	Version Version `yaml:"version"`
-
-	// Log supports setting various parameters related to the logging
-	// subsystem.
-	Log struct {
-		// Level is the granularity at which registry operations are logged.
-		Level Loglevel `yaml:"level"`
-
-		// Formatter overrides the default formatter with another. Options
-		// include "text", "json" and "logstash".
-		Formatter string `yaml:"formatter,omitempty"`
-
-		// Fields allows users to specify static string fields to include in
-		// the logger context.
-		Fields map[string]interface{} `yaml:"fields,omitempty"`
-
-		// Hooks allows users to configurate the log hooks, to enabling the
-		// sequent handling behavior, when defined levels of log message emit.
-		Hooks []LogHook `yaml:"hooks,omitempty"`
-	}
-
-	// Loglevel is the level at which registry operations are logged. This is
-	// deprecated. Please use Log.Level in the future.
-	Loglevel Loglevel `yaml:"loglevel,omitempty"`
-
-	// Storage is the configuration for the registry's storage driver
-	Storage Storage `yaml:"storage"`
-
-	// Auth allows configuration of various authorization methods that may be
-	// used to gate requests.
-	Auth Auth `yaml:"auth,omitempty"`
-
-	// Middleware lists all middlewares to be used by the registry.
-	Middleware map[string][]Middleware `yaml:"middleware,omitempty"`
-
-	// Reporting is the configuration for error reporting
-	Reporting Reporting `yaml:"reporting,omitempty"`
-
-	// HTTP contains configuration parameters for the registry's http
-	// interface.
-	HTTP struct {
-		// Addr specifies the bind address for the registry instance.
-		Addr string `yaml:"addr,omitempty"`
-
-		// Net specifies the net portion of the bind address. A default empty value means tcp.
-		Net string `yaml:"net,omitempty"`
-
-		// Host specifies an externally-reachable address for the registry, as a fully
-		// qualified URL.
-		Host string `yaml:"host,omitempty"`
-
-		Prefix string `yaml:"prefix,omitempty"`
-
-		// Secret specifies the secret key which HMAC tokens are created with.
-		Secret string `yaml:"secret,omitempty"`
-
-		// TLS instructs the http server to listen with a TLS configuration.
-		// This only support simple tls configuration with a cert and key.
-		// Mostly, this is useful for testing situations or simple deployments
-		// that require tls. If more complex configurations are required, use
-		// a proxy or make a proposal to add support here.
-		TLS struct {
-			// Certificate specifies the path to an x509 certificate file to
-			// be used for TLS.
-			Certificate string `yaml:"certificate,omitempty"`
-
-			// Key specifies the path to the x509 key file, which should
-			// contain the private portion for the file specified in
-			// Certificate.
-			Key string `yaml:"key,omitempty"`
-
-			// Specifies the CA certs for client authentication
-			// A file may contain multiple CA certificates encoded as PEM
-			ClientCAs []string `yaml:"clientcas,omitempty"`
-		} `yaml:"tls,omitempty"`
-
-		// Headers is a set of headers to include in HTTP responses. A common
-		// use case for this would be security headers such as
-		// Strict-Transport-Security. The map keys are the header names, and
-		// the values are the associated header payloads.
-		Headers http.Header `yaml:"headers,omitempty"`
-
-		// Debug configures the http debug interface, if specified. This can
-		// include services such as pprof, expvar and other data that should
-		// not be exposed externally. Left disabled by default.
-		Debug struct {
-			// Addr specifies the bind address for the debug server.
-			Addr string `yaml:"addr,omitempty"`
-		} `yaml:"debug,omitempty"`
-	} `yaml:"http,omitempty"`
-
-	// Notifications specifies configuration about various endpoint to which
-	// registry events are dispatched.
-	Notifications Notifications `yaml:"notifications,omitempty"`
-
-	// Redis configures the redis pool available to the registry webapp.
-	Redis struct {
-		// Addr specifies the the redis instance available to the application.
-		Addr string `yaml:"addr,omitempty"`
-
-		// Password string to use when making a connection.
-		Password string `yaml:"password,omitempty"`
-
-		// DB specifies the database to connect to on the redis instance.
-		DB int `yaml:"db,omitempty"`
-
-		DialTimeout  time.Duration `yaml:"dialtimeout,omitempty"`  // timeout for connect
-		ReadTimeout  time.Duration `yaml:"readtimeout,omitempty"`  // timeout for reads of data
-		WriteTimeout time.Duration `yaml:"writetimeout,omitempty"` // timeout for writes of data
-
-		// Pool configures the behavior of the redis connection pool.
-		Pool struct {
-			// MaxIdle sets the maximum number of idle connections.
-			MaxIdle int `yaml:"maxidle,omitempty"`
-
-			// MaxActive sets the maximum number of connections that should be
-			// opened before blocking a connection request.
-			MaxActive int `yaml:"maxactive,omitempty"`
-
-			// IdleTimeout sets the amount time to wait before closing
-			// inactive connections.
-			IdleTimeout time.Duration `yaml:"idletimeout,omitempty"`
-		} `yaml:"pool,omitempty"`
-	} `yaml:"redis,omitempty"`
-
-	Health Health `yaml:"health,omitempty"`
-
-	Proxy Proxy `yaml:"proxy,omitempty"`
-}
-
-// LogHook is composed of hook Level and Type.
-// After hooks configuration, it can execute the next handling automatically,
-// when defined levels of log message emitted.
-// Example: hook can sending an email notification when error log happens in app.
-type LogHook struct {
-	// Disable lets user select to enable hook or not.
-	Disabled bool `yaml:"disabled,omitempty"`
-
-	// Type allows user to select which type of hook handler they want.
-	Type string `yaml:"type,omitempty"`
-
-	// Levels set which levels of log message will let hook executed.
-	Levels []string `yaml:"levels,omitempty"`
-
-	// MailOptions allows user to configurate email parameters.
-	MailOptions MailOptions `yaml:"options,omitempty"`
-}
-
-// MailOptions provides the configuration sections to user, for specific handler.
-type MailOptions struct {
-	SMTP struct {
-		// Addr defines smtp host address
-		Addr string `yaml:"addr,omitempty"`
-
-		// Username defines user name to smtp host
-		Username string `yaml:"username,omitempty"`
-
-		// Password defines password of login user
-		Password string `yaml:"password,omitempty"`
-
-		// Insecure defines if smtp login skips the secure cerification.
-		Insecure bool `yaml:"insecure,omitempty"`
-	} `yaml:"smtp,omitempty"`
-
-	// From defines mail sending address
-	From string `yaml:"from,omitempty"`
-
-	// To defines mail receiving address
-	To []string `yaml:"to,omitempty"`
-}
-
-// FileChecker is a type of entry in the health section for checking files.
-type FileChecker struct {
-	// Interval is the duration in between checks
-	Interval time.Duration `yaml:"interval,omitempty"`
-	// File is the path to check
-	File string `yaml:"file,omitempty"`
-	// Threshold is the number of times a check must fail to trigger an
-	// unhealthy state
-	Threshold int `yaml:"threshold,omitempty"`
-}
-
-// HTTPChecker is a type of entry in the health section for checking HTTP URIs.
-type HTTPChecker struct {
-	// Timeout is the duration to wait before timing out the HTTP request
-	Timeout time.Duration `yaml:"interval,omitempty"`
-	// StatusCode is the expected status code
-	StatusCode int
-	// Interval is the duration in between checks
-	Interval time.Duration `yaml:"interval,omitempty"`
-	// URI is the HTTP URI to check
-	URI string `yaml:"uri,omitempty"`
-	// Headers lists static headers that should be added to all requests
-	Headers http.Header `yaml:"headers"`
-	// Threshold is the number of times a check must fail to trigger an
-	// unhealthy state
-	Threshold int `yaml:"threshold,omitempty"`
-}
-
-// TCPChecker is a type of entry in the health section for checking TCP servers.
-type TCPChecker struct {
-	// Timeout is the duration to wait before timing out the TCP connection
-	Timeout time.Duration `yaml:"interval,omitempty"`
-	// Interval is the duration in between checks
-	Interval time.Duration `yaml:"interval,omitempty"`
-	// Addr is the TCP address to check
-	Addr string `yaml:"addr,omitempty"`
-	// Threshold is the number of times a check must fail to trigger an
-	// unhealthy state
-	Threshold int `yaml:"threshold,omitempty"`
-}
-
-// Health provides the configuration section for health checks.
-type Health struct {
-	// FileCheckers is a list of paths to check
-	FileCheckers []FileChecker `yaml:"file,omitempty"`
-	// HTTPCheckers is a list of URIs to check
-	HTTPCheckers []HTTPChecker `yaml:"http,omitempty"`
-	// TCPCheckers is a list of URIs to check
-	TCPCheckers []TCPChecker `yaml:"tcp,omitempty"`
-	// StorageDriver configures a health check on the configured storage
-	// driver
-	StorageDriver struct {
-		// Enabled turns on the health check for the storage driver
-		Enabled bool `yaml:"enabled,omitempty"`
-		// Interval is the duration in between checks
-		Interval time.Duration `yaml:"interval,omitempty"`
-		// Threshold is the number of times a check must fail to trigger an
-		// unhealthy state
-		Threshold int `yaml:"threshold,omitempty"`
-	} `yaml:"storagedriver,omitempty"`
-}
-
-// v0_1Configuration is a Version 0.1 Configuration struct
-// This is currently aliased to Configuration, as it is the current version
-type v0_1Configuration Configuration
-
-// UnmarshalYAML implements the yaml.Unmarshaler interface
-// Unmarshals a string of the form X.Y into a Version, validating that X and Y can represent uints
-func (version *Version) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	var versionString string
-	err := unmarshal(&versionString)
-	if err != nil {
-		return err
-	}
-
-	newVersion := Version(versionString)
-	if _, err := newVersion.major(); err != nil {
-		return err
-	}
-
-	if _, err := newVersion.minor(); err != nil {
-		return err
-	}
-
-	*version = newVersion
-	return nil
-}
-
-// CurrentVersion is the most recent Version that can be parsed
-var CurrentVersion = MajorMinorVersion(0, 1)
-
-// Loglevel is the level at which operations are logged
-// This can be error, warn, info, or debug
-type Loglevel string
-
-// UnmarshalYAML implements the yaml.Umarshaler interface
-// Unmarshals a string into a Loglevel, lowercasing the string and validating that it represents a
-// valid loglevel
-func (loglevel *Loglevel) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	var loglevelString string
-	err := unmarshal(&loglevelString)
-	if err != nil {
-		return err
-	}
-
-	loglevelString = strings.ToLower(loglevelString)
-	switch loglevelString {
-	case "error", "warn", "info", "debug":
-	default:
-		return fmt.Errorf("Invalid loglevel %s Must be one of [error, warn, info, debug]", loglevelString)
-	}
-
-	*loglevel = Loglevel(loglevelString)
-	return nil
-}
-
-// Parameters defines a key-value parameters mapping
-type Parameters map[string]interface{}
-
-// Storage defines the configuration for registry object storage
-type Storage map[string]Parameters
-
-// Type returns the storage driver type, such as filesystem or s3
-func (storage Storage) Type() string {
-	var storageType []string
-
-	// Return only key in this map
-	for k := range storage {
-		switch k {
-		case "maintenance":
-			// allow configuration of maintenance
-		case "cache":
-			// allow configuration of caching
-		case "delete":
-			// allow configuration of delete
-		case "redirect":
-			// allow configuration of redirect
-		default:
-			storageType = append(storageType, k)
-		}
-	}
-	if len(storageType) > 1 {
-		panic("multiple storage drivers specified in configuration or environment: " + strings.Join(storageType, ", "))
-	}
-	if len(storageType) == 1 {
-		return storageType[0]
-	}
-	return ""
-}
-
-// Parameters returns the Parameters map for a Storage configuration
-func (storage Storage) Parameters() Parameters {
-	return storage[storage.Type()]
-}
-
-// setParameter changes the parameter at the provided key to the new value
-func (storage Storage) setParameter(key string, value interface{}) {
-	storage[storage.Type()][key] = value
-}
-
-// UnmarshalYAML implements the yaml.Unmarshaler interface
-// Unmarshals a single item map into a Storage or a string into a Storage type with no parameters
-func (storage *Storage) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	var storageMap map[string]Parameters
-	err := unmarshal(&storageMap)
-	if err == nil {
-		if len(storageMap) > 1 {
-			types := make([]string, 0, len(storageMap))
-			for k := range storageMap {
-				switch k {
-				case "maintenance":
-					// allow for configuration of maintenance
-				case "cache":
-					// allow configuration of caching
-				case "delete":
-					// allow configuration of delete
-				case "redirect":
-					// allow configuration of redirect
-				default:
-					types = append(types, k)
-				}
-			}
-
-			if len(types) > 1 {
-				return fmt.Errorf("Must provide exactly one storage type. Provided: %v", types)
-			}
-		}
-		*storage = storageMap
-		return nil
-	}
-
-	var storageType string
-	err = unmarshal(&storageType)
-	if err == nil {
-		*storage = Storage{storageType: Parameters{}}
-		return nil
-	}
-
-	return err
-}
-
-// MarshalYAML implements the yaml.Marshaler interface
-func (storage Storage) MarshalYAML() (interface{}, error) {
-	if storage.Parameters() == nil {
-		return storage.Type(), nil
-	}
-	return map[string]Parameters(storage), nil
-}
-
-// Auth defines the configuration for registry authorization.
-type Auth map[string]Parameters
-
-// Type returns the storage driver type, such as filesystem or s3
-func (auth Auth) Type() string {
-	// Return only key in this map
-	for k := range auth {
-		return k
-	}
-	return ""
-}
-
-// Parameters returns the Parameters map for an Auth configuration
-func (auth Auth) Parameters() Parameters {
-	return auth[auth.Type()]
-}
-
-// setParameter changes the parameter at the provided key to the new value
-func (auth Auth) setParameter(key string, value interface{}) {
-	auth[auth.Type()][key] = value
-}
-
-// UnmarshalYAML implements the yaml.Unmarshaler interface
-// Unmarshals a single item map into a Storage or a string into a Storage type with no parameters
-func (auth *Auth) UnmarshalYAML(unmarshal func(interface{}) error) error {
-	var m map[string]Parameters
-	err := unmarshal(&m)
-	if err == nil {
-		if len(m) > 1 {
-			types := make([]string, 0, len(m))
-			for k := range m {
-				types = append(types, k)
-			}
-
-			// TODO(stevvooe): May want to change this slightly for
-			// authorization to allow multiple challenges.
-			return fmt.Errorf("must provide exactly one type. Provided: %v", types)
-
-		}
-		*auth = m
-		return nil
-	}
-
-	var authType string
-	err = unmarshal(&authType)
-	if err == nil {
-		*auth = Auth{authType: Parameters{}}
-		return nil
-	}
-
-	return err
-}
-
-// MarshalYAML implements the yaml.Marshaler interface
-func (auth Auth) MarshalYAML() (interface{}, error) {
-	if auth.Parameters() == nil {
-		return auth.Type(), nil
-	}
-	return map[string]Parameters(auth), nil
-}
-
-// Notifications configures multiple http endpoints.
-type Notifications struct {
-	// Endpoints is a list of http configurations for endpoints that
-	// respond to webhook notifications. In the future, we may allow other
-	// kinds of endpoints, such as external queues.
-	Endpoints []Endpoint `yaml:"endpoints,omitempty"`
-}
-
-// Endpoint describes the configuration of an http webhook notification
-// endpoint.
-type Endpoint struct {
-	Name      string        `yaml:"name"`      // identifies the endpoint in the registry instance.
-	Disabled  bool          `yaml:"disabled"`  // disables the endpoint
-	URL       string        `yaml:"url"`       // post url for the endpoint.
-	Headers   http.Header   `yaml:"headers"`   // static headers that should be added to all requests
-	Timeout   time.Duration `yaml:"timeout"`   // HTTP timeout
-	Threshold int           `yaml:"threshold"` // circuit breaker threshold before backing off on failure
-	Backoff   time.Duration `yaml:"backoff"`   // backoff duration
-}
-
-// Reporting defines error reporting methods.
-type Reporting struct {
-	// Bugsnag configures error reporting for Bugsnag (bugsnag.com).
-	Bugsnag BugsnagReporting `yaml:"bugsnag,omitempty"`
-	// NewRelic configures error reporting for NewRelic (newrelic.com)
-	NewRelic NewRelicReporting `yaml:"newrelic,omitempty"`
-}
-
-// BugsnagReporting configures error reporting for Bugsnag (bugsnag.com).
-type BugsnagReporting struct {
-	// APIKey is the Bugsnag api key.
-	APIKey string `yaml:"apikey,omitempty"`
-	// ReleaseStage tracks where the registry is deployed.
-	// Examples: production, staging, development
-	ReleaseStage string `yaml:"releasestage,omitempty"`
-	// Endpoint is used for specifying an enterprise Bugsnag endpoint.
-	Endpoint string `yaml:"endpoint,omitempty"`
-}
-
-// NewRelicReporting configures error reporting for NewRelic (newrelic.com)
-type NewRelicReporting struct {
-	// LicenseKey is the NewRelic user license key
-	LicenseKey string `yaml:"licensekey,omitempty"`
-	// Name is the component name of the registry in NewRelic
-	Name string `yaml:"name,omitempty"`
-	// Verbose configures debug output to STDOUT
-	Verbose bool `yaml:"verbose,omitempty"`
-}
-
-// Middleware configures named middlewares to be applied at injection points.
-type Middleware struct {
-	// Name the middleware registers itself as
-	Name string `yaml:"name"`
-	// Flag to disable middleware easily
-	Disabled bool `yaml:"disabled,omitempty"`
-	// Map of parameters that will be passed to the middleware's initialization function
-	Options Parameters `yaml:"options"`
-}
-
-// Proxy configures the registry as a pull through cache
-type Proxy struct {
-	// RemoteURL is the URL of the remote registry
-	RemoteURL string `yaml:"remoteurl"`
-
-	// Username of the hub user
-	Username string `yaml:"username"`
-
-	// Password of the hub user
-	Password string `yaml:"password"`
-}
-
-// Parse parses an input configuration yaml document into a Configuration struct
-// This should generally be capable of handling old configuration format versions
-//
-// Environment variables may be used to override configuration parameters other than version,
-// following the scheme below:
-// Configuration.Abc may be replaced by the value of REGISTRY_ABC,
-// Configuration.Abc.Xyz may be replaced by the value of REGISTRY_ABC_XYZ, and so forth
-func Parse(rd io.Reader) (*Configuration, error) {
-	in, err := ioutil.ReadAll(rd)
-	if err != nil {
-		return nil, err
-	}
-
-	p := NewParser("registry", []VersionedParseInfo{
-		{
-			Version: MajorMinorVersion(0, 1),
-			ParseAs: reflect.TypeOf(v0_1Configuration{}),
-			ConversionFunc: func(c interface{}) (interface{}, error) {
-				if v0_1, ok := c.(*v0_1Configuration); ok {
-					if v0_1.Loglevel == Loglevel("") {
-						v0_1.Loglevel = Loglevel("info")
-					}
-					if v0_1.Storage.Type() == "" {
-						return nil, fmt.Errorf("No storage configuration provided")
-					}
-					return (*Configuration)(v0_1), nil
-				}
-				return nil, fmt.Errorf("Expected *v0_1Configuration, received %#v", c)
-			},
-		},
-	})
-
-	config := new(Configuration)
-	err = p.Parse(in, config)
-	if err != nil {
-		return nil, err
-	}
-
-	return config, nil
-}

Godeps/_workspace/src/github.com/docker/distribution/configuration/parser.go

@@ -1,283 +0,0 @@
-package configuration
-
-import (
-	"fmt"
-	"os"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-
-	"github.com/Sirupsen/logrus"
-	"gopkg.in/yaml.v2"
-)
-
-// Version is a major/minor version pair of the form Major.Minor
-// Major version upgrades indicate structure or type changes
-// Minor version upgrades should be strictly additive
-type Version string
-
-// MajorMinorVersion constructs a Version from its Major and Minor components
-func MajorMinorVersion(major, minor uint) Version {
-	return Version(fmt.Sprintf("%d.%d", major, minor))
-}
-
-func (version Version) major() (uint, error) {
-	majorPart := strings.Split(string(version), ".")[0]
-	major, err := strconv.ParseUint(majorPart, 10, 0)
-	return uint(major), err
-}
-
-// Major returns the major version portion of a Version
-func (version Version) Major() uint {
-	major, _ := version.major()
-	return major
-}
-
-func (version Version) minor() (uint, error) {
-	minorPart := strings.Split(string(version), ".")[1]
-	minor, err := strconv.ParseUint(minorPart, 10, 0)
-	return uint(minor), err
-}
-
-// Minor returns the minor version portion of a Version
-func (version Version) Minor() uint {
-	minor, _ := version.minor()
-	return minor
-}
-
-// VersionedParseInfo defines how a specific version of a configuration should
-// be parsed into the current version
-type VersionedParseInfo struct {
-	// Version is the version which this parsing information relates to
-	Version Version
-	// ParseAs defines the type which a configuration file of this version
-	// should be parsed into
-	ParseAs reflect.Type
-	// ConversionFunc defines a method for converting the parsed configuration
-	// (of type ParseAs) into the current configuration version
-	// Note: this method signature is very unclear with the absence of generics
-	ConversionFunc func(interface{}) (interface{}, error)
-}
-
-type envVar struct {
-	name  string
-	value string
-}
-
-type envVars []envVar
-
-func (a envVars) Len() int           { return len(a) }
-func (a envVars) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
-func (a envVars) Less(i, j int) bool { return a[i].name < a[j].name }
-
-// Parser can be used to parse a configuration file and environment of a defined
-// version into a unified output structure
-type Parser struct {
-	prefix  string
-	mapping map[Version]VersionedParseInfo
-	env     envVars
-}
-
-// NewParser returns a *Parser with the given environment prefix which handles
-// versioned configurations which match the given parseInfos
-func NewParser(prefix string, parseInfos []VersionedParseInfo) *Parser {
-	p := Parser{prefix: prefix, mapping: make(map[Version]VersionedParseInfo)}
-
-	for _, parseInfo := range parseInfos {
-		p.mapping[parseInfo.Version] = parseInfo
-	}
-
-	for _, env := range os.Environ() {
-		envParts := strings.SplitN(env, "=", 2)
-		p.env = append(p.env, envVar{envParts[0], envParts[1]})
-	}
-
-	// We must sort the environment variables lexically by name so that
-	// more specific variables are applied before less specific ones
-	// (i.e. REGISTRY_STORAGE before
-	// REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY). This sucks, but it's a
-	// lot simpler and easier to get right than unmarshalling map entries
-	// into temporaries and merging with the existing entry.
-	sort.Sort(p.env)
-
-	return &p
-}
-
-// Parse reads in the given []byte and environment and writes the resulting
-// configuration into the input v
-//
-// Environment variables may be used to override configuration parameters other
-// than version, following the scheme below:
-// v.Abc may be replaced by the value of PREFIX_ABC,
-// v.Abc.Xyz may be replaced by the value of PREFIX_ABC_XYZ, and so forth
-func (p *Parser) Parse(in []byte, v interface{}) error {
-	var versionedStruct struct {
-		Version Version
-	}
-
-	if err := yaml.Unmarshal(in, &versionedStruct); err != nil {
-		return err
-	}
-
-	parseInfo, ok := p.mapping[versionedStruct.Version]
-	if !ok {
-		return fmt.Errorf("Unsupported version: %q", versionedStruct.Version)
-	}
-
-	parseAs := reflect.New(parseInfo.ParseAs)
-	err := yaml.Unmarshal(in, parseAs.Interface())
-	if err != nil {
-		return err
-	}
-
-	for _, envVar := range p.env {
-		pathStr := envVar.name
-		if strings.HasPrefix(pathStr, strings.ToUpper(p.prefix)+"_") {
-			path := strings.Split(pathStr, "_")
-
-			err = p.overwriteFields(parseAs, pathStr, path[1:], envVar.value)
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	c, err := parseInfo.ConversionFunc(parseAs.Interface())
-	if err != nil {
-		return err
-	}
-	reflect.ValueOf(v).Elem().Set(reflect.Indirect(reflect.ValueOf(c)))
-	return nil
-}
-
-// overwriteFields replaces configuration values with alternate values specified
-// through the environment. Precondition: an empty path slice must never be
-// passed in.
-func (p *Parser) overwriteFields(v reflect.Value, fullpath string, path []string, payload string) error {
-	for v.Kind() == reflect.Ptr {
-		if v.IsNil() {
-			panic("encountered nil pointer while handling environment variable " + fullpath)
-		}
-		v = reflect.Indirect(v)
-	}
-	switch v.Kind() {
-	case reflect.Struct:
-		return p.overwriteStruct(v, fullpath, path, payload)
-	case reflect.Map:
-		return p.overwriteMap(v, fullpath, path, payload)
-	case reflect.Interface:
-		if v.NumMethod() == 0 {
-			if !v.IsNil() {
-				return p.overwriteFields(v.Elem(), fullpath, path, payload)
-			}
-			// Interface was empty; create an implicit map
-			var template map[string]interface{}
-			wrappedV := reflect.MakeMap(reflect.TypeOf(template))
-			v.Set(wrappedV)
-			return p.overwriteMap(wrappedV, fullpath, path, payload)
-		}
-	}
-	return nil
-}
-
-func (p *Parser) overwriteStruct(v reflect.Value, fullpath string, path []string, payload string) error {
-	// Generate case-insensitive map of struct fields
-	byUpperCase := make(map[string]int)
-	for i := 0; i < v.NumField(); i++ {
-		sf := v.Type().Field(i)
-		upper := strings.ToUpper(sf.Name)
-		if _, present := byUpperCase[upper]; present {
-			panic(fmt.Sprintf("field name collision in configuration object: %s", sf.Name))
-		}
-		byUpperCase[upper] = i
-	}
-
-	fieldIndex, present := byUpperCase[path[0]]
-	if !present {
-		logrus.Warnf("Ignoring unrecognized environment variable %s", fullpath)
-		return nil
-	}
-	field := v.Field(fieldIndex)
-	sf := v.Type().Field(fieldIndex)
-
-	if len(path) == 1 {
-		// Env var specifies this field directly
-		fieldVal := reflect.New(sf.Type)
-		err := yaml.Unmarshal([]byte(payload), fieldVal.Interface())
-		if err != nil {
-			return err
-		}
-		field.Set(reflect.Indirect(fieldVal))
-		return nil
-	}
-
-	// If the field is nil, must create an object
-	switch sf.Type.Kind() {
-	case reflect.Map:
-		if field.IsNil() {
-			field.Set(reflect.MakeMap(sf.Type))
-		}
-	case reflect.Ptr:
-		if field.IsNil() {
-			field.Set(reflect.New(sf.Type))
-		}
-	}
-
-	err := p.overwriteFields(field, fullpath, path[1:], payload)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (p *Parser) overwriteMap(m reflect.Value, fullpath string, path []string, payload string) error {
-	if m.Type().Key().Kind() != reflect.String {
-		// non-string keys unsupported
-		logrus.Warnf("Ignoring environment variable %s involving map with non-string keys", fullpath)
-		return nil
-	}
-
-	if len(path) > 1 {
-		// If a matching key exists, get its value and continue the
-		// overwriting process.
-		for _, k := range m.MapKeys() {
-			if strings.ToUpper(k.String()) == path[0] {
-				mapValue := m.MapIndex(k)
-				// If the existing value is nil, we want to
-				// recreate it instead of using this value.
-				if (mapValue.Kind() == reflect.Ptr ||
-					mapValue.Kind() == reflect.Interface ||
-					mapValue.Kind() == reflect.Map) &&
-					mapValue.IsNil() {
-					break
-				}
-				return p.overwriteFields(mapValue, fullpath, path[1:], payload)
-			}
-		}
-	}
-
-	// (Re)create this key
-	var mapValue reflect.Value
-	if m.Type().Elem().Kind() == reflect.Map {
-		mapValue = reflect.MakeMap(m.Type().Elem())
-	} else {
-		mapValue = reflect.New(m.Type().Elem())
-	}
-	if len(path) > 1 {
-		err := p.overwriteFields(mapValue, fullpath, path[1:], payload)
-		if err != nil {
-			return err
-		}
-	} else {
-		err := yaml.Unmarshal([]byte(payload), mapValue.Interface())
-		if err != nil {
-			return err
-		}
-	}
-
-	m.SetMapIndex(reflect.ValueOf(strings.ToLower(path[0])), reflect.Indirect(mapValue))
-
-	return nil
-}

Godeps/_workspace/src/github.com/docker/distribution/context/context.go

@@ -1,85 +0,0 @@
-package context
-
-import (
-	"sync"
-
-	"github.com/docker/distribution/uuid"
-	"golang.org/x/net/context"
-)
-
-// Context is a copy of Context from the golang.org/x/net/context package.
-type Context interface {
-	context.Context
-}
-
-// instanceContext is a context that provides only an instance id. It is
-// provided as the main background context.
-type instanceContext struct {
-	Context
-	id   string    // id of context, logged as "instance.id"
-	once sync.Once // once protect generation of the id
-}
-
-func (ic *instanceContext) Value(key interface{}) interface{} {
-	if key == "instance.id" {
-		ic.once.Do(func() {
-			// We want to lazy initialize the UUID such that we don't
-			// call a random generator from the package initialization
-			// code. For various reasons random could not be available
-			// https://github.com/docker/distribution/issues/782
-			ic.id = uuid.Generate().String()
-		})
-		return ic.id
-	}
-
-	return ic.Context.Value(key)
-}
-
-var background = &instanceContext{
-	Context: context.Background(),
-}
-
-// Background returns a non-nil, empty Context. The background context
-// provides a single key, "instance.id" that is globally unique to the
-// process.
-func Background() Context {
-	return background
-}
-
-// WithValue returns a copy of parent in which the value associated with key is
-// val. Use context Values only for request-scoped data that transits processes
-// and APIs, not for passing optional parameters to functions.
-func WithValue(parent Context, key, val interface{}) Context {
-	return context.WithValue(parent, key, val)
-}
-
-// stringMapContext is a simple context implementation that checks a map for a
-// key, falling back to a parent if not present.
-type stringMapContext struct {
-	context.Context
-	m map[string]interface{}
-}
-
-// WithValues returns a context that proxies lookups through a map. Only
-// supports string keys.
-func WithValues(ctx context.Context, m map[string]interface{}) context.Context {
-	mo := make(map[string]interface{}, len(m)) // make our own copy.
-	for k, v := range m {
-		mo[k] = v
-	}
-
-	return stringMapContext{
-		Context: ctx,
-		m:       mo,
-	}
-}
-
-func (smc stringMapContext) Value(key interface{}) interface{} {
-	if ks, ok := key.(string); ok {
-		if v, ok := smc.m[ks]; ok {
-			return v
-		}
-	}
-
-	return smc.Context.Value(key)
-}

Godeps/_workspace/src/github.com/docker/distribution/context/doc.go

@@ -1,89 +0,0 @@
-// Package context provides several utilities for working with
-// golang.org/x/net/context in http requests. Primarily, the focus is on
-// logging relevent request information but this package is not limited to
-// that purpose.
-//
-// The easiest way to get started is to get the background context:
-//
-// 	ctx := context.Background()
-//
-// The returned context should be passed around your application and be the
-// root of all other context instances. If the application has a version, this
-// line should be called before anything else:
-//
-// 	ctx := context.WithVersion(context.Background(), version)
-//
-// The above will store the version in the context and will be available to
-// the logger.
-//
-// Logging
-//
-// The most useful aspect of this package is GetLogger. This function takes
-// any context.Context interface and returns the current logger from the
-// context. Canonical usage looks like this:
-//
-// 	GetLogger(ctx).Infof("something interesting happened")
-//
-// GetLogger also takes optional key arguments. The keys will be looked up in
-// the context and reported with the logger. The following example would
-// return a logger that prints the version with each log message:
-//
-// 	ctx := context.Context(context.Background(), "version", version)
-// 	GetLogger(ctx, "version").Infof("this log message has a version field")
-//
-// The above would print out a log message like this:
-//
-// 	INFO[0000] this log message has a version field        version=v2.0.0-alpha.2.m
-//
-// When used with WithLogger, we gain the ability to decorate the context with
-// loggers that have information from disparate parts of the call stack.
-// Following from the version example, we can build a new context with the
-// configured logger such that we always print the version field:
-//
-// 	ctx = WithLogger(ctx, GetLogger(ctx, "version"))
-//
-// Since the logger has been pushed to the context, we can now get the version
-// field for free with our log messages. Future calls to GetLogger on the new
-// context will have the version field:
-//
-// 	GetLogger(ctx).Infof("this log message has a version field")
-//
-// This becomes more powerful when we start stacking loggers. Let's say we
-// have the version logger from above but also want a request id. Using the
-// context above, in our request scoped function, we place another logger in
-// the context:
-//
-// 	ctx = context.WithValue(ctx, "http.request.id", "unique id") // called when building request context
-// 	ctx = WithLogger(ctx, GetLogger(ctx, "http.request.id"))
-//
-// When GetLogger is called on the new context, "http.request.id" will be
-// included as a logger field, along with the original "version" field:
-//
-// 	INFO[0000] this log message has a version field        http.request.id=unique id version=v2.0.0-alpha.2.m
-//
-// Note that this only affects the new context, the previous context, with the
-// version field, can be used independently. Put another way, the new logger,
-// added to the request context, is unique to that context and can have
-// request scoped varaibles.
-//
-// HTTP Requests
-//
-// This package also contains several methods for working with http requests.
-// The concepts are very similar to those described above. We simply place the
-// request in the context using WithRequest. This makes the request variables
-// available. GetRequestLogger can then be called to get request specific
-// variables in a log line:
-//
-// 	ctx = WithRequest(ctx, req)
-// 	GetRequestLogger(ctx).Infof("request variables")
-//
-// Like above, if we want to include the request data in all log messages in
-// the context, we push the logger to a new context and use that one:
-//
-// 	ctx = WithLogger(ctx, GetRequestLogger(ctx))
-//
-// The concept is fairly powerful and ensures that calls throughout the stack
-// can be traced in log messages. Using the fields like "http.request.id", one
-// can analyze call flow for a particular request with a simple grep of the
-// logs.
-package context

Godeps/_workspace/src/github.com/docker/distribution/context/http.go

@@ -1,364 +0,0 @@
-package context
-
-import (
-	"errors"
-	"net"
-	"net/http"
-	"strings"
-	"sync"
-	"time"
-
-	log "github.com/Sirupsen/logrus"
-	"github.com/docker/distribution/uuid"
-	"github.com/gorilla/mux"
-)
-
-// Common errors used with this package.
-var (
-	ErrNoRequestContext        = errors.New("no http request in context")
-	ErrNoResponseWriterContext = errors.New("no http response in context")
-)
-
-func parseIP(ipStr string) net.IP {
-	ip := net.ParseIP(ipStr)
-	if ip == nil {
-		log.Warnf("invalid remote IP address: %q", ipStr)
-	}
-	return ip
-}
-
-// RemoteAddr extracts the remote address of the request, taking into
-// account proxy headers.
-func RemoteAddr(r *http.Request) string {
-	if prior := r.Header.Get("X-Forwarded-For"); prior != "" {
-		proxies := strings.Split(prior, ",")
-		if len(proxies) > 0 {
-			remoteAddr := strings.Trim(proxies[0], " ")
-			if parseIP(remoteAddr) != nil {
-				return remoteAddr
-			}
-		}
-	}
-	// X-Real-Ip is less supported, but worth checking in the
-	// absence of X-Forwarded-For
-	if realIP := r.Header.Get("X-Real-Ip"); realIP != "" {
-		if parseIP(realIP) != nil {
-			return realIP
-		}
-	}
-
-	return r.RemoteAddr
-}
-
-// RemoteIP extracts the remote IP of the request, taking into
-// account proxy headers.
-func RemoteIP(r *http.Request) string {
-	addr := RemoteAddr(r)
-
-	// Try parsing it as "IP:port"
-	if ip, _, err := net.SplitHostPort(addr); err == nil {
-		return ip
-	}
-
-	return addr
-}
-
-// WithRequest places the request on the context. The context of the request
-// is assigned a unique id, available at "http.request.id". The request itself
-// is available at "http.request". Other common attributes are available under
-// the prefix "http.request.". If a request is already present on the context,
-// this method will panic.
-func WithRequest(ctx Context, r *http.Request) Context {
-	if ctx.Value("http.request") != nil {
-		// NOTE(stevvooe): This needs to be considered a programming error. It
-		// is unlikely that we'd want to have more than one request in
-		// context.
-		panic("only one request per context")
-	}
-
-	return &httpRequestContext{
-		Context:   ctx,
-		startedAt: time.Now(),
-		id:        uuid.Generate().String(),
-		r:         r,
-	}
-}
-
-// GetRequest returns the http request in the given context. Returns
-// ErrNoRequestContext if the context does not have an http request associated
-// with it.
-func GetRequest(ctx Context) (*http.Request, error) {
-	if r, ok := ctx.Value("http.request").(*http.Request); r != nil && ok {
-		return r, nil
-	}
-	return nil, ErrNoRequestContext
-}
-
-// GetRequestID attempts to resolve the current request id, if possible. An
-// error is return if it is not available on the context.
-func GetRequestID(ctx Context) string {
-	return GetStringValue(ctx, "http.request.id")
-}
-
-// WithResponseWriter returns a new context and response writer that makes
-// interesting response statistics available within the context.
-func WithResponseWriter(ctx Context, w http.ResponseWriter) (Context, http.ResponseWriter) {
-	irw := instrumentedResponseWriter{
-		ResponseWriter: w,
-		Context:        ctx,
-	}
-
-	if closeNotifier, ok := w.(http.CloseNotifier); ok {
-		irwCN := &instrumentedResponseWriterCN{
-			instrumentedResponseWriter: irw,
-			CloseNotifier:              closeNotifier,
-		}
-
-		return irwCN, irwCN
-	}
-
-	return &irw, &irw
-}
-
-// GetResponseWriter returns the http.ResponseWriter from the provided
-// context. If not present, ErrNoResponseWriterContext is returned. The
-// returned instance provides instrumentation in the context.
-func GetResponseWriter(ctx Context) (http.ResponseWriter, error) {
-	v := ctx.Value("http.response")
-
-	rw, ok := v.(http.ResponseWriter)
-	if !ok || rw == nil {
-		return nil, ErrNoResponseWriterContext
-	}
-
-	return rw, nil
-}
-
-// getVarsFromRequest let's us change request vars implementation for testing
-// and maybe future changes.
-var getVarsFromRequest = mux.Vars
-
-// WithVars extracts gorilla/mux vars and makes them available on the returned
-// context. Variables are available at keys with the prefix "vars.". For
-// example, if looking for the variable "name", it can be accessed as
-// "vars.name". Implementations that are accessing values need not know that
-// the underlying context is implemented with gorilla/mux vars.
-func WithVars(ctx Context, r *http.Request) Context {
-	return &muxVarsContext{
-		Context: ctx,
-		vars:    getVarsFromRequest(r),
-	}
-}
-
-// GetRequestLogger returns a logger that contains fields from the request in
-// the current context. If the request is not available in the context, no
-// fields will display. Request loggers can safely be pushed onto the context.
-func GetRequestLogger(ctx Context) Logger {
-	return GetLogger(ctx,
-		"http.request.id",
-		"http.request.method",
-		"http.request.host",
-		"http.request.uri",
-		"http.request.referer",
-		"http.request.useragent",
-		"http.request.remoteaddr",
-		"http.request.contenttype")
-}
-
-// GetResponseLogger reads the current response stats and builds a logger.
-// Because the values are read at call time, pushing a logger returned from
-// this function on the context will lead to missing or invalid data. Only
-// call this at the end of a request, after the response has been written.
-func GetResponseLogger(ctx Context) Logger {
-	l := getLogrusLogger(ctx,
-		"http.response.written",
-		"http.response.status",
-		"http.response.contenttype")
-
-	duration := Since(ctx, "http.request.startedat")
-
-	if duration > 0 {
-		l = l.WithField("http.response.duration", duration.String())
-	}
-
-	return l
-}
-
-// httpRequestContext makes information about a request available to context.
-type httpRequestContext struct {
-	Context
-
-	startedAt time.Time
-	id        string
-	r         *http.Request
-}
-
-// Value returns a keyed element of the request for use in the context. To get
-// the request itself, query "request". For other components, access them as
-// "request.<component>". For example, r.RequestURI
-func (ctx *httpRequestContext) Value(key interface{}) interface{} {
-	if keyStr, ok := key.(string); ok {
-		if keyStr == "http.request" {
-			return ctx.r
-		}
-
-		if !strings.HasPrefix(keyStr, "http.request.") {
-			goto fallback
-		}
-
-		parts := strings.Split(keyStr, ".")
-
-		if len(parts) != 3 {
-			goto fallback
-		}
-
-		switch parts[2] {
-		case "uri":
-			return ctx.r.RequestURI
-		case "remoteaddr":
-			return RemoteAddr(ctx.r)
-		case "method":
-			return ctx.r.Method
-		case "host":
-			return ctx.r.Host
-		case "referer":
-			referer := ctx.r.Referer()
-			if referer != "" {
-				return referer
-			}
-		case "useragent":
-			return ctx.r.UserAgent()
-		case "id":
-			return ctx.id
-		case "startedat":
-			return ctx.startedAt
-		case "contenttype":
-			ct := ctx.r.Header.Get("Content-Type")
-			if ct != "" {
-				return ct
-			}
-		}
-	}
-
-fallback:
-	return ctx.Context.Value(key)
-}
-
-type muxVarsContext struct {
-	Context
-	vars map[string]string
-}
-
-func (ctx *muxVarsContext) Value(key interface{}) interface{} {
-	if keyStr, ok := key.(string); ok {
-		if keyStr == "vars" {
-			return ctx.vars
-		}
-
-		if strings.HasPrefix(keyStr, "vars.") {
-			keyStr = strings.TrimPrefix(keyStr, "vars.")
-		}
-
-		if v, ok := ctx.vars[keyStr]; ok {
-			return v
-		}
-	}
-
-	return ctx.Context.Value(key)
-}
-
-// instrumentedResponseWriterCN provides response writer information in a
-// context. It implements http.CloseNotifier so that users can detect
-// early disconnects.
-type instrumentedResponseWriterCN struct {
-	instrumentedResponseWriter
-	http.CloseNotifier
-}
-
-// instrumentedResponseWriter provides response writer information in a
-// context. This variant is only used in the case where CloseNotifier is not
-// implemented by the parent ResponseWriter.
-type instrumentedResponseWriter struct {
-	http.ResponseWriter
-	Context
-
-	mu      sync.Mutex
-	status  int
-	written int64
-}
-
-func (irw *instrumentedResponseWriter) Write(p []byte) (n int, err error) {
-	n, err = irw.ResponseWriter.Write(p)
-
-	irw.mu.Lock()
-	irw.written += int64(n)
-
-	// Guess the likely status if not set.
-	if irw.status == 0 {
-		irw.status = http.StatusOK
-	}
-
-	irw.mu.Unlock()
-
-	return
-}
-
-func (irw *instrumentedResponseWriter) WriteHeader(status int) {
-	irw.ResponseWriter.WriteHeader(status)
-
-	irw.mu.Lock()
-	irw.status = status
-	irw.mu.Unlock()
-}
-
-func (irw *instrumentedResponseWriter) Flush() {
-	if flusher, ok := irw.ResponseWriter.(http.Flusher); ok {
-		flusher.Flush()
-	}
-}
-
-func (irw *instrumentedResponseWriter) Value(key interface{}) interface{} {
-	if keyStr, ok := key.(string); ok {
-		if keyStr == "http.response" {
-			return irw
-		}
-
-		if !strings.HasPrefix(keyStr, "http.response.") {
-			goto fallback
-		}
-
-		parts := strings.Split(keyStr, ".")
-
-		if len(parts) != 3 {
-			goto fallback
-		}
-
-		irw.mu.Lock()
-		defer irw.mu.Unlock()
-
-		switch parts[2] {
-		case "written":
-			return irw.written
-		case "status":
-			return irw.status
-		case "contenttype":
-			contentType := irw.Header().Get("Content-Type")
-			if contentType != "" {
-				return contentType
-			}
-		}
-	}
-
-fallback:
-	return irw.Context.Value(key)
-}
-
-func (irw *instrumentedResponseWriterCN) Value(key interface{}) interface{} {
-	if keyStr, ok := key.(string); ok {
-		if keyStr == "http.response" {
-			return irw
-		}
-	}
-
-	return irw.instrumentedResponseWriter.Value(key)
-}

Godeps/_workspace/src/github.com/docker/distribution/context/logger.go

@@ -1,116 +0,0 @@
-package context
-
-import (
-	"fmt"
-
-	"github.com/Sirupsen/logrus"
-	"runtime"
-)
-
-// Logger provides a leveled-logging interface.
-type Logger interface {
-	// standard logger methods
-	Print(args ...interface{})
-	Printf(format string, args ...interface{})
-	Println(args ...interface{})
-
-	Fatal(args ...interface{})
-	Fatalf(format string, args ...interface{})
-	Fatalln(args ...interface{})
-
-	Panic(args ...interface{})
-	Panicf(format string, args ...interface{})
-	Panicln(args ...interface{})
-
-	// Leveled methods, from logrus
-	Debug(args ...interface{})
-	Debugf(format string, args ...interface{})
-	Debugln(args ...interface{})
-
-	Error(args ...interface{})
-	Errorf(format string, args ...interface{})
-	Errorln(args ...interface{})
-
-	Info(args ...interface{})
-	Infof(format string, args ...interface{})
-	Infoln(args ...interface{})
-
-	Warn(args ...interface{})
-	Warnf(format string, args ...interface{})
-	Warnln(args ...interface{})
-}
-
-// WithLogger creates a new context with provided logger.
-func WithLogger(ctx Context, logger Logger) Context {
-	return WithValue(ctx, "logger", logger)
-}
-
-// GetLoggerWithField returns a logger instance with the specified field key
-// and value without affecting the context. Extra specified keys will be
-// resolved from the context.
-func GetLoggerWithField(ctx Context, key, value interface{}, keys ...interface{}) Logger {
-	return getLogrusLogger(ctx, keys...).WithField(fmt.Sprint(key), value)
-}
-
-// GetLoggerWithFields returns a logger instance with the specified fields
-// without affecting the context. Extra specified keys will be resolved from
-// the context.
-func GetLoggerWithFields(ctx Context, fields map[interface{}]interface{}, keys ...interface{}) Logger {
-	// must convert from interface{} -> interface{} to string -> interface{} for logrus.
-	lfields := make(logrus.Fields, len(fields))
-	for key, value := range fields {
-		lfields[fmt.Sprint(key)] = value
-	}
-
-	return getLogrusLogger(ctx, keys...).WithFields(lfields)
-}
-
-// GetLogger returns the logger from the current context, if present. If one
-// or more keys are provided, they will be resolved on the context and
-// included in the logger. While context.Value takes an interface, any key
-// argument passed to GetLogger will be passed to fmt.Sprint when expanded as
-// a logging key field. If context keys are integer constants, for example,
-// its recommended that a String method is implemented.
-func GetLogger(ctx Context, keys ...interface{}) Logger {
-	return getLogrusLogger(ctx, keys...)
-}
-
-// GetLogrusLogger returns the logrus logger for the context. If one more keys
-// are provided, they will be resolved on the context and included in the
-// logger. Only use this function if specific logrus functionality is
-// required.
-func getLogrusLogger(ctx Context, keys ...interface{}) *logrus.Entry {
-	var logger *logrus.Entry
-
-	// Get a logger, if it is present.
-	loggerInterface := ctx.Value("logger")
-	if loggerInterface != nil {
-		if lgr, ok := loggerInterface.(*logrus.Entry); ok {
-			logger = lgr
-		}
-	}
-
-	if logger == nil {
-		fields := logrus.Fields{}
-
-		// Fill in the instance id, if we have it.
-		instanceID := ctx.Value("instance.id")
-		if instanceID != nil {
-			fields["instance.id"] = instanceID
-		}
-
-		fields["go.version"] = runtime.Version()
-		// If no logger is found, just return the standard logger.
-		logger = logrus.StandardLogger().WithFields(fields)
-	}
-
-	fields := logrus.Fields{}
-	for _, key := range keys {
-		v := ctx.Value(key)
-		if v != nil {
-			fields[fmt.Sprint(key)] = v
-		}
-	}
-
-	return logger.WithFields(fields)
-}

Godeps/_workspace/src/github.com/docker/distribution/context/trace.go

@@ -1,104 +0,0 @@
-package context
-
-import (
-	"runtime"
-	"time"
-
-	"github.com/docker/distribution/uuid"
-)
-
-// WithTrace allocates a traced timing span in a new context. This allows a
-// caller to track the time between calling WithTrace and the returned done
-// function. When the done function is called, a log message is emitted with a
-// "trace.duration" field, corresponding to the elapased time and a
-// "trace.func" field, corresponding to the function that called WithTrace.
-//
-// The logging keys "trace.id" and "trace.parent.id" are provided to implement
-// dapper-like tracing. This function should be complemented with a WithSpan
-// method that could be used for tracing distributed RPC calls.
-//
-// The main benefit of this function is to post-process log messages or
-// intercept them in a hook to provide timing data. Trace ids and parent ids
-// can also be linked to provide call tracing, if so required.
-//
-// Here is an example of the usage:
-//
-// 	func timedOperation(ctx Context) {
-// 		ctx, done := WithTrace(ctx)
-// 		defer done("this will be the log message")
-// 		// ... function body ...
-// 	}
-//
-// If the function ran for roughly 1s, such a usage would emit a log message
-// as follows:
-//
-// 	INFO[0001] this will be the log message  trace.duration=1.004575763s trace.func=github.com/docker/distribution/context.traceOperation trace.id=<id> ...
-//
-// Notice that the function name is automatically resolved, along with the
-// package and a trace id is emitted that can be linked with parent ids.
-func WithTrace(ctx Context) (Context, func(format string, a ...interface{})) {
-	if ctx == nil {
-		ctx = Background()
-	}
-
-	pc, file, line, _ := runtime.Caller(1)
-	f := runtime.FuncForPC(pc)
-	ctx = &traced{
-		Context: ctx,
-		id:      uuid.Generate().String(),
-		start:   time.Now(),
-		parent:  GetStringValue(ctx, "trace.id"),
-		fnname:  f.Name(),
-		file:    file,
-		line:    line,
-	}
-
-	return ctx, func(format string, a ...interface{}) {
-		GetLogger(ctx,
-			"trace.duration",
-			"trace.id",
-			"trace.parent.id",
-			"trace.func",
-			"trace.file",
-			"trace.line").
-			Debugf(format, a...)
-	}
-}
-
-// traced represents a context that is traced for function call timing. It
-// also provides fast lookup for the various attributes that are available on
-// the trace.
-type traced struct {
-	Context
-	id     string
-	parent string
-	start  time.Time
-	fnname string
-	file   string
-	line   int
-}
-
-func (ts *traced) Value(key interface{}) interface{} {
-	switch key {
-	case "trace.start":
-		return ts.start
-	case "trace.duration":
-		return time.Since(ts.start)
-	case "trace.id":
-		return ts.id
-	case "trace.parent.id":
-		if ts.parent == "" {
-			return nil // must return nil to signal no parent.
-		}
-
-		return ts.parent
-	case "trace.func":
-		return ts.fnname
-	case "trace.file":
-		return ts.file
-	case "trace.line":
-		return ts.line
-	}
-
-	return ts.Context.Value(key)
-}

Godeps/_workspace/src/github.com/docker/distribution/context/util.go

@@ -1,32 +0,0 @@
-package context
-
-import (
-	"time"
-)
-
-// Since looks up key, which should be a time.Time, and returns the duration
-// since that time. If the key is not found, the value returned will be zero.
-// This is helpful when inferring metrics related to context execution times.
-func Since(ctx Context, key interface{}) time.Duration {
-	startedAtI := ctx.Value(key)
-	if startedAtI != nil {
-		if startedAt, ok := startedAtI.(time.Time); ok {
-			return time.Since(startedAt)
-		}
-	}
-
-	return 0
-}
-
-// GetStringValue returns a string value from the context. The empty string
-// will be returned if not found.
-func GetStringValue(ctx Context, key interface{}) (value string) {
-	stringi := ctx.Value(key)
-	if stringi != nil {
-		if valuev, ok := stringi.(string); ok {
-			value = valuev
-		}
-	}
-
-	return value
-}

Godeps/_workspace/src/github.com/docker/distribution/context/version.go

@@ -1,16 +0,0 @@
-package context
-
-// WithVersion stores the application version in the context. The new context
-// gets a logger to ensure log messages are marked with the application
-// version.
-func WithVersion(ctx Context, version string) Context {
-	ctx = WithValue(ctx, "version", version)
-	// push a new logger onto the stack
-	return WithLogger(ctx, GetLogger(ctx, "version"))
-}
-
-// GetVersion returns the application version from the context. An empty
-// string may returned if the version was not set on the context.
-func GetVersion(ctx Context) string {
-	return GetStringValue(ctx, "version")
-}

Godeps/_workspace/src/github.com/docker/distribution/contrib/apache/README.MD

@@ -1,36 +0,0 @@
-# Apache HTTPd sample for Registry v1, v2 and mirror
-
-3 containers involved 
-
-* Docker Registry v1 (registry 0.9.1)
-* Docker Registry v2 (registry 2.0.0)
-* Docker Registry v1 in mirror mode
-
-HTTP for mirror and HTTPS for v1 & v2
-
-* http://registry.example.com proxify Docker Registry 1.0 in Mirror mode
-* https://registry.example.com proxify Docker Registry 1.0 or 2.0 in Hosting mode
-
-## 3 Docker containers should be started 
-
-* Docker Registry 1.0 in Mirror mode : port 5001
-* Docker Registry 1.0 in Hosting mode : port 5000
-* Docker Registry 2.0 in Hosting mode : port 5002
-
-### Registry v1
-
-    docker run -d -e SETTINGS_FLAVOR=dev -v /var/lib/docker-registry/storage/hosting-v1:/tmp -p 5000:5000 registry:0.9.1"
-
-### Mirror
-
-    docker run -d -e SETTINGS_FLAVOR=dev -e STANDALONE=false -e MIRROR_SOURCE=https://registry-1.docker.io -e MIRROR_SOURCE_INDEX=https://index.docker.io \
-                  -e MIRROR_TAGS_CACHE_TTL=172800 -v /var/lib/docker-registry/storage/mirror:/tmp -p 5001:5000 registry:0.9.1"
-
-### Registry v2
-
-    docker run -d -e SETTINGS_FLAVOR=dev -v /var/lib/axway/docker-registry/storage/hosting2-v2:/tmp -p 5002:5000 registry:2"
-
-# For Hosting mode access
-
-* users should have account (valid-user) to be able to fetch images
-* only users using account docker-deployer will be allowed to push images

Godeps/_workspace/src/github.com/docker/distribution/contrib/apache/apache.conf

@@ -1,127 +0,0 @@
-#
-# Sample Apache 2.x configuration where : 
-#
-
-<VirtualHost *:80>
-         
-  ServerName registry.example.com
-  ServerAlias www.registry.example.com
-
-  ProxyRequests     off
-  ProxyPreserveHost on
-
-  # no proxy for /error/ (Apache HTTPd errors messages)
-  ProxyPass /error/ !
-
-  ProxyPass        /_ping http://localhost:5001/_ping
-  ProxyPassReverse /_ping http://localhost:5001/_ping
-
-  ProxyPass        /v1 http://localhost:5001/v1
-  ProxyPassReverse /v1 http://localhost:5001/v1
-
-  # Logs
-  ErrorLog ${APACHE_LOG_DIR}/mirror_error_log
-  CustomLog ${APACHE_LOG_DIR}/mirror_access_log combined env=!dontlog
-
-</VirtualHost>
-
-
-<VirtualHost *:443>
-
-  ServerName registry.example.com
-  ServerAlias www.registry.example.com
-
-  SSLEngine on
-  SSLCertificateFile /etc/apache2/ssl/registry.example.com.crt
-  SSLCertificateKeyFile /etc/apache2/ssl/registry.example.com.key
-
-  # Higher Strength SSL Ciphers
-  SSLProtocol all -SSLv2 -SSLv3 -TLSv1 
-  SSLCipherSuite RC4-SHA:HIGH
-  SSLHonorCipherOrder on
-
-  # Logs
-  ErrorLog ${APACHE_LOG_DIR}/registry_error_ssl_log
-  CustomLog ${APACHE_LOG_DIR}/registry_access_ssl_log combined env=!dontlog
-
-  Header always set "Docker-Distribution-Api-Version" "registry/2.0"
-  Header onsuccess set "Docker-Distribution-Api-Version" "registry/2.0"
-  RequestHeader set X-Forwarded-Proto "https"
-
-  ProxyRequests     off
-  ProxyPreserveHost on
-
-  # no proxy for /error/ (Apache HTTPd errors messages)
-  ProxyPass /error/ !
-
-  #
-  # Registry v1
-  #
-
-  ProxyPass        /v1 http://localhost:5000/v1
-  ProxyPassReverse /v1 http://localhost:5000/v1
-
-  ProxyPass        /_ping http://localhost:5000/_ping
-  ProxyPassReverse /_ping http://localhost:5000/_ping
-
-  # Authentication require for push
-  <Location /v1>
-    Order deny,allow
-    Allow from all
-    AuthName "Registry Authentication"
-    AuthType basic
-    AuthUserFile "/etc/apache2/htpasswd/registry-htpasswd"
-
-    # Read access to authentified users
-    <Limit GET HEAD>
-      Require valid-user
-    </Limit>
-
-    # Write access to docker-deployer account only
-    <Limit POST PUT DELETE>
-      Require user docker-deployer
-    </Limit>
-
-  </Location>
-
-  # Allow ping to run unauthenticated.
-  <Location /v1/_ping>
-    Satisfy any
-    Allow from all
-  </Location>
-
-  # Allow ping to run unauthenticated.
-  <Location /_ping>
-    Satisfy any
-    Allow from all
-  </Location>
-
-  #
-  # Registry v2
-  #
-
-  ProxyPass        /v2 http://localhost:5002/v2
-  ProxyPassReverse /v2 http://localhost:5002/v2
-
-  <Location /v2>
-    Order deny,allow
-    Allow from all
-    AuthName "Registry Authentication"
-    AuthType basic
-    AuthUserFile "/etc/apache2/htpasswd/registry-htpasswd"
-
-    # Read access to authentified users
-    <Limit GET HEAD>
-      Require valid-user
-    </Limit>
-
-    # Write access to docker-deployer only
-    <Limit POST PUT DELETE>
-      Require user docker-deployer
-    </Limit>
-
-  </Location>
-
-
-</VirtualHost>
-

Godeps/_workspace/src/github.com/docker/distribution/contrib/ceph/ci-setup.sh

@@ -1,119 +0,0 @@
-#! /bin/bash
-#
-# Ceph cluster setup in Circle CI
-#
-
-set -x
-set -e
-set -u
-
-NODE=$(hostname)
-CEPHDIR=/tmp/ceph
-
-mkdir cluster
-pushd cluster
-
-# Install
-retries=0
-until [ $retries -ge 5 ]; do
-  pip install ceph-deploy && break
-  retries=$[$retries+1]
-  sleep 30
-done
-
-retries=0
-until [ $retries -ge 5 ]; do
-  ceph-deploy install --release hammer $NODE && break
-  retries=$[$retries+1]
-  sleep 30
-done
-
-retries=0
-until [ $retries -ge 5 ]; do
-  ceph-deploy pkg --install librados-dev $NODE && break
-  retries=$[$retries+1]
-  sleep 30
-done
-
-echo $(ip route get 1 | awk '{print $NF;exit}') $(hostname) >> /etc/hosts
-ssh-keygen -t rsa -f ~/.ssh/id_rsa -q -N ""
-cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys
-ssh-keyscan $NODE >> ~/.ssh/known_hosts
-ceph-deploy new $NODE
-
-cat >> ceph.conf <<EOF
-osd objectstore = memstore
-memstore device bytes = 2147483648
-osd data = $CEPHDIR
-osd journal = $CEPHDIR/journal
-osd crush chooseleaf type = 0
-osd pool default size = 1
-osd pool default min size = 1
-osd scrub load threshold = 1000
-
-debug_lockdep = 0/0
-debug_context = 0/0
-debug_crush = 0/0
-debug_buffer = 0/0
-debug_timer = 0/0
-debug_filer = 0/0
-debug_objecter = 0/0
-debug_rados = 0/0
-debug_rbd = 0/0
-debug_journaler = 0/0
-debug_objectcatcher = 0/0
-debug_client = 0/0
-debug_osd = 0/0
-debug_optracker = 0/0
-debug_objclass = 0/0
-debug_filestore = 0/0
-debug_journal = 0/0
-debug_ms = 0/0
-debug_monc = 0/0
-debug_tp = 0/0
-debug_auth = 0/0
-debug_finisher = 0/0
-debug_heartbeatmap = 0/0
-debug_perfcounter = 0/0
-debug_asok = 0/0
-debug_throttle = 0/0
-debug_mon = 0/0
-debug_paxos = 0/0
-debug_rgw = 0/0
-osd_op_num_threads_per_shard = 1 //You may want to try with 1 as well
-osd_op_num_shards = 5    //Depends on your cpu util
-ms_nocrc = true
-cephx_sign_messages = false
-cephx_require_signatures = false
-ms_dispatch_throttle_bytes = 0
-throttler_perf_counter = false
-
-[osd]
-osd_client_message_size_cap = 0
-osd_client_message_cap = 0
-osd_enable_op_tracker = false
-EOF
-
-sed -i -r 's/mon_host =.*/mon_host = 127.0.0.1/' ceph.conf
-sed -i -r 's/auth_cluster_required =.*/auth_cluster_required = none/' ceph.conf
-sed -i -r 's/auth_service_required =.*/auth_service_required = none/' ceph.conf
-sed -i -r 's/auth_client_required =.*/auth_client_required = none/' ceph.conf
-
-# Setup monitor and keyrings
-ceph-deploy mon create-initial
-ceph-deploy admin $NODE
-sudo chmod a+r /etc/ceph/ceph.client.admin.keyring
-
-# Setup OSD
-mkdir -p $CEPHDIR
-OSD=$(ceph osd create)
-ceph osd crush add osd.${OSD} 1 root=default host=$NODE
-ceph-osd --id ${OSD} --mkjournal --mkfs
-ceph-osd --id ${OSD}
-
-# Status
-ceph status
-ceph health detail
-ceph osd tree
-
-popd

Godeps/_workspace/src/github.com/docker/distribution/contrib/compose/README.md

@@ -1,147 +0,0 @@
-# Docker Compose V1 + V2 registry
-
-This compose configuration configures a `v1` and `v2` registry behind an `nginx`
-proxy. By default, you can access the combined registry at `localhost:5000`.
-
-The configuration does not support pushing images to `v2` and pulling from `v1`.
-If a `docker` client has a version less than 1.6, Nginx will route its requests
-to the 1.0 registry. Requests from newer clients will route to the 2.0 registry.
-
-### Install Docker Compose
-
-1. Open a new terminal on the host with your `distribution` source.
-
-2. Get the `docker-compose` binary.
-
-		$ sudo wget https://github.com/docker/compose/releases/download/1.1.0/docker-compose-`uname  -s`-`uname -m` -O /usr/local/bin/docker-compose
-
-	This command installs the binary in the `/usr/local/bin` directory. 
-	
-3. Add executable permissions to the binary.
-
-		$  sudo chmod +x /usr/local/bin/docker-compose
-		
-## Build and run with Compose
-	
-1. In your terminal, navigate to the `distribution/contrib/compose` directory
-
-	This directory includes a single `docker-compose.yml` configuration.
-	
-		nginx:
-			build: "nginx"
-			ports:
-				- "5000:5000"
-			links:
-				- registryv1:registryv1
-				- registryv2:registryv2
-		registryv1:
-			image: registry
-			ports:
-				- "5000"
-		registryv2:
-			build: "../../"
-			ports:
-				- "5000"
-
-	This configuration builds a new `nginx` image as specified by the
-	`nginx/Dockerfile` file. The 1.0 registry comes from Docker's official
-	public image. Finally, the registry 2.0 image is built from the
-	`distribution/Dockerfile` you've used previously.
- 		
-2. Get a registry 1.0 image.
-
-		$ docker pull registry:0.9.1 
-
-	The Compose configuration looks for this image locally. If you don't do this
-	step, later steps can fail.
-	
-3. Build `nginx`, the registry 2.0 image, and 
-
-		$ docker-compose build
-		registryv1 uses an image, skipping
-		Building registryv2...
-		Step 0 : FROM golang:1.4
-		
-		...
-		
-		Removing intermediate container 9f5f5068c3f3
-		Step 4 : COPY docker-registry-v2.conf /etc/nginx/docker-registry-v2.conf
-		 ---> 74acc70fa106
-		Removing intermediate container edb84c2b40cb
-		Successfully built 74acc70fa106
-		
-	The commmand outputs its progress until it completes.
-
-4. Start your configuration with compose.
-
-		$ docker-compose up
-		Recreating compose_registryv1_1...
-		Recreating compose_registryv2_1...
-		Recreating compose_nginx_1...
-		Attaching to compose_registryv1_1, compose_registryv2_1, compose_nginx_1
-		...
-	
-
-5. In another terminal, display the running configuration.
-
-		$ docker ps
-		CONTAINER ID        IMAGE                       COMMAND                CREATED             STATUS              PORTS                                     NAMES
-		a81ad2557702        compose_nginx:latest        "nginx -g 'daemon of   8 minutes ago       Up 8 minutes        80/tcp, 443/tcp, 0.0.0.0:5000->5000/tcp   compose_nginx_1        
-		0618437450dd        compose_registryv2:latest   "registry cmd/regist   8 minutes ago       Up 8 minutes        0.0.0.0:32777->5000/tcp                   compose_registryv2_1   
-		aa82b1ed8e61        registry:latest             "docker-registry"      8 minutes ago       Up 8 minutes        0.0.0.0:32776->5000/tcp                   compose_registryv1_1   
-	
-### Explore a bit
-
-1. Check for TLS on your `nginx` server.
-
-		$ curl -v https://localhost:5000
-		* Rebuilt URL to: https://localhost:5000/
-		* Hostname was NOT found in DNS cache
-		*   Trying 127.0.0.1...
-		* Connected to localhost (127.0.0.1) port 5000 (#0)
-		* successfully set certificate verify locations:
-		*   CAfile: none
-			CApath: /etc/ssl/certs
-		* SSLv3, TLS handshake, Client hello (1):
-		* SSLv3, TLS handshake, Server hello (2):
-		* SSLv3, TLS handshake, CERT (11):
-		* SSLv3, TLS alert, Server hello (2):
-		* SSL certificate problem: self signed certificate
-		* Closing connection 0
-		curl: (60) SSL certificate problem: self signed certificate
-		More details here: http://curl.haxx.se/docs/sslcerts.html
-		
-2. Tag the `v1` registry image.
-
-		 $ docker tag registry:latest localhost:5000/registry_one:latest
-
-2. Push it to the localhost.
-
-		 $ docker push localhost:5000/registry_one:latest
-		
-	If you are using the 1.6 Docker client, this pushes the image the `v2 `registry.
-
-4. Use `curl` to list the image in the registry.
-
-			$ curl -v -X GET http://localhost:32777/v2/registry1/tags/list
-			* Hostname was NOT found in DNS cache
-			*   Trying 127.0.0.1...
-			* Connected to localhost (127.0.0.1) port 32777 (#0)
-			> GET /v2/registry1/tags/list HTTP/1.1
-			> User-Agent: curl/7.36.0
-			> Host: localhost:32777
-			> Accept: */*
-			> 
-			< HTTP/1.1 200 OK
-			< Content-Type: application/json; charset=utf-8
-			< Docker-Distribution-Api-Version: registry/2.0
-			< Date: Tue, 14 Apr 2015 22:34:13 GMT
-			< Content-Length: 39
-			< 
-			{"name":"registry1","tags":["latest"]}
-			* Connection #0 to host localhost left intact
-		
-	This example refers to the specific port assigned to the 2.0 registry. You saw
-	this port earlier, when you used `docker ps` to show your running containers.
-
-

Godeps/_workspace/src/github.com/docker/distribution/contrib/compose/docker-compose.yml

@@ -1,15 +0,0 @@
-nginx:
-  build: "nginx"
-  ports:
-    - "5000:5000"
-  links:
-    - registryv1:registryv1
-    - registryv2:registryv2
-registryv1:
-  image: registry
-  ports:
-    - "5000"
-registryv2:
-  build: "../../"
-  ports:
-    - "5000"

Godeps/_workspace/src/github.com/docker/distribution/contrib/compose/nginx/Dockerfile

@@ -1,6 +0,0 @@
-FROM nginx:1.7
-
-COPY nginx.conf /etc/nginx/nginx.conf
-COPY registry.conf /etc/nginx/conf.d/registry.conf
-COPY docker-registry.conf /etc/nginx/docker-registry.conf
-COPY docker-registry-v2.conf /etc/nginx/docker-registry-v2.conf

Godeps/_workspace/src/github.com/docker/distribution/contrib/compose/nginx/docker-registry-v2.conf

@@ -1,6 +0,0 @@
-proxy_pass                          http://docker-registry-v2;
-proxy_set_header  Host              $http_host;   # required for docker client's sake
-proxy_set_header  X-Real-IP         $remote_addr; # pass on real client's IP
-proxy_set_header  X-Forwarded-For   $proxy_add_x_forwarded_for;
-proxy_set_header  X-Forwarded-Proto $scheme;
-proxy_read_timeout                  900;

Godeps/_workspace/src/github.com/docker/distribution/contrib/compose/nginx/docker-registry.conf

@@ -1,7 +0,0 @@
-proxy_pass                          http://docker-registry;
-proxy_set_header  Host              $http_host;   # required for docker client's sake
-proxy_set_header  X-Real-IP         $remote_addr; # pass on real client's IP
-proxy_set_header  X-Forwarded-For   $proxy_add_x_forwarded_for;
-proxy_set_header  X-Forwarded-Proto $scheme;
-proxy_set_header  Authorization     ""; # For basic auth through nginx in v1 to work, please comment this line
-proxy_read_timeout                  900;

Godeps/_workspace/src/github.com/docker/distribution/contrib/compose/nginx/nginx.conf

@@ -1,27 +0,0 @@
-user  nginx;
-worker_processes  1;
-
-error_log /var/log/nginx/error.log warn;
-pid        /var/run/nginx.pid;
-
-events {
-    worker_connections  1024;
-}
-
-http {
-    include       /etc/nginx/mime.types;
-    default_type  application/octet-stream;
-
-    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
-                      '$status $body_bytes_sent "$http_referer" '
-                      '"$http_user_agent" "$http_x_forwarded_for"';
-
-    access_log  /var/log/nginx/access.log main;
-
-    sendfile        on;
-
-    keepalive_timeout  65;
-
-    include /etc/nginx/conf.d/*.conf;
-}
-

Godeps/_workspace/src/github.com/docker/distribution/contrib/compose/nginx/registry.conf

@@ -1,41 +0,0 @@
-# Docker registry proxy for api versions 1 and 2
-
-upstream docker-registry {
-  server registryv1:5000;
-}
-
-upstream docker-registry-v2 {
-  server registryv2:5000;
-}
-
-# No client auth or TLS
-server {
-  listen 5000;
-  server_name localhost;
-
-  # disable any limits to avoid HTTP 413 for large image uploads
-  client_max_body_size 0;
-
-  # required to avoid HTTP 411: see Issue #1486 (https://github.com/docker/docker/issues/1486)
-  chunked_transfer_encoding on;
-
-  location /v2/ {
-    # Do not allow connections from docker 1.5 and earlier
-    # docker pre-1.6.0 did not properly set the user agent on ping, catch "Go *" user agents
-    if ($http_user_agent ~ "^(docker\/1\.(3|4|5(?!\.[0-9]-dev))|Go ).*$" ) {
-      return 404;
-    }
-
-    # To add basic authentication to v2 use auth_basic setting plus add_header
-    # auth_basic "registry.localhost";
-    # auth_basic_user_file test.password;
-    # add_header 'Docker-Distribution-Api-Version' 'registry/2.0' always;
-
-    include               docker-registry-v2.conf;
-  }
-
-  location / {
-    include               docker-registry.conf;
-  }
-}
-

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/Dockerfile

@@ -1,46 +0,0 @@
-FROM debian:jessie
-
-MAINTAINER Docker Distribution Team <distribution@docker.com>
-
-# compile and runtime deps
-# https://github.com/docker/docker/blob/master/project/PACKAGERS.md#runtime-dependencies
-RUN apt-get update && apt-get install -y --no-install-recommends \
-        # For DIND
-        ca-certificates \
-        curl \
-        iptables \
-        procps \
-        e2fsprogs \
-        xz-utils \
-        # For build
-        build-essential \
-        file \
-        git \
-        net-tools \ 
-    && apt-get clean && rm -rf /var/lib/apt/lists/*
-
-# Install Docker
-ENV VERSION 1.7.1
-RUN curl -L -o /usr/local/bin/docker https://test.docker.com/builds/Linux/x86_64/docker-${VERSION} \
-    && chmod +x /usr/local/bin/docker
-
-# Install DIND
-RUN curl -L -o /dind https://raw.githubusercontent.com/docker/docker/v1.8.1/hack/dind \
-    && chmod +x /dind
-
-# Install bats
-RUN cd /usr/local/src/ \
-    && git clone https://github.com/sstephenson/bats.git \
-    && cd bats \
-    && ./install.sh /usr/local
-
-# Install docker-compose
-RUN curl -L https://github.com/docker/compose/releases/download/1.3.3/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose \
-    && chmod +x /usr/local/bin/docker-compose
-
-RUN mkdir -p /go/src/github.com/docker/distribution
-WORKDIR /go/src/github.com/docker/distribution/contrib/docker-integration
-
-VOLUME /var/lib/docker
-
-ENTRYPOINT ["/dind"]

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/README.md

@@ -1,138 +0,0 @@
-# Docker Registry Integration Testing
-
-These integration tests cover interactions between the Docker daemon and the
-registry server. All tests are run using the docker cli.
-
-The compose configuration is intended to setup a testing environment for Docker
-using multiple registry configurations. These configurations include different
-combinations of a v1 and v2 registry as well as TLS configurations.
-
-## Running inside of Docker
-### Get integration container
-The container image to run the integation tests will need to be pulled or built
-locally.
-
-*Building locally*
-```
-$ docker build -t distribution/docker-integration .
-```
-
-### Run script
-
-Invoke the tests within Docker through the `run.sh` script.
-
-```
-$ ./run.sh
-```
-
-Run with aufs driver and tmp volume
-**NOTE: Using a volume will prevent multiple runs from needing to
-re-pull images**
-```
-$ DOCKER_GRAPHDRIVER=aufs DOCKER_VOLUME=/tmp/volume ./run.sh
-```
-
-### Example developer flow 
-
-These tests are useful for developing both as a registry and docker
-core developer. The following setup may be used to do integration
-testing between development versions
-
-Insert into your `.zshrc` or `.bashrc`
-
-```
-# /usr/lib/docker for Docker-in-Docker
-# Set this directory to make each invocation run much faster, without
-# the need to repull images.
-export DOCKER_VOLUME=$HOME/.docker-test-volume
-
-# Use overlay for all Docker testing, try aufs if overlay not supported
-export DOCKER_GRAPHDRIVER=overlay
-
-# Name this according to personal preference
-function rdtest() {
-  if [ "$1" != "" ]; then
-    DOCKER_BINARY=$GOPATH/src/github.com/docker/docker/bundles/$1/binary/docker
-    if [ ! -f $DOCKER_BINARY ]; then
-      current_version=`cat $GOPATH/src/github.com/docker/docker/VERSION`
-      echo "$DOCKER_BINARY does not exist"
-      echo "Current checked out docker version: $current_version"
-      echo "Checkout desired version and run 'make binary' from $GOPATH/src/github.com/docker/docker"
-      return 1
-    fi
-  fi
-
-  $GOPATH/src/github.com/docker/distribution/contrib/docker-integration/run.sh
-}
-```
-
-Run with Docker release version
-```
-$ rdtest
-```
-
-Run using local development version of docker
-```
-$ cd $GOPATH/src/github.com/docker/docker
-$ make binary
-$ rdtest `cat VERSION`
-```
-
-## Running manually outside of Docker
-
-### Install Docker Compose
-
-[Docker Compose Installation Guide](https://docs.docker.com/compose/install/)
-
-### Start compose setup
-```
-docker-compose up
-```
-
-### Install Certificates
-The certificates must be installed in /etc/docker/cert.d in order to use TLS
-client auth and use the CA certificate.
-```
-sudo sh ./install_certs.sh
-```
-
-### Test with Docker
-Tag an image as with any other private registry. Attempt to push the image.
-
-```
-docker pull hello-world
-docker tag hello-world localhost:5440/hello-world
-docker push localhost:5440/hello-world
-
-docker tag hello-world localhost:5441/hello-world
-docker push localhost:5441/hello-world
-# Perform login using user `testuser` and password `passpassword`
-```
-
-### Set /etc/hosts entry
-Find the non-localhost ip address of local machine
-
-### Run bats
-Run the bats tests after updating /etc/hosts, installing the certificates, and
-running the `docker-compose` script.
-```
-bats -p .
-```
-
-## Configurations
-
-Port | V2 | V1 | TLS | Authentication
---- | --- | --- | --- | ---
-5000 | yes | yes | no | none
-5001 | no | yes | no | none
-5002 | yes | no | no | none
-5011 | no | yes | yes | none
-5440 | yes | yes | yes | none
-5441 | yes | yes | yes | basic (testuser/passpassword)
-5442 | yes | yes | yes | TLS client
-5443 | yes | yes | yes | TLS client (no CA)
-5444 | yes | yes | yes | TLS client + basic (testuser/passpassword)
-5445 | yes | yes | yes (no CA) | none
-5446 | yes | yes | yes (no CA) | basic (testuser/passpassword)
-5447 | yes | yes | yes (no CA) | TLS client
-5448 | yes | yes | yes (SSLv3) | none

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/docker-compose.yml

@@ -1,27 +0,0 @@
-nginx:
-  build: "nginx"
-  ports:
-    - "5000:5000"
-    - "5001:5001"
-    - "5002:5002"
-    - "5011:5011"
-    - "5440:5440"
-    - "5441:5441"
-    - "5442:5442"
-    - "5443:5443"
-    - "5444:5444"
-    - "5445:5445"
-    - "5446:5446"
-    - "5447:5447"
-    - "5448:5448"
-  links:
-    - registryv1:registryv1
-    - registryv2:registryv2
-registryv1:
-  image: registry:0.9.1
-  ports:
-    - "5000"
-registryv2:
-  build: "../../"
-  ports:
-    - "5000"

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/helpers.bash

@@ -1,21 +0,0 @@
-# Start docker daemon
-function start_daemon() {
-	# Drivers to use for Docker engines the tests are going to create.
-	STORAGE_DRIVER=${STORAGE_DRIVER:-overlay}
-	EXEC_DRIVER=${EXEC_DRIVER:-native}
-
-	docker --daemon --log-level=panic \
-		--storage-driver="$STORAGE_DRIVER" --exec-driver="$EXEC_DRIVER" &
-	DOCKER_PID=$!
-
-	# Wait for it to become reachable.
-	tries=10
-	until docker version &> /dev/null; do
-		(( tries-- ))
-		if [ $tries -le 0 ]; then
-			echo >&2 "error: daemon failed to start"
-			exit 1
-		fi
-		sleep 1
-	done
-}

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/install_certs.sh

@@ -1,38 +0,0 @@
-#!/bin/sh
-set -e
-
-hostname=$1
-if [ "$hostname" = "" ]; then
-	hostname="localhost"
-fi
-
-mkdir -p /etc/docker/certs.d/$hostname:5011
-cp ./nginx/ssl/registry-ca+ca.pem /etc/docker/certs.d/$hostname:5011/ca.crt
-
-mkdir -p /etc/docker/certs.d/$hostname:5440
-cp ./nginx/ssl/registry-ca+ca.pem /etc/docker/certs.d/$hostname:5440/ca.crt
-
-mkdir -p /etc/docker/certs.d/$hostname:5441
-cp ./nginx/ssl/registry-ca+ca.pem /etc/docker/certs.d/$hostname:5441/ca.crt
-
-mkdir -p /etc/docker/certs.d/$hostname:5442
-cp ./nginx/ssl/registry-ca+ca.pem /etc/docker/certs.d/$hostname:5442/ca.crt
-cp ./nginx/ssl/registry-ca+client-cert.pem /etc/docker/certs.d/$hostname:5442/client.cert
-cp ./nginx/ssl/registry-ca+client-key.pem /etc/docker/certs.d/$hostname:5442/client.key
-
-mkdir -p /etc/docker/certs.d/$hostname:5443
-cp ./nginx/ssl/registry-ca+ca.pem /etc/docker/certs.d/$hostname:5443/ca.crt
-cp ./nginx/ssl/registry-noca+client-cert.pem /etc/docker/certs.d/$hostname:5443/client.cert
-cp ./nginx/ssl/registry-noca+client-key.pem /etc/docker/certs.d/$hostname:5443/client.key
-
-mkdir -p /etc/docker/certs.d/$hostname:5444
-cp ./nginx/ssl/registry-ca+ca.pem /etc/docker/certs.d/$hostname:5444/ca.crt
-cp ./nginx/ssl/registry-ca+client-cert.pem /etc/docker/certs.d/$hostname:5444/client.cert
-cp ./nginx/ssl/registry-ca+client-key.pem /etc/docker/certs.d/$hostname:5444/client.key
-
-mkdir -p /etc/docker/certs.d/$hostname:5447
-cp ./nginx/ssl/registry-ca+client-cert.pem /etc/docker/certs.d/$hostname:5447/client.cert
-cp ./nginx/ssl/registry-ca+client-key.pem /etc/docker/certs.d/$hostname:5447/client.key
-
-mkdir -p /etc/docker/certs.d/$hostname:5448
-cp ./nginx/ssl/registry-ca+ca.pem /etc/docker/certs.d/$hostname:5448/ca.crt

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/nginx/Dockerfile

@@ -1,10 +0,0 @@
-FROM nginx:1.9
-
-COPY nginx.conf /etc/nginx/nginx.conf
-COPY registry.conf /etc/nginx/conf.d/registry.conf
-COPY docker-registry.conf /etc/nginx/docker-registry.conf
-COPY docker-registry-v2.conf /etc/nginx/docker-registry-v2.conf
-COPY registry-noauth.conf /etc/nginx/registry-noauth.conf
-COPY registry-basic.conf /etc/nginx/registry-basic.conf
-COPY test.passwd /etc/nginx/test.passwd
-COPY ssl /etc/nginx/ssl

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/nginx/docker-registry-v2.conf

@@ -1,6 +0,0 @@
-proxy_pass                          http://docker-registry-v2;
-proxy_set_header  Host              $http_host;   # required for docker client's sake
-proxy_set_header  X-Real-IP         $remote_addr; # pass on real client's IP
-proxy_set_header  X-Forwarded-For   $proxy_add_x_forwarded_for;
-proxy_set_header  X-Forwarded-Proto $scheme;
-proxy_read_timeout                  900;

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/nginx/docker-registry.conf

@@ -1,7 +0,0 @@
-proxy_pass                          http://docker-registry;
-proxy_set_header  Host              $http_host;   # required for docker client's sake
-proxy_set_header  X-Real-IP         $remote_addr; # pass on real client's IP
-proxy_set_header  X-Forwarded-For   $proxy_add_x_forwarded_for;
-proxy_set_header  X-Forwarded-Proto $scheme;
-proxy_set_header  Authorization     ""; # see https://github.com/docker/docker-registry/issues/170
-proxy_read_timeout                  900;

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/nginx/nginx.conf

@@ -1,27 +0,0 @@
-user  nginx;
-worker_processes  1;
-
-error_log /var/log/nginx/error.log warn;
-pid        /var/run/nginx.pid;
-
-events {
-    worker_connections  1024;
-}
-
-http {
-    include       /etc/nginx/mime.types;
-    default_type  application/octet-stream;
-
-    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
-                      '$status $body_bytes_sent "$http_referer" '
-                      '"$http_user_agent" "$http_x_forwarded_for"';
-
-    access_log  /var/log/nginx/access.log main;
-
-    sendfile        on;
-
-    keepalive_timeout  65;
-
-    include /etc/nginx/conf.d/*.conf;
-}
-

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/nginx/registry-basic.conf

@@ -1,13 +0,0 @@
-client_max_body_size 0;
-chunked_transfer_encoding on;
-location /v2/ {
-  auth_basic "registry.localhost";
-  auth_basic_user_file test.passwd;
-  add_header 'Docker-Distribution-Api-Version' 'registry/2.0' always;
-  include               docker-registry-v2.conf;
-}
-location / {
-  auth_basic "registry.localhost";
-  auth_basic_user_file test.passwd;
-  include               docker-registry.conf;
-}

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/nginx/registry-noauth.conf

@@ -1,8 +0,0 @@
-client_max_body_size 0;
-chunked_transfer_encoding on;
-location /v2/ {
-  include               docker-registry-v2.conf;
-}
-location / {
-  include               docker-registry.conf;
-}

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/nginx/registry.conf

@@ -1,277 +0,0 @@
-# Docker registry proxy for api versions 1 and 2
-
-upstream docker-registry {
-  server registryv1:5000;
-}
-
-upstream docker-registry-v2 {
-  server registryv2:5000;
-}
-
-# No client auth or TLS
-server {
-  listen 5000;
-  server_name localhost;
-
-  # disable any limits to avoid HTTP 413 for large image uploads
-  client_max_body_size 0;
-
-  # required to avoid HTTP 411: see Issue #1486 (https://github.com/docker/docker/issues/1486)
-  chunked_transfer_encoding on;
-
-  location /v2/ {
-    # Do not allow connections from docker 1.5 and earlier
-    # docker pre-1.6.0 did not properly set the user agent on ping, catch "Go *" user agents
-    if ($http_user_agent ~ "^(docker\/1\.(3|4|5(?!\.[0-9]-dev))|Go ).*$" ) {
-      return 404;
-    }
-    
-    include               docker-registry-v2.conf;
-  }
-
-  location / {
-    include               docker-registry.conf;
-  }
-}
-
-# No client auth or TLS (V1 Only)
-server {
-  listen 5001;
-  server_name localhost;
-
-  # disable any limits to avoid HTTP 413 for large image uploads
-  client_max_body_size 0;
-
-  # required to avoid HTTP 411: see Issue #1486 (https://github.com/docker/docker/issues/1486)
-  chunked_transfer_encoding on;
-
-  location / {
-    include               docker-registry.conf;
-  }
-}
-
-# No client auth or TLS (V2 Only)
-server {
-  listen 5002;
-  server_name localhost;
-
-  # disable any limits to avoid HTTP 413 for large image uploads
-  client_max_body_size 0;
-
-  # required to avoid HTTP 411: see Issue #1486 (https://github.com/docker/docker/issues/1486)
-  chunked_transfer_encoding on;
-
-  location / {
-    include               docker-registry-v2.conf;
-  }
-}
-
-# TLS localhost (V1 Only)
-server {
-  listen 5011;
-  server_name localhost;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-ca+localhost-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-ca+localhost-key.pem;
-
-  client_max_body_size 0;
-  chunked_transfer_encoding on;
-  location / {
-    include               docker-registry.conf;
-  }
-}
-
-# TLS localregistry (V1 Only)
-server {
-  listen 5011;
-  server_name localregistry;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-ca+localregistry-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-ca+localregistry-key.pem;
-
-  client_max_body_size 0;
-  chunked_transfer_encoding on;
-  location / {
-    include               docker-registry.conf;
-  }
-}
-
-
-
-# TLS Configuration chart
-# Username/Password: testuser/passpassword
-#      | ca  | client | basic | notes
-# 5440 | yes | no     | no    | Tests CA certificate
-# 5441 | yes | no     | yes   | Tests basic auth over TLS
-# 5442 | yes | yes    | no    | Tests client auth with client CA
-# 5443 | yes | yes    | no    | Tests client auth without client CA
-# 5444 | yes | yes    | yes   | Tests using basic auth + tls auth
-# 5445 | no  | no     | no    | Tests insecure using TLS
-# 5446 | no  | no     | yes   | Tests sending credentials to server with insecure TLS
-# 5447 | no  | yes    | no    | Tests client auth to insecure
-# 5448 | yes | no     | no    | Bad SSL version
-
-server {
-  listen 5440;
-  server_name localhost;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-ca+localhost-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-ca+localhost-key.pem;
-  include registry-noauth.conf;
-}
-
-server {
-  listen 5441;
-  server_name localhost;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-ca+localhost-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-ca+localhost-key.pem;
-  include registry-basic.conf;
-}
-
-server {
-  listen 5442;
-  listen 5443;
-  server_name localhost;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-ca+localhost-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-ca+localhost-key.pem;
-  ssl_client_certificate /etc/nginx/ssl/registry-ca+ca.pem;
-  ssl_verify_client on;
-  include registry-noauth.conf;
-}
-
-server {
-  listen 5444;
-  server_name localhost;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-ca+localhost-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-ca+localhost-key.pem;
-  ssl_client_certificate /etc/nginx/ssl/registry-ca+ca.pem;
-  ssl_verify_client on;
-  include registry-basic.conf;
-}
-
-server {
-  listen 5445;
-  server_name localhost;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-noca+localhost-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-noca+localhost-key.pem;
-  include registry-noauth.conf;
-}
-
-server {
-  listen 5446;
-  server_name localhost;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-noca+localhost-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-noca+localhost-key.pem;
-  include registry-basic.conf;
-}
-
-server {
-  listen 5447;
-  server_name localhost;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-noca+localhost-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-noca+localhost-key.pem;
-  ssl_client_certificate /etc/nginx/ssl/registry-ca+ca.pem;
-  ssl_verify_client on;
-  include registry-noauth.conf;
-}
-
-server {
-  listen 5448;
-  server_name localhost;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-ca+localhost-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-ca+localhost-key.pem;
-  ssl_protocols       SSLv3;
-  include registry-noauth.conf;
-}
-
-# Add configuration for localregistry server_name
-# Requires configuring /etc/hosts to use
-# Set /etc/hosts entry to external IP, not 127.0.0.1 for testing
-# Docker secure/insecure registry features
-server {
-  listen 5440;
-  server_name localregistry;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-ca+localregistry-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-ca+localregistry-key.pem;
-  include registry-noauth.conf;
-}
-
-server {
-  listen 5441;
-  server_name localregistry;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-ca+localregistry-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-ca+localregistry-key.pem;
-  include registry-basic.conf;
-}
-
-server {
-  listen 5442;
-  listen 5443;
-  server_name localregistry;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-ca+localregistry-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-ca+localregistry-key.pem;
-  ssl_client_certificate /etc/nginx/ssl/registry-ca+ca.pem;
-  ssl_verify_client on;
-  include registry-noauth.conf;
-}
-
-server {
-  listen 5444;
-  server_name localregistry;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-ca+localregistry-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-ca+localregistry-key.pem;
-  ssl_client_certificate /etc/nginx/ssl/registry-ca+ca.pem;
-  ssl_verify_client on;
-  include registry-basic.conf;
-}
-
-server {
-  listen 5445;
-  server_name localregistry;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-noca+localregistry-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-noca+localregistry-key.pem;
-  include registry-noauth.conf;
-}
-
-server {
-  listen 5446;
-  server_name localregistry;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-noca+localregistry-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-noca+localregistry-key.pem;
-  include registry-basic.conf;
-}
-
-server {
-  listen 5447;
-  server_name localregistry;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-noca+localregistry-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-noca+localregistry-key.pem;
-  ssl_client_certificate /etc/nginx/ssl/registry-ca+ca.pem;
-  ssl_verify_client on;
-  include registry-noauth.conf;
-}
-
-server {
-  listen 5448;
-  server_name localregistry;
-  ssl on;
-  ssl_certificate /etc/nginx/ssl/registry-ca+localregistry-cert.pem;
-  ssl_certificate_key /etc/nginx/ssl/registry-ca+localregistry-key.pem;
-  ssl_protocols       SSLv3;
-  include registry-noauth.conf;
-}
-

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/nginx/test.passwd

@@ -1 +0,0 @@
-testuser:$apr1$YmLhHjm6$AjP4z8J1WgcUNxU8J4ue5.

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/run.sh

@@ -1,75 +0,0 @@
-#!/usr/bin/env bash
-set -e
-set -x
-
-cd "$(dirname "$(readlink -f "$BASH_SOURCE")")"
-
-source helpers.bash
-
-# Root directory of Distribution
-DISTRIBUTION_ROOT=$(cd ../..; pwd -P)
-
-volumeMount=""
-if [ "$DOCKER_VOLUME" != "" ]; then
-	volumeMount="-v ${DOCKER_VOLUME}:/var/lib/docker"
-fi
-
-dockerMount=""
-if [ "$DOCKER_BINARY" != "" ]; then
-	dockerMount="-v ${DOCKER_BINARY}:/usr/local/bin/docker"
-else
-	DOCKER_BINARY=docker
-fi
-
-# Image containing the integration tests environment.
-INTEGRATION_IMAGE=${INTEGRATION_IMAGE:-distribution/docker-integration}
-
-if [ "$1" == "-d" ]; then
-	start_daemon
-	shift
-fi
-
-TESTS=${@:-.}
-
-# Make sure we upgrade the integration environment.
-docker pull $INTEGRATION_IMAGE
-
-# Start a Docker engine inside a docker container
-ID=$(docker run -d -it --privileged $volumeMount $dockerMount \
-	-v ${DISTRIBUTION_ROOT}:/go/src/github.com/docker/distribution \
-	-e "DOCKER_GRAPHDRIVER=$DOCKER_GRAPHDRIVER" \
-	${INTEGRATION_IMAGE} \
-	./run_engine.sh)
-
-# Stop container on exit
-trap "docker rm -f -v $ID" EXIT
-
-
-# Wait for it to become reachable.
-tries=10
-until docker exec "$ID" docker version &> /dev/null; do
-	(( tries-- ))
-	if [ $tries -le 0 ]; then
-		echo >&2 "error: daemon failed to start"
-		exit 1
-	fi
-	sleep 1
-done
-
-# If no volume is specified, transfer images into the container from
-# the outer docker instance
-if [ "$DOCKER_VOLUME" == "" ]; then
-	# Make sure we have images outside the container, to transfer to the container.
-	# Not much will happen here if the images are already present.
-	docker-compose pull
-	docker-compose build
-
-	# Transfer images to the inner container.
-	for image in "$INTEGRATION_IMAGE" registry:0.9.1 dockerintegration_nginx dockerintegration_registryv2; do
-		docker save "$image" | docker exec -i "$ID" docker load
-	done
-fi
-
-# Run the tests.
-docker exec -it "$ID" sh -c "./test_runner.sh $TESTS"
-

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/run_engine.sh

@@ -1,23 +0,0 @@
-#!/bin/sh
-set -e
-set -x
-
-DOCKER_GRAPHDRIVER=${DOCKER_GRAPHDRIVER:-overlay}
-EXEC_DRIVER=${EXEC_DRIVER:-native}
-
-# Set IP address in /etc/hosts for localregistry
-IP=$(ifconfig eth0|grep "inet addr:"| cut -d: -f2 | awk '{ print $1}')
-echo "$IP localregistry" >> /etc/hosts
-
-sh install_certs.sh localregistry
-
-DOCKER_VERSION=$(docker --version | cut -d ' ' -f3 | cut -d ',' -f1)
-major=$(echo "$DOCKER_VERSION"| cut -d '.' -f1)
-minor=$(echo "$DOCKER_VERSION"| cut -d '.' -f2)
-
-daemonOpts="daemon"
-if [ $major -le 1 ] && [ $minor -lt 9 ]; then
-	daemonOpts="--daemon"
-fi
-
-docker $daemonOpts --log-level=debug --storage-driver="$DOCKER_GRAPHDRIVER"

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/run_multiversion.sh

@@ -1,53 +0,0 @@
-#!/usr/bin/env bash
-
-# Run the integration tests with multiple versions of the Docker engine
-
-set -e
-set -x
-
-source helpers.bash
-
-if [ `uname` = "Linux" ]; then
-	tmpdir_template="$TMPDIR/docker-versions.XXXXX"
-else
-	# /tmp isn't available for mounting in boot2docker
-	tmpdir_template="`pwd`/../../../docker-versions.XXXXX"
-fi
-
-tmpdir=`mktemp -d "$tmpdir_template"`
-trap "rm -rf $tmpdir" EXIT
-
-if [ "$1" == "-d" ]; then
-	start_daemon
-fi
-
-# Released versions
-
-versions="1.6.1 1.7.1 1.8.3 1.9.1"
-
-for v in $versions; do
-	echo "Extracting Docker $v from dind image"
-	binpath="$tmpdir/docker-$v/docker"
-	ID=$(docker create dockerswarm/dind:$v)
-	docker cp "$ID:/usr/local/bin/docker" "$tmpdir/docker-$v"
-
-	echo "Running tests with Docker $v"
-	DOCKER_BINARY="$binpath" DOCKER_VOLUME="$DOCKER_VOLUME" DOCKER_GRAPHDRIVER="$DOCKER_GRAPHDRIVER" ./run.sh
-
-	# Cleanup.
-	docker rm -f "$ID"
-done
-
-# Latest experimental version
-
-echo "Extracting Docker master from dind image"
-binpath="$tmpdir/docker-master/docker"
-docker pull dockerswarm/dind-master
-ID=$(docker create dockerswarm/dind-master)
-docker cp "$ID:/usr/local/bin/docker" "$tmpdir/docker-master"
-
-echo "Running tests with Docker master"
-DOCKER_BINARY="$binpath" DOCKER_VOLUME="$DOCKER_VOLUME" ./run.sh
-
-# Cleanup.
-docker rm -f "$ID"

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/test_runner.sh

@@ -1,18 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-cd "$(dirname "$(readlink -f "$BASH_SOURCE")")"
-
-TESTS=${@:-.}
-
-function execute() {
-	>&2 echo "++ $@"
-	eval "$@"
-}
-
-execute time docker-compose build
-
-execute docker-compose up -d
-
-# Run the tests.
-execute time bats -p $TESTS

Godeps/_workspace/src/github.com/docker/distribution/contrib/docker-integration/tls.bats

@@ -1,102 +0,0 @@
-# Registry host name, should be set to non-localhost address and match
-# DNS name in nginx/ssl certificates and what is installed in /etc/docker/cert.d
-hostname="localregistry"
-
-image="hello-world:latest"
-
-# Login information, should match values in nginx/test.passwd
-user="testuser"
-password="passpassword"
-email="distribution@docker.com"
-
-function setup() {
-	docker pull $image
-}
-
-# skip basic auth tests with Docker 1.6, where they don't pass due to
-# certificate issues
-function basic_auth_version_check() {
-	run sh -c 'docker version | fgrep -q "Client version: 1.6."'
-	if [ "$status" -eq 0 ]; then
-		skip "Basic auth tests don't support 1.6.x"
-	fi
-}
-
-# has_digest enforces the last output line is "Digest: sha256:..."
-# the input is the name of the array containing the output lines
-function has_digest() {
-	filtered=$(echo "$1" |sed -rn '/[dD]igest\: sha(256|384|512)/ p')
-	[ "$filtered" != "" ]
-}
-
-function login() {
-	run docker login -u $user -p $password -e $email $1
-	[ "$status" -eq 0 ]
-	# First line is WARNING about credential save
-	[ "${lines[1]}" = "Login Succeeded" ]
-}
-
-@test "Test valid certificates" {
-	docker tag -f $image $hostname:5440/$image
-	run docker push $hostname:5440/$image
-	[ "$status" -eq 0 ]
-	has_digest "$output"
-}
-
-@test "Test basic auth" {
-	basic_auth_version_check
-	login $hostname:5441
-	docker tag -f $image $hostname:5441/$image
-	run docker push $hostname:5441/$image
-	[ "$status" -eq 0 ]
-	has_digest "$output"
-}
-
-@test "Test TLS client auth" {
-	docker tag -f $image $hostname:5442/$image
-	run docker push $hostname:5442/$image
-	[ "$status" -eq 0 ]
-	has_digest "$output"
-}
-
-@test "Test TLS client with invalid certificate authority fails" {
-	docker tag -f $image $hostname:5443/$image
-	run docker push $hostname:5443/$image
-	[ "$status" -ne 0 ]
-}
-
-@test "Test basic auth with TLS client auth" {
-	basic_auth_version_check
-	login $hostname:5444
-	docker tag -f $image $hostname:5444/$image
-	run docker push $hostname:5444/$image
-	[ "$status" -eq 0 ]
-	has_digest "$output"
-}
-
-@test "Test unknown certificate authority fails" {
-	docker tag -f $image $hostname:5445/$image
-	run docker push $hostname:5445/$image
-	[ "$status" -ne 0 ]
-}
-
-@test "Test basic auth with unknown certificate authority fails" {
-	run login $hostname:5446
-	[ "$status" -ne 0 ]
-	docker tag -f $image $hostname:5446/$image
-	run docker push $hostname:5446/$image
-	[ "$status" -ne 0 ]
-}
-
-@test "Test TLS client auth to server with unknown certificate authority fails" {
-	docker tag -f $image $hostname:5447/$image
-	run docker push $hostname:5447/$image
-	[ "$status" -ne 0 ]
-}
-
-@test "Test failure to connect to server fails to fallback to SSLv3" {
-	docker tag -f $image $hostname:5448/$image
-	run docker push $hostname:5448/$image
-	[ "$status" -ne 0 ]
-}
-

Godeps/_workspace/src/github.com/docker/distribution/coverpkg.sh

@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-# Given a subpackage and the containing package, figures out which packages
-# need to be passed to `go test -coverpkg`:  this includes all of the
-# subpackage's dependencies within the containing package, as well as the
-# subpackage itself.
-DEPENDENCIES="$(go list -f $'{{range $f := .Deps}}{{$f}}\n{{end}}' ${1} | grep ${2})"
-echo "${1} ${DEPENDENCIES}" | xargs echo -n | tr ' ' ','