docker-api 1.5.4 → 1.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 73fb37b59d2a47b3db7d9c8a380f6e62ebdff7eb
+  data.tar.gz: eb221917606fb54355f075be67c508597749c67e
+SHA512:
+  metadata.gz: 089db48c5b0bf31aab2d7a2136ea0a26818a93faa41e27ec1e838037cdf94eb7873b1b099a6cfd6a6f942de7c2bddf356e412a6417a1c66f3a0defebe2c6c9e1
+  data.tar.gz: e6aa7b45e53e29e09130bf3f39722b5ec8eb8c537e6a01244aaf0411c65b729d38ee4603f7e7be28cb4b665feda025cf1f73e49e9e4b5b3f2be8b7a03585891b

data/README.md

@@ -2,7 +2,7 @@ docker-api
 ==========
 [![Gem Version](https://badge.fury.io/rb/docker-api.png)](http://badge.fury.io/rb/docker-api) [![travis-ci](https://travis-ci.org/swipely/docker-api.png?branch=master)](https://travis-ci.org/swipely/docker-api) [![Code Climate](https://codeclimate.com/github/swipely/docker-api.png)](https://codeclimate.com/github/swipely/docker-api) [![Dependency Status](https://gemnasium.com/swipely/docker-api.png)](https://gemnasium.com/swipely/docker-api)
 
-This gem provides an object-oriented interface to the [Docker Remote API](http://docs.docker.io/en/latest/api/docker_remote_api_v1.4/). Every method listed there is implemented, with the exception of attaching to the STDIN of a Container. At the time of this writing, docker-api is meant to interface with Docker version 0.5.*.
+This gem provides an object-oriented interface to the [Docker Remote API](http://docs.docker.io/en/latest/api/docker_remote_api_v1.4/). Every method listed there is implemented, with the exception of attaching to the STDIN of a Container. At the time of this writing, docker-api is meant to interface with Docker version 0.6.*.
 
 Installation
 ------------
@@ -42,25 +42,34 @@ $ sudo docker -d
 
 This will daemonize Docker so that it can be used for the remote API calls.
 
-If you're running Docker locally, there is no setup to do in Ruby. If you're not, you'll have to point the gem to your server. For example:
+If you're running Docker locally as a socket, there is no setup to do in Ruby. If you're not or change the path of the socket, you'll have to point the gem to your socket or local/remote port. For example:
 
 ```ruby
-Docker.url = 'http://example.com'
-Docker.options = { :port => 5422 }
+Docker.url = 'http://example.com:5422'
 ```
 
-Two things to note here. The first is that this gem uses [excon](http://www.github.com/geemus/excon), so any of the options that are valid for `Excon.new` are alse valid for `Docker.options`. Second, by default Docker runs on port 4243. The gem will assume you want to connnect to port 4243 unless you specify otherwise.
+Two things to note here. The first is that this gem uses [excon](http://www.github.com/geemus/excon), so any of the options that are valid for `Excon.new` are alse valid for `Docker.options`. Second, by default Docker runs on a socket. The gem will assume you want to connnect to the socket unless you specify otherwise.
 
 Also, you may set the above variables via `ENV` variables. For example:
 
 ```shell
-$ DOCKER_HOST=example.com DOCKER_PORT=1000 irb
+$ DOCKER_URL=unix:///var/docker.sock irb
 irb(main):001:0> require 'docker'
 => true
 irb(main):002:0> Docker.url
-=> http://example.com
+=> "unix:///var/docker.sock"
 irb(main):003:0> Docker.options
-=> {:port=>1000}
+=> {}
+```
+
+```shell
+$ DOCKER_URL=http://example.com:1000 irb
+irb(main):001:0> require 'docker'
+=> true
+irb(main):003:0> Docker.url
+=> "http://example.com:1000"
+irb(main):004:0> Docker.options
+=> {}
 ```
 
 Before doing anything else, ensure you have the correct version of the Docker API. To do this, run `Docker.validate_version!`. If your installed version is not supported, a `Docker::Error::VersionError` is raised.
@@ -91,7 +100,7 @@ require 'docker'
 # => true
 
 # Create an Image.
-Docker::Image.create('fromRepo' => 'base')
+Docker::Image.create('fromImage' => 'base')
 # => Docker::Image { :id => ae7ffbcd1, :connection => Docker::Connection { :url => http://localhost, :options => {:port=>4243} } }
 
 # Insert a file into an Image from a url.
@@ -252,7 +261,7 @@ By default, each object connects to the connection specified by `Docker.connecti
 ```ruby
 require 'docker'
 
-Docker::Container.all({}, Docker::Connection.new(:url => 'http://example.com'))
+Docker::Container.all({}, Docker::Connection.new('http://example.com:4243', {}))
 ```
 
 ## Known Issues

data/docker-api.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |gem|
   gem.name          = "docker-api"
   gem.require_paths = %w{lib}
   gem.version       = Docker::VERSION
-  gem.add_dependency 'excon', '>= 0.22.0'
+  gem.add_dependency 'excon', '>= 0.27.3'
   gem.add_dependency 'json'
   gem.add_dependency 'archive-tar-minitar'
   gem.add_development_dependency 'rake'

data/lib/docker.rb

@@ -10,13 +10,20 @@ require 'archive/tar/minitar'
 module Docker
   attr_reader :creds
 
+  def default_socket_url
+    'unix:///var/run/docker.sock'
+  end
+
+  def env_url
+    ENV['DOCKER_URL']
+  end
+
   def url
-    @url ||= "http://#{ENV['DOCKER_HOST'] || 'localhost'}"
+    @url ||= ENV['DOCKER_URL'] || default_socket_url
   end
 
   def options
-    port = (ENV['DOCKER_PORT'].nil? ? 4243 : ENV['DOCKER_PORT']).to_i
-    @options ||= { :port => port.to_i }
+    @options ||= {}
   end
 
   def url=(new_url)
@@ -25,7 +32,7 @@ module Docker
   end
 
   def options=(new_options)
-    @options = { :port => 4243 }.merge(new_options)
+    @options = new_options
     reset_connection!
   end
 
@@ -63,9 +70,9 @@ module Docker
     raise Docker::Error::VersionError, "Expected API Version: #{API_VERSION}"
   end
 
-  module_function :url, :url=, :options, :options=, :connection,
-                  :reset_connection!, :version, :info, :authenticate!,
-                  :validate_version!
+  module_function :default_socket_url, :env_url, :url, :url=, :options,
+                  :options=, :connection, :reset_connection!, :version,
+                  :info, :authenticate!, :validate_version!
 end
 
 require 'docker/version'

data/lib/docker/connection.rb

@@ -15,7 +15,12 @@ class Docker::Connection
     when !opts.is_a?(Hash)
       raise ArgumentError, "Expected a Hash, got: '#{opts}'"
     else
-      @url, @options = url, opts
+      uri = URI.parse(url)
+      if uri.scheme == "unix"
+        @url, @options = 'unix:///', {:socket => uri.path}.merge(opts)
+      else
+        @url, @options = url, opts
+      end
     end
   end
 

data/lib/docker/image.rb

@@ -2,12 +2,12 @@
 class Docker::Image
   include Docker::Error
 
-  attr_accessor :id, :connection
+  attr_accessor :id, :connection, :info
 
   # The private new method accepts a connection and optional id.
-  def initialize(connection, id = nil)
+  def initialize(connection, id = nil, info = {})
     if connection.is_a?(Docker::Connection)
-      @connection, @id = connection, id
+      @connection, @id, @info = connection, id, info
     else
       raise ArgumentError, "Expected a Docker::Connection, got: #{connection}."
     end
@@ -67,7 +67,8 @@ class Docker::Image
 
   # Return a String representation of the Image.
   def to_s
-    "Docker::Image { :id => #{self.id}, :connection => #{self.connection} }"
+    "Docker::Image { :id => #{self.id}, :info => #{self.info.inspect}, "\
+      ":connection => #{self.connection} }"
   end
 
   # #json returns extra information about an Image, #history returns its
@@ -96,7 +97,7 @@ class Docker::Image
     # Return every Image.
     def all(opts = {}, conn = Docker.connection)
       hashes = Docker::Util.parse_json(conn.get('/images/json', opts)) || []
-      hashes.map { |hash| new(conn, hash['Id']) }
+      hashes.map { |hash| new(conn, hash['Id'], hash.tap{|h| h.delete('Id')}) }
     end
 
     # Given a query like `{ :term => 'sshd' }`, queries the Docker Registry for

data/lib/docker/version.rb

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

data/spec/docker/connection_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
 describe Docker::Connection do
-  subject { described_class.new('http://localhost', :port => 4243) }
+  subject { described_class.new('http://localhost:4243', {}) }
 
   describe '#initialize' do
-    let(:url) { 'http://localhost' }
-    let(:options) { { :port => 4243 } }
+    let(:url) { 'http://localhost:4243' }
+    let(:options) { {} }
     subject { described_class.new(url, options) }
 
     context 'when the first argument is not a String' do
@@ -17,6 +17,15 @@ describe Docker::Connection do
     end
 
     context 'when the first argument is a String' do
+      context 'and the url is a unix socket' do
+        let(:url) { 'unix:///var/run/docker.sock' }
+
+        it 'sets the socket path in the options' do
+          expect(subject.url).to eq('unix:///')
+          expect(subject.options).to include(:socket => '/var/run/docker.sock')
+        end
+      end
+
       context 'but the second argument is not a Hash' do
         let(:options) { :lol_not_a_hash }
 
@@ -80,9 +89,8 @@ describe Docker::Connection do
   end
 
   describe '#to_s' do
-    let(:url) { 'google.com' }
-    let(:port) { 4000 }
-    let(:options) { { :port => port } }
+    let(:url) { 'http://google.com:4000' }
+    let(:options) { {} }
     let(:expected_string) {
       "Docker::Connection { :url => #{url}, :options => #{options} }"
     }

data/spec/docker/container_spec.rb

@@ -40,17 +40,34 @@ describe Docker::Container do
     before { subject.tap(&:start).tap(&:wait) }
 
     it 'returns the changes as an array', :vcr do
-      changes.should == [{'Path' => '/root', 'Kind' => 2}]
+      changes.should == [
+        {
+          "Path" => "/root",
+          "Kind" => 2
+        },
+        {
+          "Path" => "/dev",
+          "Kind" => 0
+        },
+        {
+          "Path" => "/dev/kmsg",
+          "Kind" => 1
+        }
+      ]
     end
   end
 
   describe '#top' do
     subject {
-      described_class.create('Cmd' => %w[find / -name '*'], 'Image' => 'base')
+      described_class.create(
+        'Cmd' => %w[while true; do; done;],
+        'Image' => 'base'
+      )
     }
     let(:top) { subject.top }
 
     before { subject.start }
+    after { subject.kill }
 
     it 'returns the top commands as an Array', :vcr do
       top.should be_a Array
@@ -60,7 +77,11 @@ describe Docker::Container do
   end
 
   describe '#copy' do
-    subject { Docker::Image.create('fromImage' => 'base').run('ls') }
+    subject {
+      Docker::Image.create(
+        'fromImage' => 'base'
+      ).run('touch /test').tap { |c| c.start.wait }
+    }
 
     context 'when the file does not exist' do
       it 'raises an error', :vcr do
@@ -72,8 +93,9 @@ describe Docker::Container do
     context 'when the input is a file' do
       it 'yields each chunk of the tarred file', :vcr do
         chunks = []
-        subject.copy('/etc/hosts') { |chunk| chunks << chunk }
-        chunks.join("\n").should include('localhost')
+        subject.copy('/test') { |chunk| chunks << chunk }
+        chunks = chunks.join("\n")
+        expect(chunks).to be_include('test')
       end
     end
 
@@ -173,9 +195,6 @@ describe Docker::Container do
       described_class.all.map(&:id).should be_none { |id|
         id.start_with?(subject.id)
       }
-      described_class.all(:all => true).map(&:id).should be_any { |id|
-        id.start_with?(subject.id)
-      }
     end
   end
 

data/spec/docker/image_spec.rb

@@ -6,13 +6,22 @@ describe Docker::Image do
 
     let(:id) { 'bf119e2' }
     let(:connection) { Docker.connection }
+
+    let(:info) do
+      {"Repository" => "base", "Tag" => "latest",
+        "Created" => 1364102658, "Size" => 24653, "VirtualSize" => 180116135}
+    end
+
     let(:expected_string) do
-      "Docker::Image { :id => #{id}, :connection => #{connection} }"
+      "Docker::Image { :id => #{id}, :info => #{info.inspect}, "\
+        ":connection => #{connection} }"
     end
+
     before do
       {
         :@id => id,
-        :@connection => connection
+        :@connection => connection,
+        :@info => info
       }.each { |k, v| subject.instance_variable_set(k, v) }
     end
 
@@ -184,9 +193,18 @@ describe Docker::Image do
     before { subject.create('fromImage' => 'base') }
 
     it 'materializes each Image into a Docker::Image', :vcr do
-      images.should be_all { |image|
-        !image.id.nil? && image.is_a?(described_class)
-      }
+      images.each do |image|
+        image.should_not be_nil
+
+        image.should be_a(described_class)
+
+        image.id.should_not be_nil
+
+        %w(Created Size VirtualSize).each do |key|
+          image.info.should have_key(key)
+        end
+      end
+
       images.length.should_not be_zero
     end
   end

data/spec/docker_spec.rb

@@ -4,39 +4,31 @@ describe Docker do
   subject { Docker }
 
   before do
-    ENV['DOCKER_HOST'] = nil
-    ENV['DOCKER_PORT'] = nil
+    ENV['DOCKER_URL'] = nil
   end
 
   it { should be_a Module }
-  its(:options) { should == { :port => 4243 } }
-  its(:url) { should == 'http://localhost' }
-  its(:connection) { should be_a Docker::Connection }
-
-  context 'when the DOCKER_HOST ENV variable is set' do
-    let(:host) { 'google.com' }
-    let(:url) { "http://#{host}" }
 
+  context 'default url and connection' do
     before do
-      Docker.instance_variable_set(:@url, nil)
-      ENV['DOCKER_HOST'] = host
+      Docker.url = nil
+      Docker.options = nil
     end
 
-    it 'sets Docker.url to that variable' do
-      subject.url.should == url
+    context "when the DOCKER_* ENV variables aren't set" do
+      its(:options) { {} }
+      its(:url) { should == 'unix:///var/run/docker.sock' }
+      its(:connection) { should be_a Docker::Connection }
     end
-  end
 
-  context 'when the DOCKER_PORT ENV variable is set' do
-    let(:port) { 1234 }
-
-    before do
-      Docker.instance_variable_set(:@options, nil)
-      ENV['DOCKER_PORT'] = port.to_s
-    end
+    context "when the DOCKER_* ENV variables are set" do
+      before do
+        ENV['DOCKER_URL'] = 'unixs:///var/run/not-docker.sock'
+      end
 
-    it 'sets Docker.options[:port] to that variable' do
-      subject.options[:port].should == port
+      its(:options) { {} }
+      its(:url) { should == 'unixs:///var/run/not-docker.sock' }
+      its(:connection) { should be_a Docker::Connection }
     end
   end
 
@@ -52,8 +44,8 @@ describe Docker do
   [:options=, :url=].each do |method|
     describe "##{method}" do
       after(:all) do
-        subject.options = { :port => 4243 }
-        subject.url = 'http://localhost'
+        subject.instance_variable_set(:@url, nil)
+        subject.instance_variable_set(:@options, nil)
       end
       it 'calls #reset_connection!' do
         subject.should_receive(:reset_connection!)
@@ -63,18 +55,29 @@ describe Docker do
   end
 
   describe '#version' do
+    before do
+      subject.url = nil
+      subject.options = nil
+    end
+
     let(:version) { subject.version }
     it 'returns the version as a Hash', :vcr do
       version.should be_a Hash
-      version.keys.sort.should == %w[GoVersion Version]
+      version.keys.sort.should == %w[GitCommit GoVersion Version]
     end
   end
 
   describe '#info' do
+    before do
+      subject.url = nil
+      subject.options = nil
+    end
+
     let(:info) { subject.info }
     let(:keys) do
-      %w(Containers Debug Images KernelVersion LXCVersion MemoryLimit
-         NEventsListener NFd NGoroutines)
+      %w(Containers Debug IPv4Forwarding Images IndexServerAddress
+         KernelVersion LXCVersion MemoryLimit NEventsListener NFd
+         NGoroutines)
     end
 
     it 'returns the info as a Hash', :vcr do
@@ -90,6 +93,11 @@ describe Docker do
   end
 
   describe '#validate_version' do
+    before do
+      subject.url = nil
+      subject.options = nil
+    end
+
     context 'when a Docker Error is raised' do
       before { Docker.stub(:info).and_raise(Docker::Error::ClientError) }