docker-api 1.26.2 → 1.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc23f00b0653acb770223bb93732fd1c5fc2b271
-  data.tar.gz: 1107a9c03e159bdf9e088bf7d89c93b074cac97f
+  metadata.gz: a402451b60cf3ee27d968b6c406b763ba02fd064
+  data.tar.gz: 239c7b7261f471873819ade511325c785e632d0f
 SHA512:
-  metadata.gz: 057abba527419ba36ede9fc86770d4aa0d189ab17766cec6c84a1d463d80e400b18af6ac645a95ff67886b253fe6ae29c948797c69cbfa67b239288243d1260d
-  data.tar.gz: 60cb8cbba5a878137e46e13e5c76b9087e9cdaab010c1c30f322a8a9ef363dcb5a80209cdfb7b6d0fa298e39404953ca82f4047ed51d55acb057770da5389669
+  metadata.gz: 68228f7e53d244b754ce9c26c3a2e412c4162595ae4fc069afea00aa5b89a499f205bcd2be5e055a274ce6e1f5ef2a9188dec364c2086505817176c4bb66a737
+  data.tar.gz: 128d69692f073e103aeef72af0743d5ab3db5020b770242f8df4964da3b0ec6c88c70e587e25822e0a66c80cd3c6bebfdf05f7fa90d501850960b71272c29df9

data/.travis.yml

@@ -1,18 +1,25 @@
 sudo: required
 dist: trusty
-cache: bundler
 language: ruby
+cache: bundler
 rvm:
-  - 1.9.3
-  - 2.0
-  - 2.1
   - 2.2
+  - 2.1
+  - 2.0
+  - 1.9.3
 env:
-  - DOCKER_VERSION=1.6.2
-  - DOCKER_VERSION=1.7.1
-  - DOCKER_VERSION=1.8.3
+  - DOCKER_VERSION=1.10.3
   - DOCKER_VERSION=1.9.1
-before_install: ./script/install_dependencies.sh
+  - DOCKER_VERSION=1.8.2
+  - DOCKER_VERSION=1.7.1
+  - DOCKER_VERSION=1.6.2
+matrix:
+  fast_finish: true
+before_install:
+ - docker --version
+ - gem install bundler
 before_script:
- - export PATH=/opt/docker:$PATH
- - docker version
+ - sudo ./script/install_docker.sh ${DOCKER_VERSION}
+ - uname -a
+ - docker --version
+ - docker info

data/README.md

@@ -186,6 +186,10 @@ image.save('my_export.tar')
 image.save
 # => "abiglongbinarystring"
 
+# Stream the contents of the image to a block:
+image.save_stream { |chunk| puts chunk }
+# => nil
+
 # Given a Container's export, creates a new Image.
 # docker command for reference: docker import some-export.tar
 Docker::Image.import('some-export.tar')
@@ -210,6 +214,11 @@ Docker::Image.build("from base\nrun touch /test")
 Docker::Image.build_from_dir('.')
 # => Docker::Image { :id => 1266dc19e, :connection => Docker::Connection { :url => tcp://localhost, :options => {:port=>2375} } }
 
+# Create an Image from a file other than Dockerfile.
+# docker command for reference: docker build -f Dockerfile.Centos .
+Docker::Image.build_from_dir('.', { 'dockerfile' => 'Dockerfile.Centos' })
+# => Docker::Image { :id => 1266dc19e, :connection => Docker::Connection { :url => tcp://localhost, :options => {:port=>2375} } }
+
 # Create an Image from a Dockerfile and stream the logs
 Docker::Image.build_from_dir('.') do |v|
   if (log = JSON.parse(v)) && log.has_key?("stream")
@@ -247,6 +256,11 @@ names = %w( my_image1 my_image2:not_latest )
 Docker::Image.save(names)
 # => "abiglongbinarystring"
 
+# Stream the raw binary data
+names = %w( my_image1 my_image2:not_latest )
+Docker::Image.save_stream(names) { |chunk| puts chunk }
+# => nil
+
 # Search the Docker registry.
 # docker command for reference: docker search sshd
 Docker::Image.search('term' => 'sshd')
@@ -429,12 +443,30 @@ Docker::Container.get('500f53b25e6e')
 # Request all of the Containers. By default, will only return the running Containers.
 Docker::Container.all(:all => true)
 # => [Docker::Container { :id => , :connection => Docker::Connection { :url => tcp://localhost, :options => {:port=>2375} } }]
+```
+
+## JSON encoded values
+
+For JSON encoded values, nothing is done implicitly, meaning you need to explicitly call `to_json` on your parameter before the call. For example, to request all of the Containers using a filter:
+
+```ruby
+require 'docker'
 
 # Request all of the Containers, filtering by status exited.
 Docker::Container.all(all: true, filters: { status: ["exited"] }.to_json)
 # => [Docker::Container { :id => , :connection => Docker::Connection { :url => tcp://localhost, :options => {:port=>2375} } }]
+
+# Request all of the Container, filtering by label_name.
+Docker::Container.all(all: true, filters: { label: [ "label_name"  ]  }.to_json)
+# => [Docker::Container { :id => , :connection => Docker::Connection { :url => tcp://localhost, :options => {:port=>2375} } }]
+
+# Request all of the Container, filtering by label label_name that have the value label_value_.
+Docker::Container.all(all: true, filters: { label: [ "label_name=label_value"  ]  }.to_json)
+# => [Docker::Container { :id => , :connection => Docker::Connection { :url => tcp://localhost, :options => {:port=>2375} } }]
 ```
 
+This applies for all parameters that are requested to be JSON encoded by the docker api.
+
 ## Events
 
 ```ruby
@@ -486,6 +518,10 @@ image 'repo:new_tag' => 'repo:tag' do
 end
 ```
 
+## Known issues
+
+*   If the docker daemon is always responding to your requests with a 400 Bad Request when using UNIX sockets, verify you're running Excon version 0.46.0 or greater. [Link](https://github.com/swipely/docker-api/issues/381)
+
 ## Not supported (yet)
 
 *   Generating a tarball of images and metadata for a repository specified by a name: https://docs.docker.com/engine/reference/api/docker_remote_api_v1.14/#get-a-tarball-containing-all-images-and-tags-in-a-repository

data/lib/docker.rb

@@ -112,6 +112,11 @@ module Docker
     Util.parse_json(connection.get('/info'))
   end
 
+  # Ping the Docker server.
+  def ping(connection = self.connection)
+    connection.get('/_ping')
+  end
+
   # Login to the Docker registry.
   def authenticate!(options = {}, connection = self.connection)
     creds = options.to_json
@@ -134,5 +139,5 @@ module Docker
   module_function :default_socket_url, :env_url, :url, :url=, :env_options,
                   :options, :options=, :creds, :creds=, :logger, :logger=,
                   :connection, :reset!, :reset_connection!, :version, :info,
-                  :authenticate!, :validate_version!, :ssl_options
+                  :ping, :authenticate!, :validate_version!, :ssl_options
 end

data/lib/docker/image.rb

@@ -89,6 +89,11 @@ class Docker::Image
     self.class.save(self.id, filename, connection)
   end
 
+  # Save the image as a tarball to an IO object.
+  def save_stream(opts = {}, &block)
+    self.class.save_stream(self.id, opts, connection, &block)
+  end
+
   # Update the @info hash, which is the only mutable state in this object.
   def refresh!
     img = Docker::Image.all({:all => true}, connection).find { |image|
@@ -133,27 +138,49 @@ class Docker::Image
     # representation of the binary data. If the filename is not nil, then
     # return nil.
     def save(names, filename = nil, conn = Docker.connection)
-      # By using compare_by_identity we can create a Hash that has
-      # the same key multiple times.
-      query = {}
-      query.compare_by_identity
-      Array(names).each do |name|
-        query['names'.dup] = URI.encode(name)
-      end
-
       if filename
-        file = File.open(filename, 'wb')
-        conn.get(
-          '/images/get', query,
-          :response_block => response_block_for_save(file)
-        )
-        file.close
+        File.open(filename, 'wb') do |file|
+          save_stream(names, {}, conn, &response_block_for_save(file))
+        end
         nil
       else
-        conn.get('/images/get', query)
+        string = ''
+        save_stream(names, {}, conn, &response_block_for_save(string))
+        string
       end
     end
 
+    # Stream the contents of Docker image(s) to a block.
+    #
+    # @param names [String, Array#String] The image(s) you wish to save
+    # @param conn [Docker::Connection] The Docker connection to use
+    # @yield chunk [String] a chunk of the Docker image(s).
+    def save_stream(names, opts = {}, conn = Docker.connection, &block)
+      # By using compare_by_identity we can create a Hash that has
+      # the same key multiple times.
+      query = {}.tap(&:compare_by_identity)
+      Array(names).each { |name| query['names'.dup] = URI.encode(name) }
+      conn.get(
+        '/images/get',
+        query,
+        opts.merge(:response_block => block)
+      )
+      nil
+    end
+
+    # Load a tar Image
+    def load(tar, opts = {}, conn = Docker.connection, creds = nil, &block)
+       headers = build_headers(creds)
+       body = ""
+       f = File.open(tar,'rb')
+       conn.post(
+         '/images/load',
+         opts,
+         :headers => headers,
+         :response_block => response_block(body, &block)
+       ) { f.read(Excon.defaults[:chunk_size]).to_s }
+    end
+
     # Check if an image exists.
     def exist?(id, opts = {}, conn = Docker.connection)
       get(id, opts, conn)

data/lib/docker/version.rb

@@ -1,6 +1,6 @@
 module Docker
   # The version of the docker-api gem.
-  VERSION = '1.26.2'
+  VERSION = '1.27.0'
 
   # The version of the compatible Docker remote API.
   API_VERSION = '1.16'

data/lib/docker/volume.rb

@@ -23,10 +23,8 @@ class Docker::Volume
     # /volumes endpoint returns an array of hashes incapsulated in an Volumes tag
     def all(opts = {}, conn = Docker.connection)
       resp = conn.get('/volumes')
-      hashes = Docker::Util.parse_json(resp) || []
-      if hashes.has_key?("Volumes")
-         hashes =  hashes['Volumes']
-      end
+      json = Docker::Util.parse_json(resp) || {}
+      hashes = json['Volumes'] || []
       hashes.map { |hash| new(conn, hash) }
     end
 

data/script/docker

@@ -0,0 +1,149 @@
+#!/bin/sh
+set -e
+
+### BEGIN INIT INFO
+# Provides:           docker
+# Required-Start:     $syslog $remote_fs
+# Required-Stop:      $syslog $remote_fs
+# Should-Start:       cgroupfs-mount cgroup-lite
+# Should-Stop:        cgroupfs-mount cgroup-lite
+# Default-Start:      2 3 4 5
+# Default-Stop:       0 1 6
+# Short-Description:  Create lightweight, portable, self-sufficient containers.
+# Description:
+#  Docker is an open-source project to easily create lightweight, portable,
+#  self-sufficient containers from any application. The same container that a
+#  developer builds and tests on a laptop can run at scale, in production, on
+#  VMs, bare metal, OpenStack clusters, public clouds and more.
+### END INIT INFO
+
+export PATH=/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin
+
+BASE=$(basename $0)
+
+# modify these in /etc/default/$BASE (/etc/default/docker)
+DOCKER=/usr/bin/$BASE
+# This is the pid file managed by docker itself
+DOCKER_PIDFILE=/var/run/$BASE.pid
+# This is the pid file created/managed by start-stop-daemon
+DOCKER_SSD_PIDFILE=/var/run/$BASE-ssd.pid
+DOCKER_LOGFILE=/var/log/$BASE.log
+DOCKER_OPTS=
+DOCKER_DESC="Docker"
+
+# Get lsb functions
+. /lib/lsb/init-functions
+
+if [ -f /etc/default/$BASE ]; then
+        . /etc/default/$BASE
+fi
+
+# Check docker is present
+if [ ! -x $DOCKER ]; then
+        log_failure_msg "$DOCKER not present or not executable"
+        exit 1
+fi
+
+check_init() {
+         # see also init_is_upstart in /lib/lsb/init-functions (which isn't available in Ubuntu 12.04, or we'd use it directly)
+         if [ -x /sbin/initctl ] && /sbin/initctl version 2>/dev/null | grep -q upstart; then
+                log_failure_msg "$DOCKER_DESC is managed via upstart, try using service $BASE $1"
+                exit 1
+         fi
+}
+
+fail_unless_root() {
+        if [ "$(id -u)" != '0' ]; then
+                log_failure_msg "$DOCKER_DESC must be run as root"
+                exit 1
+        fi
+}
+
+cgroupfs_mount() {
+        # see also https://github.com/tianon/cgroupfs-mount/blob/master/cgroupfs-mount
+        if grep -v '^#' /etc/fstab | grep -q cgroup \
+                || [ ! -e /proc/cgroups ] \
+                || [ ! -d /sys/fs/cgroup ]; then
+                return
+        fi
+        if ! mountpoint -q /sys/fs/cgroup; then
+                mount -t tmpfs -o uid=0,gid=0,mode=0755 cgroup /sys/fs/cgroup
+        fi
+        (
+                cd /sys/fs/cgroup
+                for sys in $(awk '!/^#/ { if ($4 == 1) print $1 }' /proc/cgroups); do
+                        mkdir -p $sys
+                        if ! mountpoint -q $sys; then
+                                if ! mount -n -t cgroup -o $sys cgroup $sys; then
+                                        rmdir $sys || true
+                                fi
+                        fi
+                done
+        )
+}
+
+case "$1" in
+        start)
+                check_init
+
+                fail_unless_root
+
+                cgroupfs_mount
+
+                touch "$DOCKER_LOGFILE"
+                chgrp docker "$DOCKER_LOGFILE"
+
+                ulimit -n 1048576
+                if [ "$BASH" ]; then
+                        ulimit -u 1048576
+                else
+                        ulimit -p 1048576
+                fi
+
+                log_begin_msg "Starting $DOCKER_DESC: $BASE"
+                start-stop-daemon --start --background \
+                        --no-close \
+                        --exec "$DOCKER" \
+                        --pidfile "$DOCKER_SSD_PIDFILE" \
+                        --make-pidfile \
+                        -- \
+                                -d -p "$DOCKER_PIDFILE" \
+                                $DOCKER_OPTS \
+                                        >> "$DOCKER_LOGFILE" 2>&1
+                log_end_msg $?
+                ;;
+
+        stop)
+                check_init
+                fail_unless_root
+                log_begin_msg "Stopping $DOCKER_DESC: $BASE"
+                start-stop-daemon --stop --pidfile "$DOCKER_SSD_PIDFILE"
+                log_end_msg $?
+                ;;
+
+        restart)
+                check_init
+                fail_unless_root
+                docker_pid=`cat "$DOCKER_SSD_PIDFILE" 2>/dev/null`
+                [ -n "$docker_pid" ] \
+                        && ps -p $docker_pid > /dev/null 2>&1 \
+                        && $0 stop
+                $0 start
+                ;;
+
+        force-reload)
+                check_init
+                fail_unless_root
+                $0 restart
+                ;;
+
+        status)
+                check_init
+                status_of_proc -p "$DOCKER_SSD_PIDFILE" "$DOCKER" "$DOCKER_DESC"
+                ;;
+
+        *)
+                echo "Usage: service docker {start|stop|restart|status}"
+                exit 1
+                ;;
+esac

data/script/docker.conf

@@ -0,0 +1,61 @@
+description "Docker daemon"
+
+start on (local-filesystems and net-device-up IFACE!=lo)
+stop on runlevel [!2345]
+limit nofile 524288 1048576
+limit nproc 524288 1048576
+
+respawn
+
+kill timeout 20
+
+pre-start script
+        # see also https://github.com/tianon/cgroupfs-mount/blob/master/cgroupfs-mount
+        if grep -v '^#' /etc/fstab | grep -q cgroup \
+                || [ ! -e /proc/cgroups ] \
+                || [ ! -d /sys/fs/cgroup ]; then
+                exit 0
+        fi
+        if ! mountpoint -q /sys/fs/cgroup; then
+                mount -t tmpfs -o uid=0,gid=0,mode=0755 cgroup /sys/fs/cgroup
+        fi
+        (
+                cd /sys/fs/cgroup
+                for sys in $(awk '!/^#/ { if ($4 == 1) print $1 }' /proc/cgroups); do
+                        mkdir -p $sys
+                        if ! mountpoint -q $sys; then
+                                if ! mount -n -t cgroup -o $sys cgroup $sys; then
+                                        rmdir $sys || true
+                                fi
+                        fi
+                done
+        )
+end script
+
+script
+        # modify these in /etc/default/$UPSTART_JOB (/etc/default/docker)
+        DOCKER=/usr/bin/$UPSTART_JOB
+        DOCKER_OPTS=
+        if [ -f /etc/default/$UPSTART_JOB ]; then
+                . /etc/default/$UPSTART_JOB
+        fi
+        exec "$DOCKER" -d $DOCKER_OPTS
+end script
+
+# Don't emit "started" event until docker.sock is ready.
+# See https://github.com/docker/docker/issues/6647
+post-start script
+        DOCKER_OPTS=
+        if [ -f /etc/default/$UPSTART_JOB ]; then
+                . /etc/default/$UPSTART_JOB
+        fi
+        if ! printf "%s" "$DOCKER_OPTS" | grep -qE -e '-H|--host'; then
+                while ! [ -e /var/run/docker.sock ]; do
+                        initctl status $UPSTART_JOB | grep -qE "(stop|respawn)/" && exit 1
+                        echo "Waiting for /var/run/docker.sock"
+                        sleep 0.1
+                done
+                echo "/var/run/docker.sock is up"
+        fi
+end script
+

data/script/install_docker.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+set -x
+set -e
+
+# argv[0]
+DOCKER_VERSION=$1
+
+# disable travis default installation
+service docker stop
+apt-get -y --purge remove docker-engine
+
+# install gpg key for docker rpo
+apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv 58118E89F3A912897C070ADBF76221572C52609D
+
+# enable docker repo
+echo 'deb "https://apt.dockerproject.org/repo" ubuntu-trusty main' >> /etc/apt/sources.list.d/docker-main.list
+apt-get update -o Dir::Etc::sourcelist='sources.list.d/docker-main.list' -o Dir::Etc::sourceparts='-' -o APT::Get::List-Cleanup='0'
+apt-cache gencaches
+
+# install package
+apt-get -y --force-yes install docker-engine=${DOCKER_VERSION}-0~trusty
+echo 'DOCKER_OPTS="-H unix:///var/run/docker.sock --pidfile=/var/run/docker.pid"' > /etc/default/docker
+cat /etc/default/docker
+
+# docker 1.6 packages did not come with init files
+if [[ $DOCKER_VERSION == 1.6.* ]]
+then
+    cp script/docker.conf /etc/init/docker.conf
+    cp script/docker /etc/init.d/docker
+    chmod +x /etc/init.d/docker
+else
+    service docker stop
+fi
+
+service docker start

data/spec/docker/exec_spec.rb

@@ -133,13 +133,17 @@ describe Docker::Exec do
       after { container.kill!.remove }
 
       it 'returns empty stdout/stderr messages with exitcode' do
-        expect(subject.start!(:detach => true)).to eq([[],[], 0])
+        expect(subject.start!(:detach => true).length).to eq(3)
       end
     end
 
     context 'when :wait set long time value' do
       subject {
-        described_class.create('Container' => container.id, 'Cmd' => %w[date])
+        described_class.create(
+          'Container' => container.id,
+          'AttachStdout' => true,
+          'Cmd' => %w[true]
+        )
       }
       after { container.kill!.remove }
 

data/spec/docker/image_spec.rb

@@ -269,6 +269,28 @@ describe Docker::Image do
     end
   end
 
+  describe '#save_stream' do
+    let(:image) { Docker::Image.get('busybox') }
+    let(:block) { proc { |chunk| puts chunk } }
+
+    it 'calls the class method' do
+      expect(Docker::Image).to receive(:save_stream)
+        .with(image.id, instance_of(Hash), instance_of(Docker::Connection))
+      image.save_stream(:chunk_size => 1024 * 1024, &block)
+    end
+  end
+
+  describe '#load' do
+    include_context "local paths"
+    let(:file) { File.join(project_dir, 'spec', 'fixtures', 'load.tar') }
+    context 'test image upload' do
+      it 'load tianon/true image' do
+        result = Docker::Image.load(file)
+        expect(result).to eq("")
+      end
+    end
+  end
+
   describe '#refresh!' do
     let(:image) { Docker::Image.create('fromImage' => 'debian:wheezy') }
 
@@ -311,7 +333,7 @@ describe Docker::Image do
       it 'sets the id and sends Docker.creds' do
         allow(Docker).to receive(:creds).and_return(creds)
         expect(image).to be_a Docker::Image
-        expect(image.id).to match(/\A[a-fA-F0-9]+\Z/)
+        expect(image.id).to match(/\A(sha256:)?[a-fA-F0-9]+\Z/)
         expect(image.id).to_not include('base')
         expect(image.id).to_not be_nil
         expect(image.id).to_not be_empty
@@ -387,6 +409,30 @@ describe Docker::Image do
     end
   end
 
+  describe '.save_stream' do
+    let(:image) { 'busybox:latest' }
+    let(:non_streamed) do
+      Docker.connection.get(
+        '/images/get',
+        'names' => URI.encode(image)
+      )
+    end
+    let(:streamed) { '' }
+    let(:tar_files) do
+      proc do |string|
+        Gem::Package::TarReader
+          .new(StringIO.new(string, 'rb'))
+          .map(&:full_name)
+          .sort
+      end
+    end
+
+    it 'yields each chunk of the image' do
+      Docker::Image.save_stream(image) { |chunk| streamed << chunk }
+      expect(tar_files.call(streamed)).to eq(tar_files.call(non_streamed))
+    end
+  end
+
   describe '.exist?' do
     subject { described_class }
     let(:exists) { subject.exist?(image_name) }

data/spec/docker/volume_spec.rb

@@ -1,5 +1,7 @@
 require 'spec_helper'
 
+# Volume requests are actually slow enough to occasionally not work
+# Use sleep statements to manage that
 describe Docker::Volume, :docker_1_9 do
   let(:name) { "ArbitraryNameForTheRakeTestVolume" }
 
@@ -16,7 +18,7 @@ describe Docker::Volume, :docker_1_9 do
   describe '.get' do
     let(:volume) { Docker::Volume.get(name) }
 
-    before { Docker::Volume.create(name) }
+    before { Docker::Volume.create(name); sleep 1 }
     after { volume.remove }
 
     it 'gets volume details' do
@@ -29,13 +31,14 @@ describe Docker::Volume, :docker_1_9 do
     after { Docker::Volume.get(name).remove }
 
     it 'gets a list of volumes' do
-      expect { Docker::Volume.create(name) }.to change { Docker::Volume.all.length }.by(1)
+      expect { Docker::Volume.create(name); sleep 1 }.to change { Docker::Volume.all.length }.by(1)
     end
   end
 
   describe '#remove' do
     it 'removes a volume' do
       volume = Docker::Volume.create(name)
+      sleep 1
       expect { volume.remove }.to change { Docker::Volume.all.length }.by(-1)
     end
   end

data/spec/docker_spec.rb

@@ -183,6 +183,16 @@ describe Docker do
     end
   end
 
+  describe '#ping' do
+    before { Docker.reset! }
+
+    let(:ping) { subject.ping}
+
+    it 'returns the status as a String' do
+      expect(ping).to eq('OK')
+    end
+  end
+
   describe '#authenticate!' do
     subject { described_class }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: docker-api
 version: !ruby/object:Gem::Version
-  version: 1.26.2
+  version: 1.27.0
 platform: ruby
 authors:
 - Swipely, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-24 00:00:00.000000000 Z
+date: 2016-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: excon
@@ -188,7 +188,9 @@ files:
 - lib/docker/version.rb
 - lib/docker/volume.rb
 - lib/excon/middlewares/hijack.rb
-- script/install_dependencies.sh
+- script/docker
+- script/docker.conf
+- script/install_docker.sh
 - spec/docker/connection_spec.rb
 - spec/docker/container_spec.rb
 - spec/docker/event_spec.rb
@@ -202,6 +204,7 @@ files:
 - spec/docker_spec.rb
 - spec/fixtures/build_from_dir/Dockerfile
 - spec/fixtures/export.tar
+- spec/fixtures/load.tar
 - spec/fixtures/top/Dockerfile
 - spec/spec_helper.rb
 homepage: https://github.com/swipely/docker-api
@@ -242,6 +245,7 @@ test_files:
 - spec/docker_spec.rb
 - spec/fixtures/build_from_dir/Dockerfile
 - spec/fixtures/export.tar
+- spec/fixtures/load.tar
 - spec/fixtures/top/Dockerfile
 - spec/spec_helper.rb
 has_rdoc: 

data/script/install_dependencies.sh

@@ -1,23 +0,0 @@
-#!/bin/bash
-set -e
-
-# Update bundler
-gem install bundler
-
-# Install docker
-sudo mkdir -p /opt/docker
-sudo curl -fo /opt/docker/docker "https://get.docker.com/builds/Linux/x86_64/docker-${DOCKER_VERSION}"
-sudo chmod +x /opt/docker/docker
-
-running=0
-for x in {1..3}
-do
-    [[ $running != 1 ]] || break
-    sudo rm -rf /var/run/docker.pid
-    sudo /opt/docker/docker -d -D &
-    DOCKER_PID=$!
-    sleep 5
-    echo "Checking if docker is running"
-    ps -p $DOCKER_PID && running=1 || echo "Couldn't start docker, retrying"
-done
-echo "Docker running, continuing"