docker-api 1.27.0 → 2.0.0

data/lib/docker/event.rb

@@ -2,15 +2,26 @@
 class Docker::Event
   include Docker::Error
 
-  attr_accessor :status, :id, :from, :time
+  # Represents the actor object nested within an event
+  class Actor
+    attr_accessor :ID, :Attributes
 
-  def initialize(status, id, from, time)
-    @status, @id, @from, @time = status, id, from, time
-  end
+    def initialize(actor_attributes = {})
+      [:ID, :Attributes].each do |sym|
+        value = actor_attributes[sym]
+        if value.nil?
+          value = actor_attributes[sym.to_s]
+        end
+        send("#{sym}=", value)
+      end
 
-  def to_s
-    "Docker::Event { :status => #{self.status}, :id => #{self.id}, "\
-      ":from => #{self.from}, :time => #{self.time} }"
+      if self.Attributes.nil?
+        self.Attributes = {}
+      end
+    end
+
+    alias_method :id, :ID
+    alias_method :attributes, :Attributes
   end
 
   class << self
@@ -18,7 +29,9 @@ class Docker::Event
 
     def stream(opts = {}, conn = Docker.connection, &block)
       conn.get('/events', opts, :response_block => lambda { |b, r, t|
-        block.call(new_event(b, r, t))
+        b.each_line do |line|
+          block.call(new_event(line, r, t))
+        end
       })
     end
 
@@ -29,12 +42,85 @@ class Docker::Event
     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']
-      )
+      Docker::Event.new(json)
     end
   end
+
+  attr_accessor :Type, :Action, :time, :timeNano
+  attr_reader :Actor
+  # Deprecated interface
+  attr_accessor :status, :from
+
+  def initialize(event_attributes = {})
+    [:Type, :Action, :Actor, :time, :timeNano, :status, :from].each do |sym|
+      value = event_attributes[sym]
+      if value.nil?
+        value = event_attributes[sym.to_s]
+      end
+      send("#{sym}=", value)
+    end
+
+    if @Actor.nil?
+      value = event_attributes[:id]
+      if value.nil?
+        value = event_attributes['id']
+      end
+      self.Actor = Actor.new(ID: value)
+    end
+  end
+
+  def ID
+    self.actor.ID
+  end
+
+  def Actor=(actor)
+    return if actor.nil?
+    if actor.is_a? Actor
+      @Actor = actor
+    else
+      @Actor = Actor.new(actor)
+    end
+  end
+
+  alias_method :type, :Type
+  alias_method :action, :Action
+  alias_method :actor, :Actor
+  alias_method :time_nano, :timeNano
+  alias_method :id, :ID
+
+  def to_s
+    if type.nil? && action.nil?
+      to_s_legacy
+    else
+      to_s_actor_style
+    end
+  end
+
+  private
+
+  def to_s_legacy
+    attributes = []
+    attributes << "from=#{from}" unless from.nil?
+
+    unless attributes.empty?
+      attribute_string = "(#{attributes.join(', ')}) "
+    end
+
+    "Docker::Event { #{time} #{status} #{id} #{attribute_string}}"
+  end
+
+  def to_s_actor_style
+    most_accurate_time = time_nano || time
+
+    attributes = []
+    actor.attributes.each do |attribute, value|
+      attributes << "#{attribute}=#{value}"
+    end
+
+    unless attributes.empty?
+      attribute_string = "(#{attributes.join(', ')}) "
+    end
+
+    "Docker::Event { #{most_accurate_time} #{type} #{action} #{actor.id} #{attribute_string}}"
+  end
 end

data/lib/docker/exec.rb

@@ -20,7 +20,7 @@ class Docker::Exec
   def self.create(options = {}, conn = Docker.connection)
     container = options.delete('Container')
     resp = conn.post("/containers/#{container}/exec", {},
-      :body => options.to_json)
+      body: MultiJson.dump(options))
     hash = Docker::Util.parse_json(resp) || {}
     new(conn, hash)
   end
@@ -51,11 +51,11 @@ class Docker::Exec
     read_timeout = options[:wait]
 
     # Create API Request Body
-    body = {
-      "Tty" => tty,
-      "Detach" => detached
-    }
-    excon_params = { :body => body.to_json }
+    body = MultiJson.dump(
+      'Tty' => tty,
+      'Detach' => detached
+    )
+    excon_params = { body: body }
 
     msgs = Docker::Messages.new
     unless detached

data/lib/docker/image.rb

@@ -6,17 +6,17 @@ class Docker::Image
   # an Image. This will not modify the Image, but rather create a new Container
   # 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 }
+  def run(cmd = nil, options = {})
+    opts = {'Image' => self.id}.merge(options)
     opts["Cmd"] = cmd.is_a?(String) ? cmd.split(/\s+/) : cmd
     begin
       Docker::Container.create(opts, connection)
                        .tap(&:start!)
-    rescue ServerError => ex
+    rescue ServerError, ClientError => ex
       if cmd
         raise ex
       else
-        raise ServerError, "No command specified."
+        raise ex, "No command specified."
       end
     end
   end
@@ -108,7 +108,7 @@ class Docker::Image
 
     # Create a new Image.
     def create(opts = {}, creds = nil, conn = Docker.connection, &block)
-      credentials = creds.nil? ? Docker.creds : creds.to_json
+      credentials = creds.nil? ? Docker.creds : MultiJson.dump(creds)
       headers = credentials && Docker::Util.build_auth_header(credentials) || {}
       body = ''
       conn.post(
@@ -117,17 +117,32 @@ class Docker::Image
         :headers => headers,
         :response_block => response_block(body, &block)
         )
+      # NOTE: see associated tests for why we're looking at image#end_with?
       image = opts['fromImage'] || opts[:fromImage]
+      tag = opts['tag'] || opts[:tag]
+      image = "#{image}:#{tag}" if tag && !image.end_with?(":#{tag}")
       get(image, {}, conn)
     end
 
     # Return a specific image.
     def get(id, opts = {}, conn = Docker.connection)
-      image_json = conn.get("/images/#{URI.encode(id)}/json", opts)
+      image_json = conn.get("/images/#{id}/json", opts)
       hash = Docker::Util.parse_json(image_json) || {}
       new(conn, hash)
     end
 
+    # Delete a specific image
+    def remove(id, opts = {}, conn = Docker.connection)
+      conn.delete("/images/#{id}", opts)
+    end
+    alias_method :delete, :remove
+
+    # Prune images
+    def prune(conn = Docker.connection)
+      conn.post("/images/prune", {})
+    end
+
+
     # Save the raw binary representation or one or more Docker images
     #
     # @param names [String, Array#String] The image(s) you wish to save
@@ -159,7 +174,7 @@ class Docker::Image
       # 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) }
+      Array(names).each { |name| query['names'.dup] = name }
       conn.get(
         '/images/get',
         query,
@@ -171,14 +186,14 @@ class Docker::Image
     # Load a tar Image
     def load(tar, opts = {}, conn = Docker.connection, creds = nil, &block)
        headers = build_headers(creds)
+       io = tar.is_a?(String) ? File.open(tar, 'rb') : tar
        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 }
+       ) { io.read(Excon.defaults[:chunk_size]).to_s }
     end
 
     # Check if an image exists.
@@ -197,8 +212,14 @@ class Docker::Image
 
     # Given a query like `{ :term => 'sshd' }`, queries the Docker Registry for
     # a corresponding Image.
-    def search(query = {}, connection = Docker.connection)
-      body = connection.get('/images/search', query)
+    def search(query = {}, connection = Docker.connection, creds = nil)
+      credentials = creds.nil? ? Docker.creds : creds.to_json
+      headers = credentials && Docker::Util.build_auth_header(credentials) || {}
+      body = connection.get(
+        '/images/search',
+        query,
+        :headers => headers,
+      )
       hashes = Docker::Util.parse_json(body) || []
       hashes.map { |hash| new(connection, 'id' => hash['name']) }
     end

data/lib/docker/network.rb

@@ -2,18 +2,18 @@
 class Docker::Network
   include Docker::Base
 
-  def connect(container, opts = {})
+  def connect(container, opts = {}, body_opts = {})
+    body = MultiJson.dump({ container: container }.merge(body_opts))
     Docker::Util.parse_json(
-      connection.post(path_for('connect'), opts,
-                      body: { container: container }.to_json)
+      connection.post(path_for('connect'), opts, body: body)
     )
     reload
   end
 
   def disconnect(container, opts = {})
+    body = MultiJson.dump(container: container)
     Docker::Util.parse_json(
-      connection.post(path_for('disconnect'), opts,
-                      body: { container: container }.to_json)
+      connection.post(path_for('disconnect'), opts, body: body)
     )
     reload
   end
@@ -34,25 +34,24 @@ class Docker::Network
   end
 
   def reload
-    network_json = @connection.get("/networks/#{URI.encode(@id)}")
+    network_json = @connection.get("/networks/#{@id}")
     hash = Docker::Util.parse_json(network_json) || {}
     @info = hash
   end
 
   class << self
     def create(name, opts = {}, conn = Docker.connection)
-      default_opts = {
+      default_opts = MultiJson.dump({
         'Name' => name,
         'CheckDuplicate' => true
-      }
-      resp = conn.post('/networks/create', {},
-                       body: default_opts.merge(opts).to_json)
+      }.merge(opts))
+      resp = conn.post('/networks/create', {}, body: default_opts)
       response_hash = Docker::Util.parse_json(resp) || {}
       get(response_hash['Id'], {}, conn) || {}
     end
 
     def get(id, opts = {}, conn = Docker.connection)
-      network_json = conn.get("/networks/#{URI.encode(id)}", opts)
+      network_json = conn.get("/networks/#{id}", opts)
       hash = Docker::Util.parse_json(network_json) || {}
       new(conn, hash)
     end
@@ -63,10 +62,15 @@ class Docker::Network
     end
 
     def remove(id, opts = {}, conn = Docker.connection)
-      conn.delete("/networks/#{URI.encode(id)}", opts)
+      conn.delete("/networks/#{id}", opts)
       nil
     end
     alias_method :delete, :remove
+
+    def prune(conn = Docker.connection)
+      conn.post("/networks/prune", {})
+      nil
+    end
   end
 
   # Convenience method to return the path for a particular resource.

data/lib/docker/util.rb

@@ -1,6 +1,9 @@
 # This module holds shared logic that doesn't really belong anywhere else in the
 # gem.
 module Docker::Util
+  # http://www.tldp.org/LDP/GNU-Linux-Tools-Summary/html/x11655.htm#STANDARD-WILDCARDS
+  GLOB_WILDCARDS = /[\?\*\[\{]/
+
   include Docker::Error
 
   module_function
@@ -99,8 +102,8 @@ module Docker::Util
   end
 
   def parse_json(body)
-    JSON.parse(body) unless body.nil? || body.empty? || (body == 'null')
-  rescue JSON::ParserError => ex
+    MultiJson.load(body) unless body.nil? || body.empty? || (body == 'null')
+  rescue MultiJson::ParseError => ex
     raise UnexpectedResponseError, ex.message
   end
 
@@ -119,8 +122,12 @@ module Docker::Util
   def create_tar(hash = {})
     output = StringIO.new
     Gem::Package::TarWriter.new(output) do |tar|
-      hash.each do |file_name, input|
-        tar.add_file(file_name, 0640) { |tar_file| tar_file.write(input) }
+      hash.each do |file_name, file_details|
+        permissions = file_details.is_a?(Hash) ? file_details[:permissions] : 0640
+        tar.add_file(file_name, permissions) do |tar_file|
+          content = file_details.is_a?(Hash) ? file_details[:content] : file_details
+          tar_file.write(content)
+        end
       end
     end
     output.tap(&:rewind).string
@@ -137,7 +144,10 @@ module Docker::Util
 
   def create_relative_dir_tar(directory, output)
     Gem::Package::TarWriter.new(output) do |tar|
-      Find.find(directory) do |prefixed_file_name|
+      files = glob_all_files(File.join(directory, "**/*"))
+      remove_ignored_files!(directory, files)
+
+      files.each do |prefixed_file_name|
         stat = File.stat(prefixed_file_name)
         next unless stat.file?
 
@@ -201,18 +211,29 @@ module Docker::Util
       basename = File.basename(local_path)
       if File.directory?(local_path)
         tar = create_dir_tar(local_path)
-        file_hash[basename] = tar.read
+        file_hash[basename] = {
+          content: tar.read,
+          permissions: filesystem_permissions(local_path)
+        }
         tar.close
         FileUtils.rm(tar.path)
       else
-        file_hash[basename] = File.read(local_path)
+        file_hash[basename] = {
+          content: File.read(local_path, mode: 'rb'),
+          permissions: filesystem_permissions(local_path)
+        }
       end
     end
   end
 
+  def filesystem_permissions(path)
+    mode = sprintf("%o", File.stat(path).mode)
+    mode[(mode.length - 3)...mode.length].to_i(8)
+  end
+
   def build_auth_header(credentials)
-    credentials = credentials.to_json if credentials.is_a?(Hash)
-    encoded_creds = Base64.encode64(credentials).gsub(/\n/, '')
+    credentials = MultiJson.dump(credentials) if credentials.is_a?(Hash)
+    encoded_creds = Base64.urlsafe_encode64(credentials)
     {
       'X-Registry-Auth' => encoded_creds
     }
@@ -220,20 +241,39 @@ module Docker::Util
 
   def build_config_header(credentials)
     if credentials.is_a?(String)
-      credentials = JSON.parse(credentials, symbolize_names: true)
+      credentials = MultiJson.load(credentials, symbolize_keys: true)
     end
-    header = {
+
+    header = MultiJson.dump(
       credentials[:serveraddress].to_s => {
-        "username" => credentials[:username].to_s,
-        "password" => credentials[:password].to_s,
-        "email" => credentials[:email].to_s
+        'username' => credentials[:username].to_s,
+        'password' => credentials[:password].to_s,
+        'email' => credentials[:email].to_s
       }
-    }.to_json
+    )
 
-    encoded_header = Base64.encode64(header).gsub(/\n/, '')
+    encoded_header = Base64.urlsafe_encode64(header)
 
     {
       'X-Registry-Config' => encoded_header
     }
   end
+
+  def glob_all_files(pattern)
+    Dir.glob(pattern, File::FNM_DOTMATCH) - ['..', '.']
+  end
+
+  def remove_ignored_files!(directory, files)
+    ignore = File.join(directory, '.dockerignore')
+    return unless files.include?(ignore)
+    ignored_files(directory, ignore).each { |f| files.delete(f) }
+  end
+
+  def ignored_files(directory, ignore_file)
+    patterns = File.read(ignore_file).split("\n").each(&:strip!)
+    patterns.reject! { |p| p.empty? || p.start_with?('#') }
+    patterns.map! { |p| File.join(directory, p) }
+    patterns.map! { |p| File.directory?(p) ? "#{p}/**/*" : p }
+    patterns.flat_map { |p| p =~ GLOB_WILDCARDS ? glob_all_files(p) : p }
+  end
 end