docker-api 1.6.0 → 1.7.0

checksums.yaml

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

data/.cane

@@ -1 +0,0 @@
---abc-max 13

data/README.md

@@ -219,22 +219,21 @@ ff02::1         ip6-allnodes
 ff02::2         ip6-allrouters
 # => Docker::Container { :id => a1759f3e2873, :connection => Docker::Connection { :url => http://localhost, :options => {:port=>4243} } }
 
-
-
 # Wait for the current command to finish executing. If an argument is given,
 # will timeout after that number of seconds. The default is one minute.
 container.wait(15)
 # => {'StatusCode'=>0}
 
 # Attach to the Container. Currently, the below options are the only valid ones.
-# By default, :stream and :stdout are set.
+# By default, :stream, :stdout, and :stderr are set.
 container.attach(:stream => true, :stdout => true, :stderr => true, :logs => true)
-# => "bin\nboot\ndev\netc\nhome\nlib\nlib64\nmedia\nmnt\nopt\nproc\nroot\nrun\nsbin\nselinux\nsrv\nsys\ntmp\nusr\nvar"
+# => [["bin\nboot\ndev\netc\nhome\nlib\nlib64\nmedia\nmnt\nopt\nproc\nroot\nrun\nsbin\nselinux\nsrv\nsys\ntmp\nusr\nvar", []]
 
 # If you wish to stream the attach method, a block may be supplied.
-container = Docker::Container.create('Image' => 'base', 'Cmd' => %[find / -name *])
-container.tap(&:start).attach { |chunk| puts chunk }
-# => nil
+container = Docker::Container.create('Image' => 'base', 'Cmd' => ['find / -name *'])
+container.tap(&:start).attach { |stream, chunk| puts "#{stream}: #{chunk}" }
+stderr: 2013/10/30 17:16:24 Unable to locate find / -name *
+# => [[], ["2013/10/30 17:16:24 Unable to locate find / -name *\n"]]
 
 # Create an Image from a Container's changes.
 container.commit

data/docker-api.gemspec

@@ -3,7 +3,7 @@ require File.expand_path('../lib/docker/version', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.authors       = ["Swipely, Inc."]
-  gem.email         = %w{tomhulihan@swipely.com bright@swipely.com}
+  gem.email         = %w{tomhulihan@swipely.com bright@swipely.com toddlunter@swipely.com}
   gem.description   = %q{A simple REST client for the Docker Remote API}
   gem.summary       = %q{A simple REST client for the Docker Remote API}
   gem.homepage      = 'https://github.com/swipely/docker-api'
@@ -14,14 +14,13 @@ Gem::Specification.new do |gem|
   gem.name          = "docker-api"
   gem.require_paths = %w{lib}
   gem.version       = Docker::VERSION
-  gem.add_dependency 'excon', '>= 0.27.3'
+  gem.add_dependency 'excon', '>= 0.28'
   gem.add_dependency 'json'
   gem.add_dependency 'archive-tar-minitar'
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'cane'
   gem.add_development_dependency 'pry'
-  gem.add_development_dependency 'webmock', '>= 1.11.0'
-  gem.add_development_dependency 'vcr', '>= 2.4.0'
+  gem.add_development_dependency 'vcr', '>= 2.7.0'
   gem.add_development_dependency 'simplecov'
 end

data/lib/docker.rb

@@ -2,13 +2,14 @@ require 'cgi'
 require 'json'
 require 'excon'
 require 'tempfile'
+require 'base64'
 require 'rubygems/package'
 require 'archive/tar/minitar'
 
 # The top-level module for this gem. It's purpose is to hold global
 # configuration variables that are used as defaults in other classes.
 module Docker
-  attr_reader :creds
+  attr_accessor :creds
 
   def default_socket_url
     'unix:///var/run/docker.sock'
@@ -56,9 +57,12 @@ module Docker
 
   # Login to the Docker registry.
   def authenticate!(options = {})
-    @creds = options.to_json
-    connection.post(:path => '/auth', :body => @creds)
+    creds = options.to_json
+    connection.post('/auth', {}, :body => creds)
+    @creds = creds
     true
+  rescue Docker::Error::ServerError, Docker::Error::UnauthorizedError
+    raise Docker::Error::AuthenticationError
   end
 
   # When the correct version of Docker is installed, returns true. Otherwise,
@@ -71,8 +75,8 @@ module Docker
   end
 
   module_function :default_socket_url, :env_url, :url, :url=, :options,
-                  :options=, :connection, :reset_connection!, :version,
-                  :info, :authenticate!, :validate_version!
+                  :options=, :creds, :creds=, :connection, :reset_connection!,
+                  :version, :info, :authenticate!, :validate_version!
 end
 
 require 'docker/version'
@@ -81,3 +85,4 @@ require 'docker/util'
 require 'docker/connection'
 require 'docker/container'
 require 'docker/image'
+require 'docker/event'

data/lib/docker/connection.rb

@@ -36,6 +36,8 @@ class Docker::Connection
     resource.request(compile_request_params(*args, &block)).body
   rescue Excon::Errors::BadRequest => ex
     raise ClientError, ex.message
+  rescue Excon::Errors::Unauthorized => ex
+    raise UnauthorizedError, ex.message
   rescue Excon::Errors::InternalServerError => ex
     raise ServerError, ex.message
   rescue Excon::Errors::Timeout => ex

data/lib/docker/container.rb

@@ -50,14 +50,31 @@ class Docker::Container
 
   # Attach to a container's standard streams / logs.
   def attach(options = {}, &block)
-    opts = { :stream => true, :stdout => true }.merge(options)
-    connection.post(path_for(:attach), opts, :response_block => block)
+    opts = {
+      :stream => true, :stdout => true, :stderr => true
+    }.merge(options)
+    # Creates list to store stdout and stderr messages
+    msgs = [[],[]]
+    connection.post(
+      path_for(:attach),
+      opts,
+      :response_block => attach_for(block, msgs)
+    )
+    msgs
   end
 
   # Create an Image from a Container's change.s
   def commit(options = {})
     options.merge!('container' => self.id[0..7])
-    hash = Docker::Util.parse_json(connection.post('/commit', options))
+    # [code](https://github.com/dotcloud/docker/blob/v0.6.3/commands.go#L1115)
+    # Based on the link, the config passed as run, needs to be passed as the
+    # body of the post so capture it, remove from the options, and pass it via
+    # the post body
+    config = options.delete('run')
+    hash = Docker::Util.parse_json(connection.post('/commit',
+                                                   options,
+                                                   :body => config.to_json)
+                                  )
     Docker::Image.send(:new, self.connection, hash['Id'])
   end
 
@@ -124,6 +141,24 @@ class Docker::Container
     "/containers/#{self.id}/#{resource}"
   end
 
-  private :path_for
+  # Method that takes chunks and calls the attached block for each mux'd message
+  def attach_for(block, msg_stack)
+    lambda do |c,r,t|
+      stdout_msgs, stderr_msgs = Docker::Util.decipher_messages(c)
+      msg_stack[0] += stdout_msgs
+      msg_stack[1] += stderr_msgs
+
+      unless block.nil?
+        stdout_msgs.each do |msg|
+          block.call(:stdout, msg)
+        end
+        stderr_msgs.each do |msg|
+          block.call(:stderr, msg)
+        end
+      end
+    end
+  end
+
+  private :path_for, :attach_for
   private_class_method :new
 end

data/lib/docker/error.rb

@@ -11,6 +11,9 @@ module Docker::Error
   # Raised when a request returns a 400.
   class ClientError < DockerError; end
 
+  # Raised when a request returns a 401.
+  class UnauthorizedError < DockerError; end
+
   # Raised when a request returns a 500.
   class ServerError < DockerError; end
 
@@ -22,4 +25,7 @@ module Docker::Error
 
   # Raised when a request times out.
   class TimeoutError < DockerError; end
+
+  # Raised when login fails.
+  class AuthenticationError < DockerError; end
 end

data/lib/docker/event.rb

@@ -0,0 +1,40 @@
+# This class represents a Docker Image.
+class Docker::Event
+  include Docker::Error
+
+  attr_accessor :status, :id, :from, :time
+
+  def initialize(status, id, from, time)
+    @status, @id, @from, @time = status, id, from, time
+  end
+
+  def to_s
+    "Docker::Event { :status => #{self.status}, :id => #{self.id}, "\
+      ":from => #{self.from}, :time => #{self.time} }"
+  end
+
+  class << self
+    include Docker::Error
+
+    def stream(opts = {}, conn = Docker.connection, &block)
+      conn.get('/events', opts, :response_block => lambda { |b, r, t|
+        block.call(new_event(b, r, t))
+      })
+    end
+
+    def since(since, opts = {}, conn = Docker.connection, &block)
+      stream(opts.merge(:since => since), conn, &block)
+    end
+
+    def new_event(body, remaining, total)
+      return if body.nil? || body.empty?
+      json = Docker::Util.parse_json(body)
+      Docker::Event.new(
+        json['status'],
+        json['id'],
+        json['from'],
+        json['time']
+      )
+    end
+  end
+end

data/lib/docker/image.rb

@@ -15,16 +15,32 @@ class Docker::Image
 
   # Given a command and optional list of streams to attach to, run a command on
   # an Image. This will not modify the Image, but rather create a new Container
-  # to run the Image.
-  def run(cmd)
-    cmd = cmd.split(/\s+/) if cmd.is_a?(String)
-    Docker::Container.create({ 'Image' => self.id, 'Cmd' => cmd }, connection)
-                     .tap(&:start!)
+  # to run the Image. If the image has an embedded config, no command is
+  # necessary, but it will fail with 500 if no config is saved with the image
+  def run(cmd=nil)
+    opts = { 'Image' => self.id }
+    opts["Cmd"] = cmd.split(/\s+/) if cmd.is_a?(String)
+    begin
+      Docker::Container.create(opts, connection)
+                       .tap(&:start!)
+    rescue ServerError
+      if cmd
+        raise ServerError, "Docker Server Error."
+      else
+        raise ServerError, "No command specified."
+      end
+    end
   end
 
   # Push the Image to the Docker registry.
-  def push(options = {})
-    connection.post(path_for(:push), options, :body => Docker.creds)
+  def push(creds = nil, options = {})
+    credentials = (creds.nil?) ? Docker.creds : creds.to_json
+    headers = Docker::Util.build_auth_header(credentials)
+    connection.post(
+      path_for(:push),
+      options,
+      :headers => headers
+    )
     self
   end
 
@@ -83,8 +99,14 @@ class Docker::Image
     include Docker::Error
 
     # Create a new Image.
-    def create(opts = {}, conn = Docker.connection)
-      instance = new(conn)
+    def create(opts = {}, creds = nil, conn = Docker.connection)
+      credentials = (creds.nil?) ? creds.to_json : Docker.creds
+      headers = if credentials.nil?
+        Docker::Util.build_auth_header(credentials)
+      else
+        {}
+      end
+      instance = new(conn, {}, :headers => headers)
       conn.post('/images/create', opts)
       id = opts['repo'] ? "#{opts['repo']}/#{opts['tag']}" : opts['fromImage']
       if (instance.id = id).nil?
@@ -122,19 +144,21 @@ class Docker::Image
     end
 
     # Given a Dockerfile as a string, builds an Image.
-    def build(commands, connection = Docker.connection)
+    def build(commands, opts = {}, connection = Docker.connection)
       body = connection.post(
-        '/build', {},
+        '/build', opts,
         :body => Docker::Util.create_tar('Dockerfile' => commands)
       )
       new(connection, Docker::Util.extract_id(body))
+    rescue Docker::Error::ServerError
+      raise Docker::Error::UnexpectedResponseError
     end
 
     # Given a directory that contains a Dockerfile, builds an Image.
-    def build_from_dir(dir, connection = Docker.connection)
+    def build_from_dir(dir, opts = {}, connection = Docker.connection)
       tar = Docker::Util.create_dir_tar(dir)
       body = connection.post(
-        '/build', {},
+        '/build', opts,
         :headers => { 'Content-Type'      => 'application/tar',
                       'Transfer-Encoding' => 'chunked' }
       ) { tar.read(Excon.defaults[:chunk_size]).to_s }

data/lib/docker/util.rb

@@ -18,7 +18,7 @@ module Docker::Util
         tar.add_file(file_name, 0640) { |tar_file| tar_file.write(input) }
       end
     end
-    output.tap(&:rewind)
+    output.tap(&:rewind).string
   end
 
   def create_dir_tar(directory)
@@ -57,4 +57,28 @@ module Docker::Util
 
     file_hash
   end
+
+  def build_auth_header(credentials)
+    credentials = credentials.to_json if credentials.is_a?(Hash)
+    { 'X-Registry-Auth' => Base64.encode64(credentials).gsub(/\n/, '') }
+  end
+
+  # Method to break apart application/vnd.docker.raw-stream headers
+  def decipher_messages(body)
+    raw_text = body.dup
+    stdout_messages = []
+    stderr_messages = []
+    while !raw_text.empty?
+      header = raw_text.slice!(0,8)
+      next if header.nil?
+      length = header[4..7].chars
+        .map { |c| c.getbyte(0) }
+        .inject(0) { |total, curr| (total << 8) + curr }
+      message = raw_text.slice!(0,length)
+      stdout_messages << message if header.getbyte(0) == 1
+      stderr_messages << message if header.getbyte(0) == 2
+    end
+
+    [stdout_messages, stderr_messages]
+  end
 end

data/lib/docker/version.rb

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

data/spec/docker/container_spec.rb

@@ -58,16 +58,14 @@ describe Docker::Container do
   end
 
   describe '#top' do
-    subject {
-      described_class.create(
-        'Cmd' => %w[while true; do; done;],
-        'Image' => 'base'
-      )
+    let(:dir) {
+      File.join(File.dirname(__FILE__), '..', 'fixtures', 'top')
     }
-    let(:top) { subject.top }
+    let(:image) { Docker::Image.build_from_dir(dir) }
+    let(:top) { sleep 1; container.top }
+    let!(:container) { image.run('/while') }
 
-    before { subject.start }
-    after { subject.kill }
+    after { container.kill; image.remove }
 
     it 'returns the top commands as an Array', :vcr do
       top.should be_a Array
@@ -80,7 +78,7 @@ describe Docker::Container do
     subject {
       Docker::Image.create(
         'fromImage' => 'base'
-      ).run('touch /test').tap { |c| c.start.wait }
+      ).run('touch /test').tap { |c| c.wait }
     }
 
     context 'when the file does not exist' do
@@ -120,8 +118,7 @@ describe Docker::Container do
     it 'yields each chunk', :vcr do
       first = nil
       subject.export do |chunk|
-        first = chunk
-        break
+        first ||= chunk
       end
       first[257..261].should == "ustar" # Make sure the export is a tar.
     end
@@ -133,10 +130,11 @@ describe Docker::Container do
     before { subject.start }
 
     it 'yields each chunk', :vcr do
-      subject.attach { |chunk|
-        chunk.should == "/\n"
-        break
-      }
+      chunk = nil
+      subject.attach do |stream, c|
+        chunk ||= c
+      end
+      expect(chunk).to eq("/\n")
     end
   end
 
@@ -277,6 +275,14 @@ describe Docker::Container do
       image.should be_a Docker::Image
       image.id.should_not be_nil
     end
+
+    context 'if run is passed, it saves the command in the image', :vcr do
+      let(:image) { subject.commit('run' => {"Cmd" => %w[pwd]}) }
+      it 'saves the command' do
+        expect(image.run.attach).to eql [["/\n"],[]]
+      end
+    end
+
   end
 
   describe '.create' do
@@ -284,8 +290,14 @@ describe Docker::Container do
 
     context 'when the Container does not yet exist' do
       context 'when the HTTP request does not return a 200' do
-        before { Excon.stub({ :method => :post }, { :status => 400 }) }
-        after { Excon.stubs.shift }
+        before do
+          Docker.options = { :mock => true }
+          Excon.stub({ :method => :post }, { :status => 400 })
+        end
+        after do
+          Excon.stubs.shift
+          Docker.options = {}
+        end
 
         it 'raises an error' do
           expect { subject.create }.to raise_error(Docker::Error::ClientError)
@@ -329,8 +341,14 @@ describe Docker::Container do
     subject { described_class }
 
     context 'when the HTTP response is not a 200' do
-      before { Excon.stub({ :method => :get }, { :status => 500 }) }
-      after { Excon.stubs.shift }
+      before do
+        Docker.options = { :mock => true }
+        Excon.stub({ :method => :get }, { :status => 500 })
+      end
+      after do
+        Excon.stubs.shift
+        Docker.options = {}
+      end
 
       it 'raises an error' do
         expect { subject.all }