mirror of
https://github.com/clearlinux/docker.git
synced 2026-09-07 06:22:03 +00:00
Moved release scripts to hack/release and updated instructions.
This commit is contained in:
Jérôme Petazzoni
-133
@@ -1,133 +0,0 @@
|
||||
## A maintainer's guide to releasing Docker
|
||||
|
||||
So you're in charge of a docker release? Cool. Here's what to do.
|
||||
|
||||
If your experience deviates from this document, please document the changes to keep it
|
||||
up-to-date.
|
||||
|
||||
|
||||
### 1. Pull from master and create a release branch
|
||||
|
||||
```bash
|
||||
$ git checkout master
|
||||
$ git pull
|
||||
$ git checkout -b bump_$VERSION
|
||||
```
|
||||
|
||||
### 2. Update CHANGELOG.md
|
||||
|
||||
You can run this command for reference:
|
||||
|
||||
```bash
|
||||
LAST_VERSION=$(git tag | grep -E "v[0-9\.]+$" | sort -nr | head -n 1)
|
||||
git log $LAST_VERSION..HEAD
|
||||
```
|
||||
|
||||
Each change should be formatted as ```BULLET CATEGORY: DESCRIPTION```
|
||||
|
||||
* BULLET is either ```-```, ```+``` or ```*```, to indicate a bugfix,
|
||||
new feature or upgrade, respectively.
|
||||
|
||||
* CATEGORY should describe which part of the project is affected.
|
||||
Valid categories are:
|
||||
* Builder
|
||||
* Documentation
|
||||
* Hack
|
||||
* Packaging
|
||||
* Remote API
|
||||
* Runtime
|
||||
|
||||
* DESCRIPTION: a concise description of the change that is relevant to the end-user,
|
||||
using the present tense.
|
||||
Changes should be described in terms of how they affect the user, for example "new feature
|
||||
X which allows Y", "fixed bug which caused X", "increased performance of Y".
|
||||
|
||||
EXAMPLES:
|
||||
|
||||
```
|
||||
+ Builder: 'docker build -t FOO' applies the tag FOO to the newly built container.
|
||||
* Runtime: improve detection of kernel version
|
||||
- Remote API: fix a bug in the optional unix socket transport
|
||||
```
|
||||
|
||||
### 3. Change the contents of the VERSION file
|
||||
|
||||
### 4. Run all tests
|
||||
|
||||
```bash
|
||||
$ make test
|
||||
```
|
||||
|
||||
### 5. Commit and create a pull request
|
||||
|
||||
```bash
|
||||
$ git add commands.go CHANGELOG.md
|
||||
$ git commit -m "Bump version to $VERSION"
|
||||
$ git push origin bump_$VERSION
|
||||
```
|
||||
|
||||
### 6. Get 2 other maintainers to validate the pull request
|
||||
|
||||
### 7. Merge the pull request and apply tags
|
||||
|
||||
```bash
|
||||
$ git checkout master
|
||||
$ git merge bump_$VERSION
|
||||
$ git tag -a v$VERSION # Don't forget the v!
|
||||
$ git tag -f -a latest
|
||||
$ git push
|
||||
$ git push --tags
|
||||
```
|
||||
|
||||
### 8. Publish binaries
|
||||
|
||||
To run this you will need access to the release credentials.
|
||||
Get them from [the infrastructure maintainers](https://github.com/dotcloud/docker/blob/master/hack/infrastructure/MAINTAINERS).
|
||||
|
||||
```bash
|
||||
$ RELEASE_IMAGE=image_provided_by_infrastructure_maintainers
|
||||
$ BUILD=$(docker run -d -e RELEASE_PPA=0 $RELEASE_IMAGE)
|
||||
```
|
||||
|
||||
This will do 2 things:
|
||||
|
||||
* It will build and upload the binaries on http://get.docker.io
|
||||
* It will *test* the release on our Ubuntu PPA (a PPA is a community repository for ubuntu packages)
|
||||
|
||||
Wait for the build to complete.
|
||||
|
||||
```bash
|
||||
$ docker wait $BUILD # This should print 0. If it doesn't, your build failed.
|
||||
```
|
||||
|
||||
Check that the output looks OK. Here's an example of a correct output:
|
||||
|
||||
```bash
|
||||
$ docker logs 2>&1 b4e7c8299d73 | grep -e 'Public URL' -e 'Successfully uploaded'
|
||||
Public URL of the object is: http://get.docker.io.s3.amazonaws.com/builds/Linux/x86_64/docker-v0.4.7.tgz
|
||||
Public URL of the object is: http://get.docker.io.s3.amazonaws.com/builds/Linux/x86_64/docker-latest.tgz
|
||||
Successfully uploaded packages.
|
||||
```
|
||||
|
||||
If you don't see 3 lines similar to this, something might be wrong. Check the full logs and try again.
|
||||
|
||||
|
||||
### 9. Publish Ubuntu packages
|
||||
|
||||
If everything went well in the previous step, you can finalize the release by submitting the Ubuntu
|
||||
packages.
|
||||
|
||||
```bash
|
||||
$ RELEASE_IMAGE=image_provided_by_infrastructure_maintainers
|
||||
$ docker run -e RELEASE_PPA=1 $RELEASE_IMAGE
|
||||
```
|
||||
|
||||
If that goes well, Ubuntu Precise package is in its way. It will take anywhere from 0.5 to 30 hours
|
||||
for the builders to complete their job depending on builder demand at this time. At this point, Quantal
|
||||
and Raring packages need to be created using the Launchpad interface:
|
||||
https://launchpad.net/~dotcloud/+archive/lxc-docker/+packages
|
||||
|
||||
Notify [the packager maintainers](https://github.com/dotcloud/docker/blob/master/packaging/MAINTAINERS)
|
||||
who will ensure PPA is ready.
|
||||
|
||||
Congratulations! You're done
|
||||
@@ -0,0 +1,106 @@
|
||||
## A maintainer's guide to releasing Docker
|
||||
|
||||
So you're in charge of a Docker release? Cool. Here's what to do.
|
||||
|
||||
If your experience deviates from this document, please document the changes
|
||||
to keep it up-to-date.
|
||||
|
||||
|
||||
### 1. Pull from master and create a release branch
|
||||
|
||||
```bash
|
||||
git checkout master
|
||||
git pull
|
||||
git checkout -b bump_$VERSION
|
||||
```
|
||||
|
||||
### 2. Update CHANGELOG.md
|
||||
|
||||
You can run this command for reference:
|
||||
|
||||
```bash
|
||||
LAST_VERSION=$(git tag | grep -E "v[0-9\.]+$" | sort -nr | head -n 1)
|
||||
git log $LAST_VERSION..HEAD
|
||||
```
|
||||
|
||||
Each change should be formatted as ```BULLET CATEGORY: DESCRIPTION```
|
||||
|
||||
* BULLET is either ```-```, ```+``` or ```*```, to indicate a bugfix,
|
||||
new feature or upgrade, respectively.
|
||||
|
||||
* CATEGORY should describe which part of the project is affected.
|
||||
Valid categories are:
|
||||
* Builder
|
||||
* Documentation
|
||||
* Hack
|
||||
* Packaging
|
||||
* Remote API
|
||||
* Runtime
|
||||
|
||||
* DESCRIPTION: a concise description of the change that is relevant to the
|
||||
end-user, using the present tense. Changes should be described in terms
|
||||
of how they affect the user, for example "new feature X which allows Y",
|
||||
"fixed bug which caused X", "increased performance of Y".
|
||||
|
||||
EXAMPLES:
|
||||
|
||||
```
|
||||
+ Builder: 'docker build -t FOO' applies the tag FOO to the newly built
|
||||
container.
|
||||
* Runtime: improve detection of kernel version
|
||||
- Remote API: fix a bug in the optional unix socket transport
|
||||
```
|
||||
|
||||
### 3. Change the contents of the VERSION file
|
||||
|
||||
### 4. Run all tests
|
||||
|
||||
```bash
|
||||
go test
|
||||
```
|
||||
|
||||
### 5. Commit and create a pull request
|
||||
|
||||
```bash
|
||||
git add CHANGELOG.md
|
||||
git commit -m "Bump version to $VERSION"
|
||||
git push origin bump_$VERSION
|
||||
```
|
||||
|
||||
### 6. Get 2 other maintainers to validate the pull request
|
||||
|
||||
### 7. Merge the pull request and apply tags
|
||||
|
||||
```bash
|
||||
git checkout master
|
||||
git merge bump_$VERSION
|
||||
git tag -a v$VERSION # Don't forget the v!
|
||||
git tag -f -a latest
|
||||
git push
|
||||
git push --tags
|
||||
```
|
||||
|
||||
### 8. Publish binaries
|
||||
|
||||
To run this you will need access to the release credentials.
|
||||
Get them from [the infrastructure maintainers](
|
||||
https://github.com/dotcloud/docker/blob/master/hack/infrastructure/MAINTAINERS).
|
||||
|
||||
```bash
|
||||
docker build -t releasedocker .
|
||||
docker run \
|
||||
-e AWS_S3_BUCKET=get-nightly.docker.io \
|
||||
-e AWS_ACCESS_KEY=$(cat ~/.aws/access_key) \
|
||||
-e AWS_SECRET_KEY=$(cat ~/.aws/secret_key) \
|
||||
-e GPG_PASSPHRASE=supersecretsesame \
|
||||
releasedocker
|
||||
```
|
||||
|
||||
It will build and upload the binaries on the specified bucket (you should
|
||||
use get-nightly.docker.io for general testing, and once everything is fine,
|
||||
switch to get.docker.io).
|
||||
|
||||
|
||||
### 9. Rejoice!
|
||||
|
||||
Congratulations! You're done.
|
||||
Executable
+178
@@ -0,0 +1,178 @@
|
||||
#!/bin/sh
|
||||
|
||||
# This script builds various binary artifacts from a checkout of the docker
|
||||
# source code.
|
||||
#
|
||||
# Requirements:
|
||||
# - The current directory should be a checkout of the docker source code
|
||||
# (http://github.com/dotcloud/docker). Whatever version is checked out
|
||||
# will be built.
|
||||
# - The VERSION file, at the root of the repository, should exist, and
|
||||
# will be used as Docker binary version and package version.
|
||||
# - The hash of the git commit will also be included in the Docker binary,
|
||||
# with the suffix -dirty if the repository isn't clean.
|
||||
# - The script is intented to be run as part of a docker build, as defined
|
||||
# in the Dockerfile at the root of the source. In other words:
|
||||
# DO NOT CALL THIS SCRIPT DIRECTLY.
|
||||
# - The right way to call this script is to invoke "docker build ." from
|
||||
# your checkout of the Docker repository.
|
||||
#
|
||||
|
||||
set -e
|
||||
set -x
|
||||
|
||||
# We're a nice, sexy, little shell script, and people might try to run us;
|
||||
# but really, they shouldn't. We want to be in a container!
|
||||
RESOLVCONF=$(readlink --canonicalize /etc/resolv.conf)
|
||||
grep -q "$RESOLVCONF" /proc/mounts || {
|
||||
echo "# I will only run within a container."
|
||||
echo "# Try this instead:"
|
||||
echo "docker build ."
|
||||
exit 1
|
||||
}
|
||||
|
||||
VERSION=$(cat ./VERSION)
|
||||
PKGVERSION="$VERSION"
|
||||
GITCOMMIT=$(git rev-parse --short HEAD)
|
||||
if test -n "$(git status --porcelain)"
|
||||
then
|
||||
GITCOMMIT="$GITCOMMIT-dirty"
|
||||
PKGVERSION="$PKGVERSION-$(date +%Y%m%d%H%M%S)-$GITCOMMIT"
|
||||
fi
|
||||
|
||||
PACKAGE_ARCHITECTURE="$(dpkg-architecture -qDEB_HOST_ARCH)"
|
||||
PACKAGE_URL="http://www.docker.io/"
|
||||
PACKAGE_MAINTAINER="docker@dotcloud.com"
|
||||
PACKAGE_DESCRIPTION="lxc-docker is a Linux container runtime
|
||||
Docker complements LXC with a high-level API which operates at the process
|
||||
level. It runs unix processes with strong guarantees of isolation and
|
||||
repeatability across servers.
|
||||
Docker is a great building block for automating distributed systems:
|
||||
large-scale web deployments, database clusters, continuous deployment systems,
|
||||
private PaaS, service-oriented architectures, etc."
|
||||
|
||||
UPSTART_SCRIPT='description "Docker daemon"
|
||||
|
||||
start on filesystem or runlevel [2345]
|
||||
stop on runlevel [!2345]
|
||||
|
||||
respawn
|
||||
|
||||
exec docker -d
|
||||
'
|
||||
|
||||
# Each "bundle" is a different type of build artefact: static binary, Ubuntu
|
||||
# package, etc.
|
||||
|
||||
# Build Docker as a static binary file
|
||||
bundle_binary() {
|
||||
mkdir -p bundles/$VERSION/binary
|
||||
go build -o bundles/$VERSION/binary/docker-$VERSION \
|
||||
-ldflags "-X main.GITCOMMIT $GITCOMMIT -X main.VERSION $VERSION -d -w" \
|
||||
./docker
|
||||
}
|
||||
|
||||
|
||||
# Build Docker's test suite as a collection of binary files (one per
|
||||
# sub-package to test)
|
||||
bundle_test() {
|
||||
mkdir -p bundles/$VERSION/test
|
||||
for test_dir in $(find_test_dirs); do
|
||||
test_binary=$(
|
||||
cd $test_dir
|
||||
go test -c -v -ldflags "-X main.GITCOMMIT $GITCOMMIT -X main.VERSION $VERSION -d -w" >&2
|
||||
find . -maxdepth 1 -type f -name '*.test' -executable
|
||||
)
|
||||
cp $test_dir/$test_binary bundles/$VERSION/test/
|
||||
done
|
||||
}
|
||||
|
||||
# Build docker as an ubuntu package using FPM and REPREPRO (sue me).
|
||||
# bundle_binary must be called first.
|
||||
bundle_ubuntu() {
|
||||
mkdir -p bundles/$VERSION/ubuntu
|
||||
|
||||
DIR=$(pwd)/bundles/$VERSION/ubuntu/build
|
||||
|
||||
# Generate an upstart config file (ubuntu-specific)
|
||||
mkdir -p $DIR/etc/init
|
||||
echo "$UPSTART_SCRIPT" > $DIR/etc/init/docker.conf
|
||||
|
||||
# Copy the binary
|
||||
mkdir -p $DIR/usr/bin
|
||||
cp bundles/$VERSION/binary/docker-$VERSION $DIR/usr/bin/docker
|
||||
|
||||
# Generate postinstall/prerm scripts
|
||||
cat >/tmp/postinstall <<EOF
|
||||
#!/bin/sh
|
||||
/sbin/stop docker || true
|
||||
/sbin/start docker
|
||||
EOF
|
||||
cat >/tmp/prerm <<EOF
|
||||
#!/bin/sh
|
||||
/sbin/stop docker || true
|
||||
EOF
|
||||
chmod +x /tmp/postinstall /tmp/prerm
|
||||
|
||||
(
|
||||
cd bundles/$VERSION/ubuntu
|
||||
fpm -s dir -C $DIR \
|
||||
--name lxc-docker-$VERSION --version $PKGVERSION \
|
||||
--after-install /tmp/postinstall \
|
||||
--before-remove /tmp/prerm \
|
||||
--architecture "$PACKAGE_ARCHITECTURE" \
|
||||
--prefix / \
|
||||
--depends lxc --depends aufs-tools \
|
||||
--description "$PACKAGE_DESCRIPTION" \
|
||||
--maintainer "$PACKAGE_MAINTAINER" \
|
||||
--conflicts lxc-docker-virtual-package \
|
||||
--provides lxc-docker \
|
||||
--provides lxc-docker-virtual-package \
|
||||
--replaces lxc-docker \
|
||||
--replaces lxc-docker-virtual-package \
|
||||
--url "$PACKAGE_URL" \
|
||||
--vendor "$PACKAGE_VENDOR" \
|
||||
-t deb .
|
||||
mkdir empty
|
||||
fpm -s dir -C empty \
|
||||
--name lxc-docker --version $PKGVERSION \
|
||||
--architecture "$PACKAGE_ARCHITECTURE" \
|
||||
--depends lxc-docker-$VERSION \
|
||||
--description "$PACKAGE_DESCRIPTION" \
|
||||
--maintainer "$PACKAGE_MAINTAINER" \
|
||||
--url "$PACKAGE_URL" \
|
||||
--vendor "$PACKAGE_VENDOR" \
|
||||
-t deb .
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
# This helper function walks the current directory looking for directories
|
||||
# holding Go test files, and prints their paths on standard output, one per
|
||||
# line.
|
||||
find_test_dirs() {
|
||||
find . -name '*_test.go' |
|
||||
{ while read f; do dirname $f; done; } |
|
||||
sort -u
|
||||
}
|
||||
|
||||
|
||||
main() {
|
||||
bundle_binary
|
||||
bundle_ubuntu
|
||||
#bundle_test
|
||||
cat <<EOF
|
||||
###############################################################################
|
||||
Now run the resulting image, making sure that you set AWS_S3_BUCKET,
|
||||
AWS_ACCESS_KEY, and AWS_SECRET_KEY environment variables:
|
||||
|
||||
docker run -e AWS_S3_BUCKET=get-staging.docker.io \\
|
||||
AWS_ACCESS_KEY=AKI1234... \\
|
||||
AWS_SECRET_KEY=sEs3mE... \\
|
||||
GPG_PASSPHRASE=sesame... \\
|
||||
image_id_or_name
|
||||
###############################################################################
|
||||
EOF
|
||||
}
|
||||
|
||||
main
|
||||
Executable
+176
@@ -0,0 +1,176 @@
|
||||
#!/bin/sh
|
||||
|
||||
# This script looks for bundles built by make.sh, and releases them on a
|
||||
# public S3 bucket.
|
||||
#
|
||||
# Bundles should be available for the VERSION string passed as argument.
|
||||
#
|
||||
# The correct way to call this script is inside a container built by the
|
||||
# official Dockerfile at the root of the Docker source code. The Dockerfile,
|
||||
# make.sh and release.sh should all be from the same source code revision.
|
||||
|
||||
set -x
|
||||
set -e
|
||||
|
||||
# Print a usage message and exit.
|
||||
usage() {
|
||||
cat <<EOF
|
||||
To run, I need:
|
||||
- to be in a container generated by the Dockerfile at the top of the Docker
|
||||
repository;
|
||||
- to be provided with the name of an S3 bucket, in environment variable
|
||||
AWS_S3_BUCKET;
|
||||
- to be provided with AWS credentials for this S3 bucket, in environment
|
||||
variables AWS_ACCESS_KEY and AWS_SECRET_KEY;
|
||||
- the passphrase to unlock the GPG key which will sign the deb packages
|
||||
(passed as environment variable GPG_PASSPHRASE);
|
||||
- a generous amount of good will and nice manners.
|
||||
The canonical way to run me is to run the image produced by the Dockerfile: e.g.:"
|
||||
|
||||
docker run -e AWS_S3_BUCKET=get-staging.docker.io \\
|
||||
AWS_ACCESS_KEY=AKI1234... \\
|
||||
AWS_SECRET_KEY=sEs4mE... \\
|
||||
GPG_PASSPHRASE=m0resEs4mE... \\
|
||||
f0058411
|
||||
EOF
|
||||
exit 1
|
||||
}
|
||||
|
||||
[ "$AWS_S3_BUCKET" ] || usage
|
||||
[ "$AWS_ACCESS_KEY" ] || usage
|
||||
[ "$AWS_SECRET_KEY" ] || usage
|
||||
[ "$GPG_PASSPHRASE" ] || usage
|
||||
[ -d /go/src/github.com/dotcloud/docker/ ] || usage
|
||||
cd /go/src/github.com/dotcloud/docker/
|
||||
|
||||
VERSION=$(cat VERSION)
|
||||
BUCKET=$AWS_S3_BUCKET
|
||||
|
||||
setup_s3() {
|
||||
# Try creating the bucket. Ignore errors (it might already exist).
|
||||
s3cmd mb s3://$BUCKET 2>/dev/null || true
|
||||
# Check access to the bucket.
|
||||
# s3cmd has no useful exit status, so we cannot check that.
|
||||
# Instead, we check if it outputs anything on standard output.
|
||||
# (When there are problems, it uses standard error instead.)
|
||||
s3cmd info s3://$BUCKET | grep -q .
|
||||
# Make the bucket accessible through website endpoints.
|
||||
s3cmd ws-create --ws-index index --ws-error error s3://$BUCKET
|
||||
}
|
||||
|
||||
# write_to_s3 uploads the contents of standard input to the specified S3 url.
|
||||
write_to_s3() {
|
||||
DEST=$1
|
||||
F=`mktemp`
|
||||
cat > $F
|
||||
s3cmd --acl-public put $F $DEST
|
||||
rm -f $F
|
||||
}
|
||||
|
||||
s3_url() {
|
||||
echo "http://$BUCKET.s3.amazonaws.com"
|
||||
}
|
||||
|
||||
# Upload the 'ubuntu' bundle to S3:
|
||||
# 1. A full APT repository is published at $BUCKET/ubuntu/
|
||||
# 2. Instructions for using the APT repository are uploaded at $BUCKET/ubuntu/info
|
||||
release_ubuntu() {
|
||||
# Make sure that we have our keys
|
||||
mkdir -p /.gnupg/
|
||||
s3cmd sync s3://$BUCKET/ubuntu/.gnupg/ /.gnupg/ || true
|
||||
gpg --list-keys releasedocker >/dev/null || {
|
||||
gpg --gen-key --batch <<EOF
|
||||
Key-Type: RSA
|
||||
Key-Length: 2048
|
||||
Passphrase: $GPG_PASSPHRASE
|
||||
Name-Real: Docker Release Tool
|
||||
Name-Email: docker@dotcloud.com
|
||||
Name-Comment: releasedocker
|
||||
Expire-Date: 0
|
||||
%commit
|
||||
EOF
|
||||
}
|
||||
|
||||
# Sign our packages
|
||||
dpkg-sig -g "--passphrase $GPG_PASSPHRASE" -k releasedocker \
|
||||
--sign builder bundles/$VERSION/ubuntu/*.deb
|
||||
|
||||
# Setup the APT repo
|
||||
APTDIR=bundles/$VERSION/ubuntu/apt
|
||||
mkdir -p $APTDIR/conf $APTDIR/db
|
||||
s3cmd sync s3://$BUCKET/ubuntu/db/ $APTDIR/db/ || true
|
||||
cat > $APTDIR/conf/distributions <<EOF
|
||||
Codename: docker
|
||||
Components: main
|
||||
Architectures: amd64 i386
|
||||
EOF
|
||||
|
||||
# Add the DEB package to the APT repo
|
||||
DEBFILE=bundles/$VERSION/ubuntu/lxc-docker*.deb
|
||||
reprepro -b $APTDIR includedeb docker $DEBFILE
|
||||
|
||||
# Sign
|
||||
for F in $(find $APTDIR -name Release)
|
||||
do
|
||||
gpg -u releasedocker --passphrase $GPG_PASSPHRASE \
|
||||
--armor --sign --detach-sign \
|
||||
--output $F.gpg $F
|
||||
done
|
||||
|
||||
# Upload keys
|
||||
s3cmd sync /.gnupg/ s3://$BUCKET/ubuntu/.gnupg/
|
||||
gpg --armor --export releasedocker > bundles/$VERSION/ubuntu/gpg
|
||||
s3cmd --acl-public put bundles/$VERSION/ubuntu/gpg s3://$BUCKET/gpg
|
||||
|
||||
# Upload repo
|
||||
s3cmd --acl-public sync $APTDIR/ s3://$BUCKET/ubuntu/
|
||||
cat <<EOF | write_to_s3 s3://$BUCKET/ubuntu/info
|
||||
# Add the repository to your APT sources
|
||||
echo deb $(s3_url $BUCKET)/ubuntu docker main > /etc/apt/sources.list.d/docker.list
|
||||
# Then import the repository key
|
||||
curl $(s3_url $BUCKET)/gpg | apt-key add -
|
||||
# Install docker
|
||||
apt-get update ; apt-get install -y lxc-docker
|
||||
EOF
|
||||
echo "APT repository uploaded. Instructions available at $(s3_url $BUCKET)/ubuntu/info"
|
||||
}
|
||||
|
||||
# Upload a static binary to S3
|
||||
release_binary() {
|
||||
[ -e bundles/$VERSION ]
|
||||
S3DIR=s3://$BUCKET/builds/Linux/x86_64
|
||||
s3cmd --acl-public put bundles/$VERSION/binary/docker-$VERSION $S3DIR/docker-$VERSION
|
||||
cat <<EOF | write_to_s3 s3://$BUCKET/builds/info
|
||||
# To install, run the following command as root:
|
||||
curl -O http://$BUCKET.s3.amazonaws.com/builds/Linux/x86_64/docker-$VERSION && chmod +x docker-$VERSION && sudo mv docker-$VERSION /usr/local/bin/docker
|
||||
# Then start docker in daemon mode:
|
||||
sudo /usr/local/bin/docker -d
|
||||
EOF
|
||||
if [ -z "$NOLATEST" ]; then
|
||||
echo "Copying docker-$VERSION to docker-latest"
|
||||
s3cmd --acl-public cp $S3DIR/docker-$VERSION $S3DIR/docker-latest
|
||||
echo "Advertising $VERSION on $BUCKET as most recent version"
|
||||
echo $VERSION | write_to_s3 s3://$BUCKET/latest
|
||||
fi
|
||||
}
|
||||
|
||||
# Upload the index script
|
||||
release_index() {
|
||||
(
|
||||
if [ "$BUCKET" != "get.docker.io" ]
|
||||
then
|
||||
sed s,https://get.docker.io/,http://$BUCKET.s3.amazonaws.com/, contrib/install.sh
|
||||
else
|
||||
cat contrib/install.sh
|
||||
fi
|
||||
) | write_to_s3 s3://$BUCKET/index
|
||||
}
|
||||
|
||||
main() {
|
||||
setup_s3
|
||||
release_binary
|
||||
release_ubuntu
|
||||
release_index
|
||||
}
|
||||
|
||||
main
|
||||
Reference in New Issue
Block a user