dockerapi 0.8.1 → 0.13.0

data/dockerapi.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|resources)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|resources)/}) }.append("doc")
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }

data/lib/docker/api/base.rb

@@ -1,38 +1,66 @@
-module Docker
-    module API
-        class Base
+class Docker::API::Base
+    
 
-            def initialize connection = nil
-                raise Docker::API::Error.new("Expect connection to be a Docker::API::Connection class") if connection != nil && !connection.is_a?(Docker::API::Connection)
-                @connection = connection || Docker::API::Connection.new
-            end
-            
-            private
+    def initialize connection = nil
+        raise Docker::API::Error.new("Expected connection to be a Docker::API::Connection class") if connection != nil && !connection.is_a?(Docker::API::Connection)
+        @connection = connection || Docker::API::Connection.new
+        
+        (self.methods - Object.methods).each do |method|
+            params_index = method(method).parameters.map{|ar| ar[1]}.index(:params)
+            body_index = method(method).parameters.map{|ar| ar[1]}.index(:body)
 
-            def base_path # TODO: this method to be removed?
-                "/"
+            define_singleton_method(method) do |*args, &block|
+                validate Docker::API::InvalidParameter, Docker::API::VALID_PARAMS["#{self.class.name}"]["#{method}"], (args[params_index] || {}) if params_index
+                validate Docker::API::InvalidRequestBody, Docker::API::VALID_BODY["#{self.class.name}"]["#{method}"], (args[body_index] || {}) if body_index
+                super(*args,&block)
             end
+        end
+    end
+    
+    private
 
-            def validate error, permitted, params
-                return if params[:skip_validation]
-                unpermitted = params.keys.map(&:to_s) - permitted.map(&:to_s)
-                raise error.new(permitted, unpermitted) if unpermitted.size > 0
-            end
+    def default_streamer
+        streamer = lambda do |chunk, remaining_bytes, total_bytes|
+            p chunk.to_s.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?') if Docker::API::PRINT_TO_STDOUT
+        end
+        streamer
+    end
 
-            ## Converts Ruby Hash into query parameters
-            ## In general, the format is key=value
-            ## If value is another Hash, it should keep a json syntax {key:value}
-            def hash_to_params h
-                p = []
-                h.delete_if{ | k, v | k.to_s == "skip_validation" }.each { |k,v| p.push( v.is_a?(Hash) ? "#{k}=#{v.to_json}" : "#{k}=#{v}") }
-                p.join("&").gsub(" ","")
-            end
+    def default_writer path
+        streamer = lambda do |chunk, remaining_bytes, total_bytes|
+            return if "#{chunk}".match(/(No such image)/)
+            file = File.open(File.expand_path(path), "wb+")
+            file.write(chunk)
+            file.close
+        end
+        streamer
+    end
 
-            def build_path path, params = {}
-                p = path.is_a?(Array) ? ([base_path] << path).join("/") : path # TODO: this line to be removed?
-                params.size > 0 ? [p, hash_to_params(params)].join("?") : p
-            end
+    def default_reader path, url, header = {"Content-Type" => "application/x-tar"}, &block
+        file = File.open(File.expand_path(path), "r")
+        response = @connection.request(method: :post, path: url , headers: header, request_block: lambda { file.read(Excon.defaults[:chunk_size]).to_s}, response_block: block_given? ? block.call : default_streamer )
+        file.close
+        response
+    end
 
-        end
+    def validate error, permitted, params
+        return if params[:skip_validation]
+        unpermitted = params.keys.map(&:to_s) - permitted.map(&:to_s)
+        raise error.new(permitted, unpermitted) if unpermitted.size > 0
+    end
+
+    ## Converts Ruby Hash into query parameters
+    ## In general, the format is key=value
+    ## If value is another Hash, it should keep a json syntax {key:value}
+    def hash_to_params h
+        p = []
+        h.delete_if{ | k, v | k.to_s == "skip_validation" }.each { |k,v| p.push( v.is_a?(Hash) ? "#{k}=#{v.to_json}" : "#{k}=#{v}") }
+        p.join("&").gsub(" ","")
+    end
+
+    def build_path path, params = {}
+        p = path.is_a?(Array) ? ([base_path] << path).join("/") : path # TODO: this line to be removed?
+        params.size > 0 ? [p, hash_to_params(params)].join("?") : p
     end
+
 end

data/lib/docker/api/config.rb

@@ -0,0 +1,66 @@
+# This class represents the Docker API endpoints regarding configs.
+#
+# @see https://docs.docker.com/engine/api/v1.40/#tag/Config
+#
+# Configs are application configurations that can be used by services. Swarm mode must be enabled for these endpoints to work.
+class Docker::API::Config < Docker::API::Base
+
+    # List configs
+    #
+    # Docker API: GET /configs
+    #
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ConfigList
+    #
+    # @param params [Hash]: Parameters that are appended to the URL.
+    def list params = {}
+        @connection.get(build_path("/configs",params))
+    end
+
+    # Create a config
+    #
+    # Docker API: POST /configs/create
+    #
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ConfigCreate
+    #
+    # @param body [Hash]: Request body to be sent as json.
+    def create body = {}
+        @connection.request(method: :post, path: "/configs/create", headers: {"Content-Type": "application/json"}, body: body.to_json)
+    end
+
+    # Inspect a config
+    #
+    # Docker API: GET /configs/{id}
+    #
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ConfigInspect
+    #
+    # @param name [String]: The ID or name of the config.
+    def details name
+        @connection.get("/configs/#{name}")
+    end
+
+    # Update a config
+    #
+    # Docker API: POST /configs/{id}/update
+    #
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ConfigUpdate
+    #
+    # @param name [String]: The ID or name of the config.
+    #
+    # @param params [Hash]: Parameters that are appended to the URL.
+    #
+    # @param body [Hash]: Request body to be sent as json.
+    def update name, params = {}, body = {}
+        @connection.request(method: :post, path: build_path("/configs/#{name}/update",params), headers: {"Content-Type": "application/json"}, body: body.to_json)
+    end
+
+    # Delete a config
+    #
+    # Docker API: DELETE /configs/{id}
+    #
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ConfigDelete
+    #
+    # @param name [String]: The ID or name of the config.
+    def delete name
+        @connection.delete("/configs/#{name}")
+    end
+end

data/lib/docker/api/container.rb

@@ -1,28 +1,16 @@
 module Docker
     module API
-        CreateBody = [:Hostname,:Domainname,:User,:AttachStdin,:AttachStdout,:AttachStderr,:ExposedPorts,:Tty,:OpenStdin,:StdinOnce,:Env,:Cmd,:HealthCheck,:ArgsEscaped,:Image,:Volumes,:WorkingDir,:Entrypoint,:NetworkDisabled,:MacAddress,:OnBuild,:Labels,:StopSignal,:StopTimeout,:Shell,:HostConfig,:NetworkingConfig]
-        UpdateBody = [:CpuShares, :Memory, :CgroupParent, :BlkioWeight, :BlkioWeightDevice, :BlkioWeightReadBps, :BlkioWeightWriteBps, :BlkioWeightReadOps, :BlkioWeightWriteOps, :CpuPeriod, :CpuQuota, :CpuRealtimePeriod, :CpuRealtimeRuntime, :CpusetCpus, :CpusetMems, :Devices, :DeviceCgroupRules, :DeviceRequest, :Kernel, :Memory, :KernelMemoryTCP, :MemoryReservation, :MemorySwap, :MemorySwappiness, :NanoCPUs, :OomKillDisable, :Init, :PidsLimit, :ULimits, :CpuCount, :CpuPercent, :IOMaximumIOps, :IOMaximumBandwidth, :RestartPolicy]
-
         class Container < Docker::API::Base
 
-            def base_path
-                "/containers"
+            def list params = {}
+                @connection.get(build_path(["json"], params))
             end
 
-            def inspect *args
-                return super.inspect if args.size == 0
-                name, params = args[0], args[1] || {}
-                validate Docker::API::InvalidParameter, [:size], params
+            def details name, params = {}
                 @connection.get(build_path([name, "json"], params))
             end
 
-            def list params = {}
-                validate Docker::API::InvalidParameter, [:all, :limit, :size, :filters], params
-                @connection.get(build_path(["json"], params))
-            end
-
             def top name, params = {}
-                validate Docker::API::InvalidParameter, [:ps_args], params
                 @connection.get(build_path([name, "top"], params))
             end
 
@@ -31,47 +19,38 @@ module Docker
             end
 
             def start name, params = {}
-                validate Docker::API::InvalidParameter, [:detachKeys], params
                 @connection.post(build_path([name, "start"], params))
             end
 
             def stop name, params = {}
-                validate Docker::API::InvalidParameter, [:t], params
                 @connection.post(build_path([name, "stop"], params))
             end
 
             def restart name, params = {}
-                validate Docker::API::InvalidParameter, [:t], params
                 @connection.post(build_path([name, "restart"], params))
             end
 
             def kill name, params = {}
-                validate Docker::API::InvalidParameter, [:signal], params
                 @connection.post(build_path([name, "kill"], params))
             end
 
             def wait name, params = {}
-                validate Docker::API::InvalidParameter, [:condition], params
                 @connection.post(build_path([name, "wait"], params))
             end
 
             def update name, body = {}
-                validate Docker::API::InvalidRequestBody, Docker::API::UpdateBody, body
                 @connection.request(method: :post, path: build_path([name, "update"]), headers: {"Content-Type": "application/json"}, body: body.to_json)
             end
 
             def rename name, params = {}
-                validate Docker::API::InvalidParameter, [:name], params
                 @connection.post(build_path([name, "rename"], params))
             end
 
             def resize name, params = {}
-                validate Docker::API::InvalidParameter, [:w, :h], params
                 @connection.post(build_path([name, "resize"], params))
             end
 
             def prune params = {}
-                validate Docker::API::InvalidParameter, [:filters], params
                 @connection.post(build_path(["prune"], params))
             end
 
@@ -84,12 +63,10 @@ module Docker
             end
 
             def remove name, params = {}
-                validate Docker::API::InvalidParameter, [:v, :force, :link], params
                 @connection.delete(build_path([name]))
             end
 
             def logs name, params = {}
-                validate Docker::API::InvalidParameter, [:follow, :stdout, :stderr, :since, :until, :timestamps, :tail], params
                 
                 path = build_path([name, "logs"], params)
 
@@ -101,18 +78,14 @@ module Docker
             end
 
             def attach name, params = {}
-                validate Docker::API::InvalidParameter, [:detachKeys, :logs, :stream, :stdin, :stdout, :stderr], params
                 @connection.request(method: :post, path: build_path([name, "attach"], params) , response_block: lambda { |chunk, remaining_bytes, total_bytes| puts chunk.inspect })
             end
 
             def create params = {}, body = {}
-                validate Docker::API::InvalidParameter, [:name], params
-                validate Docker::API::InvalidRequestBody, Docker::API::CreateBody, body
                 @connection.request(method: :post, path: build_path(["create"], params), headers: {"Content-Type": "application/json"}, body: body.to_json)
             end
 
             def stats name, params = {}
-                validate Docker::API::InvalidParameter, [:stream], params
                 path = build_path([name, "stats"], params)
 
                 if params[:stream] == true || params[:stream] == 1
@@ -126,7 +99,7 @@ module Docker
             end
 
             def export name, path = "exported_container"
-                response = self.inspect(name)
+                response = self.details(name)
                 if response.status == 200
                     file = File.open(File.expand_path(path), "wb")
                     streamer = lambda do |chunk, remaining_bytes, total_bytes|
@@ -139,7 +112,6 @@ module Docker
             end
 
             def archive name, file, params = {}
-                validate Docker::API::InvalidParameter, [:path, :noOverwriteDirNonDir, :copyUIDGID], params
 
                 begin # File exists on disk, send it to container
                     file = File.open( File.expand_path( file ) , "r")
@@ -156,6 +128,21 @@ module Docker
                 response
             end
 
+            #################################################
+            # Items in this area to be removed before 1.0.0 #
+            #################################################
+            def base_path
+                "/containers"
+            end
+
+            def inspect *args
+                return super.inspect if args.size == 0
+                warn  "WARNING: #inspect is deprecated and will be removed in the future, please use #details instead."
+                name, params = args[0], args[1] || {}
+                details(name, params)
+            end
+            #################################################
+
         end
     end
 end

data/lib/docker/api/exec.rb

@@ -2,20 +2,11 @@ module Docker
     module API
         class Exec < Docker::API::Base
 
-            def inspect *args
-                return super.inspect if args.size == 0
-                name = args[0]
-                @connection.get("/exec/#{name}/json")
-            end
-
             def create name, body = {}
-                validate Docker::API::InvalidRequestBody, [:AttachStdin, :AttachStdout, :AttachStderr, :DetachKeys, :Tty, :Env, :Cmd, :Privileged, :User, :WorkingDir], body
                 @connection.request(method: :post, path: "/containers/#{name}/exec", headers: {"Content-Type": "application/json"}, body: body.to_json )
             end
 
             def start name, body = {}
-                validate Docker::API::InvalidRequestBody, [:Detach, :Tty], body
-
                 stream = ""
                 response = @connection.request(method: :post, 
                     path: "/exec/#{name}/start", 
@@ -28,10 +19,24 @@ module Docker
             end
 
             def resize name, params = {}
-                validate Docker::API::InvalidParameter, [:w, :h], params
                 @connection.post(build_path("/exec/#{name}/resize", params))
             end
 
+            def details name
+                @connection.get("/exec/#{name}/json")
+            end
+            
+            #################################################
+            # Items in this area to be removed before 1.0.0 #
+            #################################################
+            def inspect *args
+                return super.inspect if args.size == 0
+                warn  "WARNING: #inspect is deprecated and will be removed in the future, please use #details instead."
+                name = args[0]
+                details(name)
+            end
+            #################################################
+
         end
     end
 end

data/lib/docker/api/image.rb

@@ -1,140 +1,190 @@
-require "base64"
-require "json"
-require 'fileutils'
-module Docker
-    module API
-        CommitBody = [:Hostname, :Domainname, :User, :AttachStdin, :AttachStdout, :AttachStderr, :ExposedPorts, :Tty, :OpenStdin, :StdinOnce, :Env, :Cmd, :HealthCheck, :ArgsEscaped, :Image, :Volumes, :WorkingDir, :Entrypoint, :NetworkDisabled, :MacAddress, :OnBuild, :Labels, :StopSignal, :StopTimeout, :Shell]
-        BuildParams = [:dockerfile, :t, :extrahosts, :remote, :q, :nocache, :cachefrom, :pull, :rm, :forcerm, :memory, :memswap, :cpushares, :cpusetcpus, :cpuperiod, :cpuquota, :buildargs, :shmsize, :squash, :labels, :networkmode, :platform, :target, :outputs]
-        class Image < Docker::API::Base
-
-            def base_path
-                "/images"
-            end
-
-            def inspect *args
-                return super.inspect if args.size == 0
-                name = args[0]
-                @connection.get(build_path([name, "json"]))
-            end
-
-            def history name
-                @connection.get(build_path([name, "history"]))
-            end
-
-            def list params = {}
-                validate Docker::API::InvalidParameter, [:all, :filters, :digests], params
-                @connection.get(build_path(["json"], params)) 
-            end
-
-            def search params = {}
-                validate Docker::API::InvalidParameter, [:term, :limit, :filters], params
-                @connection.get(build_path(["search"], params)) 
-            end
-
-            def tag name, params = {}
-                validate Docker::API::InvalidParameter, [:repo, :tag], params
-                @connection.post(build_path([name, "tag"], params))
-            end
-
-            def prune params = {}
-                validate Docker::API::InvalidParameter, [:filters], params
-                @connection.post(build_path(["prune"], params))
-            end
-
-            def remove name, params = {}
-                validate Docker::API::InvalidParameter, [:force, :noprune], params
-                @connection.delete(build_path([name], params))
-            end
-
-            def export name, path = "exported_image"
-                file = File.open("/tmp/exported-image", "wb")
-                streamer = lambda do |chunk, remaining_bytes, total_bytes|
-                    file.write(chunk)
-                end
-                response = @connection.request(method: :get, path: build_path([name, "get"]) , response_block: streamer)
-                file.close
-                response.status == 200 ? FileUtils.mv("/tmp/exported-image", File.expand_path(path)) : FileUtils.rm("/tmp/exported-image")
-                response
-            end
-
-            def import path, params = {}
-                validate Docker::API::InvalidParameter, [:quiet], params
-                file = File.open(File.expand_path(path), "r")
-                response = @connection.request(method: :post, path: build_path(["load"], params) , headers: {"Content-Type" => "application/x-tar"}, request_block: lambda { file.read(Excon.defaults[:chunk_size]).to_s} )
-                file.close
-                response
-            end
-
-            def push name, params = {}, authentication = {}
-                validate Docker::API::InvalidParameter, [:tag], params
-
-                if authentication.keys.size > 0
-                    @connection.request(method: :post, path: build_path([name, "push"], params), headers: { "X-Registry-Auth" => Base64.urlsafe_encode64(authentication.to_json.to_s).chomp } )
-                else
-                    raise Docker::API::Error.new("Provide authentication parameters to push an image")
-                end
-            end
-
-            def commit params = {}, body = {}
-                validate Docker::API::InvalidParameter, [:container, :repo, :tag, :comment, :author, :pause, :changes], params
-                validate Docker::API::InvalidRequestBody, Docker::API::CommitBody, body
-                container = Docker::API::Container.new.inspect(params[:container])
-                return container if [404, 301].include? container.status
-                body = JSON.parse(container.body)["Config"].merge(body)
-                @connection.request(method: :post, path: build_path("/commit", params), headers: {"Content-Type": "application/json"}, body: body.to_json)
-            end
-
-            def create params = {}, authentication = {}
-                validate Docker::API::InvalidParameter, [:fromImage, :fromSrc, :repo, :tag, :message, :platform], params
-                
-                if authentication.keys.size > 0
-                    auth = Docker::API::System.new.auth(authentication)
-                    return auth unless [200, 204].include? auth.status
-                    @connection.request(method: :post, path: build_path(["create"], params), headers: { "X-Registry-Auth" => Base64.encode64(authentication.to_json.to_s).chomp } )
-                elsif params.has_key? :fromSrc
-                    if params[:fromSrc].match(/^(http|https)/)
-                        @connection.request(method: :post, path: build_path(["create"], params))
-                    else
-                        file = File.open(File.expand_path(params[:fromSrc]), "r")
-                        params[:fromSrc] = "-"
-                        response = @connection.request(method: :post, path: build_path(["create"], params) , headers: {"Content-Type" => "application/x-tar"}, request_block: lambda { file.read(Excon.defaults[:chunk_size]).to_s} )
-                        file.close
-                        response
-                    end
-                else
-                    @connection.post(build_path(["create"], params))
-                end
-            end
-
-            def build path, params = {}, authentication = {}
-                raise Docker::API::Error.new("Expected path or params[:remote]") unless path || params[:remote] 
-                validate Docker::API::InvalidParameter, Docker::API::BuildParams, params
-
-                header = {"Content-type": "application/x-tar"}
-                if authentication.keys.size > 0
-                    authentication.each_key do |server|
-                        auth = Docker::API::System.new.auth({username: authentication[server][:username] ,password:authentication[server][:password], serveraddress: server})
-                        return auth unless [200, 204].include? auth.status
-                    end
-                    header.merge!({"X-Registry-Config": Base64.urlsafe_encode64(authentication.to_json.to_s).chomp})
-                end
-
-                begin
-                    file = File.open( File.expand_path( path ) , "r")
-                    response = @connection.request(method: :post, path: build_path("/build", params), headers: header, request_block: lambda { file.read(Excon.defaults[:chunk_size]).to_s})
-                    file.close
-                rescue
-                    response = @connection.request(method: :post, path: build_path("/build", params), headers: header)
-                end
-                response
-            end
-
-            def delete_cache params = {}
-                validate Docker::API::InvalidParameter, [:all, "keep-storage", :filters], params
-                @connection.post(build_path("/build/prune", params))
-            end
+##
+# This class represents the Docker API endpoints regarding images.
+# @see https://docs.docker.com/engine/api/v1.40/#tag/Image
+class Docker::API::Image < Docker::API::Base
+
+    ##
+    # Return low-level information about an image.
+    # Docker API: GET /images/{name}/json
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ImageInspect
+    #
+    # @param name [String]: The ID or name of the image.
+    def details name
+        @connection.get("/images/#{name}/json")
+    end
+
+    ##
+    # Return image digest and platform information by contacting the registry.
+    # Docker API: GET /distribution/{name}/json
+    # @see https://docs.docker.com/engine/api/v1.40/#tag/Distribution
+    #
+    # @param name [String]: The ID or name of the image.
+    def distribution name
+        @connection.get("/distribution/#{name}/json")
+    end
+
+    ##
+    # Return parent layers of an image.
+    # Docker API: GET /images/{name}/history
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ImageHistory
+    #
+    # @param name [String]: The ID or name of the image.
+    def history name
+        @connection.get("/images/#{name}/history")
+    end
+
+    ##
+    # Returns a list of images on the server. Note that it uses a different, smaller representation of an image than inspecting a single image.
+    # Docker API: GET /images/json
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ImageList
+    #
+    # @param params [Hash]: Parameters that are appended to the URL.
+    def list params = {}
+        @connection.get(build_path("/images/json", params)) 
+    end
 
+    ##
+    # Search for an image on Docker Hub.
+    # Docker API: GET /images/search
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ImageSearch
+    #
+    # @param params [Hash]: Parameters that are appended to the URL.
+    def search params = {}
+        @connection.get(build_path("/images/search", params)) 
+    end
+
+    ##
+    # Tag an image so that it becomes part of a repository.
+    # Docker API: POST /images/{name}/tag
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ImageTag
+    #
+    # @param name [String]: The ID or name of the image.
+    # @param params [Hash]: Parameters that are appended to the URL.
+    def tag name, params = {}
+        @connection.post(build_path("/images/#{name}/tag", params))
+    end
+
+    ##
+    # Delete unused images.
+    # Docker API: POST /images/prune
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ImagePrune
+    #
+    # @param params [Hash]: Parameters that are appended to the URL.
+    def prune params = {}
+        @connection.post(build_path("/images/prune", params))
+    end
+
+    ##
+    # Remove an image, along with any untagged parent images that were referenced by that image.
+    # Images can't be removed if they have descendant images, are being used by a running container or are being used by a build.
+    # Docker API: DELETE /images/{name}
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ImageDelete
+    #
+    # @param name [String]: The ID or name of the image.
+    # @param params [Hash]: Parameters that are appended to the URL.
+    def remove name, params = {}
+        @connection.delete(build_path("/images/#{name}", params))
+    end
+
+    ##
+    # Export an image.
+    # Docker API: GET /images/{name}/get
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ImageGet
+    #
+    # @param name [String]: The ID or name of the image.
+    # @param path [Hash]: Parameters that are appended to the URL.
+    # @param block [Hash]: Request body to be sent as json.
+    # @block: Replace the default file writing method.
+    def export name, path = "exported_image", &block
+        @connection.request(method: :get, path: build_path("/images/#{name}/get") , response_block: block_given? ? block.call : default_writer(path))
+    end
+
+    ##
+    # Import images.
+    # Docker API: POST /images/load
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ImageLoad
+    #
+    # @param name [String]: The ID or name of the image.
+    # @param params [Hash]: Parameters that are appended to the URL.
+    def import path, params = {}
+        default_reader(path, build_path("/images/load", params))
+    end
+
+    ##
+    # Push an image to a registry.
+    # Docker API: POST /images/{name}/push
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ImagePush
+    #
+    # @param name [String]: The ID or name of the image.
+    # @param params [Hash]: Parameters that are appended to the URL.
+    # @param authentication [Hash]: Authentication parameters.
+    def push name, params = {}, authentication = {}
+        raise Docker::API::Error.new("Provide authentication parameters to push an image") unless authentication.keys.size > 0
+        @connection.request(method: :post, path: build_path("/images/#{name}/push", params), headers: { "X-Registry-Auth" => Base64.urlsafe_encode64(authentication.to_json.to_s).chomp } )
+    end
+
+    ##
+    # Create a new image from a container.
+    # Docker API: POST /commit
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ImageCommit
+    #
+    # @param params [Hash]: Parameters that are appended to the URL.
+    # @param body [Hash]: Request body to be sent as json.
+    def commit params = {}, body = {}
+        container = Docker::API::Container.new.details(params[:container])
+        return container if [404, 301].include? container.status
+        @connection.request(method: :post, path: build_path("/commit", params), headers: {"Content-Type": "application/json"}, body: container.json["Config"].merge(body).to_json)
+    end
+
+    ##
+    # Create an image by either pulling it from a registry or importing it.
+    # Docker API: POST /images/create
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ImageCreate
+    #
+    # @param params [Hash]: Parameters that are appended to the URL.
+    # @param authentication [Hash]: Authentication parameters.
+    # @param &block: Replace the default output to stdout behavior.
+    def create params = {}, authentication = {}, &block
+        request = {method: :post, path: build_path("/images/create", params), response_block: block_given? ? block.call : default_streamer }
+        if params.has_key? :fromSrc and !params[:fromSrc].match(/^(http|https)/) # then it's using a tar file
+            path = params[:fromSrc]
+            params[:fromSrc] = "-"
+            default_reader(path, build_path("/images/create", params))
+        else
+            request[:headers] = { "X-Registry-Auth" => Base64.encode64(authentication.to_json.to_s).chomp } if authentication.keys.size > 0
+            @connection.request(request)
+        end
+    end
+
+    ##
+    # Build an image from a tar archive with a Dockerfile in it.
+    # Docker API: POST /build
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/ImageBuild
+    #
+    # @param path [String]: Path to the tar file.
+    # @param params [Hash]: Parameters that are appended to the URL.
+    # @param authentication [Hash]: Authentication parameters.
+    # @param &block: Replace the default output to stdout behavior.
+    def build path, params = {}, authentication = {}, &block
+        raise Docker::API::Error.new("Expected path or params[:remote]") unless path || params[:remote] 
+
+        headers = {"Content-type": "application/x-tar"}
+        headers.merge!({"X-Registry-Config": Base64.urlsafe_encode64(authentication.to_json.to_s).chomp}) if authentication.keys.size > 0
+
+        if path == nil and params.has_key? :remote
+            response = @connection.request(method: :post, path: build_path("/build", params), headers: headers, response_block: block_given? ? block.call : default_streamer)
+        else
+            default_reader(path, build_path("/build", params), headers)
         end
+    end
 
+    ##
+    # Delete builder cache.
+    # Docker API: POST /build/prune
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/BuildPrune
+    #
+    # @param params [Hash]: Parameters that are appended to the URL.
+    def delete_cache params = {}
+        @connection.post(build_path("/build/prune", params))
     end
 end