dockerapi 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a32e488d06a0afd653bb04ab0ad5131fa8e898973128d7a6661f3d3fa4eae53d
-  data.tar.gz: 641ffcc096f798fbfff057fb1eecc7ce97ad9191c2acf49f5e97c90bf5ceddc5
+  metadata.gz: 0dac991f7f237b1df6314bae40e54a5f44175186bbbb6756184c65862bb9f652
+  data.tar.gz: 604ea213a309219a91b6923e89e8003eb030fff51d22104e8c689872264ebd59
 SHA512:
-  metadata.gz: 6cda72170483e133b467a399d77fbcc7668793726b8f67beb4235c5eaf74e2d91977c9544f93ee7d3f3c4b681004d9415f939d2d521aa70151d3a580fc15fc86
-  data.tar.gz: d45997041c9d706d2c2d0e2c5e3f5ccaedad51d71cb27ba8538898565e6259e30d7ff11ffa60a5dee9ffca3611ed51ddc96ca68af2a5aff490715b4645297c0d
+  metadata.gz: d5f2eb58e059da1f60de416b07902e538ad707ec1a95a4efb665073d3b54a3ab74ea101144f9cea51effd50610ece9e0011061c653d848855885399bcb6b1cdd
+  data.tar.gz: 98e253a61bd7c2ff36df30f9e3557d4c502e10e206c7b5a32d2969e9ec996151741a5bda5a46ef32426905236228caaba57485250a7f7561fb98cd2181052b86

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+# 0.13.0
+
+Add default behavior for file read, write and output to stdout. Whenever a method can receive a block, this default behavior can be replaced.
+
+The following `Docker::API::Image` methods that can now receive a block:
+* export (write file)
+* create (output to stdout)
+* build (output to stdout)
+
+Default output to stdout can be supressed by setting `Docker::API::PRINT_TO_STDOUT` to `false`
+
+Method parameters `params` and `body` will be automatically evaluated whenever they are present in the method's signature.
+
 # 0.12.0
 
 Add `Docker::API::Plugin` methods:

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dockerapi (0.12.0)
+    dockerapi (0.13.0)
       excon (~> 0.74.0)
 
 GEM

data/README.md

@@ -75,13 +75,16 @@ image.prune(filters: {dangling: {"false": true}})
 image.commit(container: container, repo: "my/image", tag: "latest", comment: "Comment from commit", author: "dockerapi", pause: false )
 
 # Build image from a local tar file
-image.build("/path/to/file.tar")
+image.build("/path/to/file.tar", {t: "tag"})
+
+# Build image using private repository
+image.build("/path/to/file.tar", {t: "tag"}, {"https://index.docker.io/v1/" => {username: "janedoe", password: "janedoe"}})
 
 # Build image from a remote tar file
-image.build(nil, remote: "https://url.to/file.tar")
+image.build(nil, {remote: "https://url.to/file.tar", t: "tag"})
 
 # Build image from a remote Dockerfile
-image.build(nil, remote: "https://url.to/Dockerfile")
+image.build(nil, {remote: "https://url.to/Dockerfile", t: "tag"})
 
 # Delete builder cache
 image.delete_cache
@@ -506,7 +509,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 | Class | Tests | Implementation | Refactoring |
 |---|---|---|---|
-| Image | Ok | Ok | 8/7 |
+| Image | Ok | Ok | Ok |
 | Container | Ok | Ok | 8/14 |
 | Volume | Ok | Ok | 8/21 |
 | Network | Ok | Ok | 8/21 |
@@ -519,7 +522,9 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 | Secret | Ok | Ok | 9/4 |
 | Config | Ok | Ok | 9/4 |
 | Distribution | Ok | Ok | 9/4 |
-| Plugin | Ok | 7/24 | 9/4 |
+| Plugin | Ok | Ok | 9/4 |
+
+Add doc in these files: `base`, `connection`, `error`, `response`, `dockerapi`
 
 ## Contributing
 

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

@@ -13,7 +13,6 @@ class Docker::API::Config < Docker::API::Base
     #
     # @param params [Hash]: Parameters that are appended to the URL.
     def list params = {}
-        validate Docker::API::InvalidParameter, [:filters], params
         @connection.get(build_path("/configs",params))
     end
 
@@ -25,7 +24,6 @@ class Docker::API::Config < Docker::API::Base
     #
     # @param body [Hash]: Request body to be sent as json.
     def create body = {}
-        validate Docker::API::InvalidRequestBody, [:Name, :Labels, :Data, :Templating], body
         @connection.request(method: :post, path: "/configs/create", headers: {"Content-Type": "application/json"}, body: body.to_json)
     end
 
@@ -52,8 +50,6 @@ class Docker::API::Config < Docker::API::Base
     #
     # @param body [Hash]: Request body to be sent as json.
     def update name, params = {}, body = {}
-        validate Docker::API::InvalidParameter, [:version], params
-        validate Docker::API::InvalidRequestBody, [:Name, :Labels, :Data, :Driver, :Templating], body
         @connection.request(method: :post, path: build_path("/configs/#{name}/update",params), headers: {"Content-Type": "application/json"}, body: body.to_json)
     end
 

data/lib/docker/api/container.rb

@@ -1,22 +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 list params = {}
-                validate Docker::API::InvalidParameter, [:all, :limit, :size, :filters], params
                 @connection.get(build_path(["json"], params))
             end
 
             def details name, params = {}
-                validate Docker::API::InvalidParameter, [:size], params
                 @connection.get(build_path([name, "json"], params))
             end
 
             def top name, params = {}
-                validate Docker::API::InvalidParameter, [:ps_args], params
                 @connection.get(build_path([name, "top"], params))
             end
 
@@ -25,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
 
@@ -78,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)
 
@@ -95,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
@@ -133,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")

data/lib/docker/api/exec.rb

@@ -3,13 +3,10 @@ module Docker
         class Exec < Docker::API::Base
 
             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", 
@@ -22,7 +19,6 @@ module Docker
             end
 
             def resize name, params = {}
-                validate Docker::API::InvalidParameter, [:w, :h], params
                 @connection.post(build_path("/exec/#{name}/resize", params))
             end
 

data/lib/docker/api/image.rb

@@ -1,152 +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 details name
-                @connection.get(build_path([name, "json"]))
-            end
-
-            def distribution name
-                @connection.get("/distribution/#{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.details(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
-
-            #################################################
-            # Items in this area to be removed before 1.0.0 #
-            #################################################
-            def base_path
-                "/images"
-            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 = args[0]
-                details(name)
-            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

data/lib/docker/api/network.rb

@@ -3,17 +3,14 @@ module Docker
         class Network < Docker::API::Base
 
             def list params = {}
-                validate Docker::API::InvalidParameter, [:filters], params
                 @connection.get(build_path("/networks", params))
             end
 
             def details name, params = {}
-                validate Docker::API::InvalidParameter, [:verbose, :scope], params
                 @connection.get(build_path([name], params))
             end
 
             def create body = {}
-                validate Docker::API::InvalidRequestBody, [:Name, :CheckDuplicate, :Driver, :Internal, :Attachable, :Ingress, :IPAM, :EnableIPv6, :Options, :Labels], body
                 @connection.request(method: :post, path: build_path(["create"]), headers: {"Content-Type": "application/json"}, body: body.to_json)
             end
 
@@ -22,17 +19,14 @@ module Docker
             end
 
             def prune params = {}
-                validate Docker::API::InvalidParameter, [:filters], params
                 @connection.post(build_path(["prune"], params))
             end
 
             def connect name, body = {}
-                validate Docker::API::InvalidRequestBody, [:Container, :EndpointConfig], body
                 @connection.request(method: :post, path: build_path([name, "connect"]), headers: {"Content-Type": "application/json"}, body: body.to_json)
             end
 
             def disconnect name, body = {}
-                validate Docker::API::InvalidRequestBody, [:Container, :Force], body
                 @connection.request(method: :post, path: build_path([name, "disconnect"]), headers: {"Content-Type": "application/json"}, body: body.to_json)
             end
 

data/lib/docker/api/node.rb

@@ -3,18 +3,14 @@ module Docker
         class Node < Docker::API::Base
 
             def list params = {}
-                validate Docker::API::InvalidParameter, [:filters], params
                 @connection.get(build_path("/nodes", params))
             end
 
             def update name, params = {}, body = {}
-                validate Docker::API::InvalidParameter, [:version], params
-                validate Docker::API::InvalidRequestBody, [:Name, :Labels, :Role, :Availability], body
                 @connection.request(method: :post, path: build_path("nodes/#{name}/update", params), headers: {"Content-Type": "application/json"}, body: body.to_json)
             end
 
             def delete name, params = {}
-                validate Docker::API::InvalidParameter, [:force], params
                 @connection.delete(build_path("/nodes/#{name}", params))
             end
 

data/lib/docker/api/plugin.rb

@@ -11,7 +11,6 @@ class Docker::API::Plugin < Docker::API::Base
     #
     # @param params [Hash]: Parameters that are appended to the URL.
     def list params = {}
-        validate Docker::API::InvalidParameter, [:filters], params
         @connection.get(build_path("/plugins", params))
     end
 
@@ -23,7 +22,6 @@ class Docker::API::Plugin < Docker::API::Base
     #
     # @param params [Hash]: Parameters that are appended to the URL.
     def privileges params = {}
-        validate Docker::API::InvalidParameter, [:remote], params
         @connection.get(build_path("/plugins/privileges", params))
     end
 
@@ -41,7 +39,6 @@ class Docker::API::Plugin < Docker::API::Base
     #
     # @param authentication [Hash]: Authentication parameters.
     def install params = {}, privileges = [], authentication = {}
-        validate Docker::API::InvalidParameter, [:remote, :name], params
         headers = {"Content-Type": "application/json"}
         headers.merge!({"X-Registry-Auth" => Base64.urlsafe_encode64(authentication.to_json.to_s)}) if authentication.keys.size > 0
         @connection.request(method: :post, path: build_path("/plugins/pull", params), headers: headers, body: privileges.to_json )
@@ -68,7 +65,6 @@ class Docker::API::Plugin < Docker::API::Base
     #
     # @param params [Hash]: Parameters that are appended to the URL.
     def remove name, params = {}
-        validate Docker::API::InvalidParameter, [:force], params
         @connection.delete(build_path("/plugins/#{name}",params))
     end
 
@@ -82,7 +78,6 @@ class Docker::API::Plugin < Docker::API::Base
     #
     # @param params [Hash]: Parameters that are appended to the URL.
     def enable name, params = {}
-        validate Docker::API::InvalidParameter, [:timeout], params
         @connection.post(build_path("/plugins/#{name}/enable", params))
     end
 
@@ -111,7 +106,6 @@ class Docker::API::Plugin < Docker::API::Base
     #
     # @param authentication [Hash]: Authentication parameters.
     def upgrade name, params = {}, privileges = [], authentication = {}
-        validate Docker::API::InvalidParameter, [:remote], params
         headers = {"Content-Type": "application/json"}
         headers.merge!({"X-Registry-Auth" => Base64.urlsafe_encode64(authentication.to_json.to_s)}) if authentication.keys.size > 0
         @connection.request(method: :post, path: build_path("/plugins/#{name}/upgrade", params), headers: headers, body: privileges.to_json )

data/lib/docker/api/secret.rb

@@ -13,7 +13,6 @@ class Docker::API::Secret < Docker::API::Base
     #
     # @param params [Hash]: Parameters that are appended to the URL.
     def list params = {}
-        validate Docker::API::InvalidParameter, [:filters], params
         @connection.get(build_path("/secrets",params))
     end
 
@@ -25,7 +24,6 @@ class Docker::API::Secret < Docker::API::Base
     #
     # @param body [Hash]: Request body to be sent as json.
     def create body = {}
-        validate Docker::API::InvalidRequestBody, [:Name, :Labels, :Data, :Driver, :Templating], body
         @connection.request(method: :post, path: "/secrets/create", headers: {"Content-Type": "application/json"}, body: body.to_json)
     end
 
@@ -52,8 +50,6 @@ class Docker::API::Secret < Docker::API::Base
     #
     # @param body [Hash]: Request body to be sent as json.
     def update name, params = {}, body = {}
-        validate Docker::API::InvalidParameter, [:version], params
-        validate Docker::API::InvalidRequestBody, [:Name, :Labels, :Data, :Driver, :Templating], body
         @connection.request(method: :post, path: build_path("/secrets/#{name}/update",params), headers: {"Content-Type": "application/json"}, body: body.to_json)
     end
 

data/lib/docker/api/service.rb

@@ -13,7 +13,6 @@ class Docker::API::Service < Docker::API::Base
     #
     # @param params [Hash]: Parameters that are appended to the URL.
     def list params = {}
-        validate Docker::API::InvalidParameter, [:filters], params
         @connection.get(build_path("/services", params))
     end
 
@@ -27,7 +26,6 @@ class Docker::API::Service < Docker::API::Base
     #
     # @param authentication [Hash]: Authentication parameters.
     def create body = {}, authentication = {}
-        validate Docker::API::InvalidRequestBody, [:Name, :Labels, :TaskTemplate, :Mode, :UpdateConfig, :RollbackConfig, :Networks, :EndpointSpec], body
         headers = {"Content-Type": "application/json"}
         headers.merge!({"X-Registry-Auth" => Base64.urlsafe_encode64(authentication.to_json.to_s)}) if authentication.keys.size > 0
         @connection.request(method: :post, path: "/services/create", headers: headers, body: body.to_json)
@@ -48,8 +46,6 @@ class Docker::API::Service < Docker::API::Base
     # @param authentication [Hash]:  Authentication parameters.
     def update name, params = {}, body = {}, authentication = {}
         # view https://github.com/docker/swarmkit/issues/1394#issuecomment-240850719
-        validate Docker::API::InvalidParameter, [:version, :registryAuthFrom, :rollback], params
-        validate Docker::API::InvalidRequestBody, [:Name, :Labels, :TaskTemplate, :Mode, :UpdateConfig, :RollbackConfig, :Networks, :EndpointSpec], body
         headers = {"Content-Type": "application/json"}
         headers.merge!({"X-Registry-Auth" => Base64.urlsafe_encode64(authentication.to_json.to_s)}) if authentication.keys.size > 0
         @connection.request(method: :post, path: build_path("/services/#{name}/update", params), headers: headers, body: body.to_json)
@@ -65,7 +61,6 @@ class Docker::API::Service < Docker::API::Base
     #
     # @param params [Hash]: Parameters that are appended to the URL. 
     def details name, params = {}
-        validate Docker::API::InvalidParameter, [:insertDefaults], params
         @connection.get(build_path("/services/#{name}", params))
     end
 
@@ -81,7 +76,6 @@ class Docker::API::Service < Docker::API::Base
     #
     # @param params [Hash]: Parameters that are appended to the URL. 
     def logs name, params = {}
-        validate Docker::API::InvalidParameter, [:details, :follow, :stdout, :stderr, :since, :timestamps, :tail], params
         @connection.get(build_path("/services/#{name}/logs", params))
     end
 

data/lib/docker/api/swarm.rb

@@ -3,13 +3,10 @@ module Docker
         class Swarm < Docker::API::Base
 
             def init body = {}
-                validate Docker::API::InvalidRequestBody, [:ListenAddr, :AdvertiseAddr, :DataPathAddr, :DataPathPort, :DefaultAddrPool, :ForceNewCluster, :SubnetSize, :Spec], body
                 @connection.request(method: :post, path: build_path("/swarm/init"), headers: {"Content-Type": "application/json"}, body: body.to_json)
             end
 
             def update params = {}, body = {}
-                validate Docker::API::InvalidParameter, [:version, :rotateWorkerToken, :rotateManagerToken, :rotateManagerUnlockKey], params
-                validate Docker::API::InvalidRequestBody, [:Name, :Labels, :Orchestration, :Raft, :Dispatcher, :CAConfig, :EncryptionConfig, :TaskDefaults], body
                 @connection.request(method: :post, path: build_path("/swarm/update", params), headers: {"Content-Type": "application/json"}, body: body.to_json)
             end
 
@@ -22,17 +19,14 @@ module Docker
             end
 
             def unlock body = {}
-                validate Docker::API::InvalidRequestBody, [:UnlockKey], body
                 @connection.request(method: :post, path: build_path("/swarm/unlock"), headers: {"Content-Type": "application/json"}, body: body.to_json)
             end
 
             def join body = {}
-                validate Docker::API::InvalidRequestBody, [:ListenAddr, :AdvertiseAddr, :DataPathAddr, :RemoteAddrs, :JoinToken], body
                 @connection.request(method: :post, path: build_path("/swarm/join"), headers: {"Content-Type": "application/json"}, body: body.to_json)
             end
 
             def leave params = {}
-                validate Docker::API::InvalidParameter, [:force], params
                 @connection.post(build_path("/swarm/leave", params))
             end
 

data/lib/docker/api/system.rb

@@ -4,12 +4,10 @@ module Docker
         class System < Docker::API::Base
 
             def auth body = {}
-                validate Docker::API::InvalidRequestBody, [:username, :password, :email, :serveraddress, :identitytoken], body
                 @connection.request(method: :post, path: "/auth", headers: { "Content-Type" => "application/json" }, body: body.to_json)
             end
 
             def events params = {}
-                validate Docker::API::InvalidParameter, [:since, :until, :filters], params
                 @connection.request(method: :get, path: build_path("/events", params), response_block: lambda { |chunk, remaining_bytes, total_bytes| puts chunk.inspect } )
             end
 

data/lib/docker/api/task.rb

@@ -13,7 +13,6 @@ class Docker::API::Task < Docker::API::Base
     #
     # @param params [Hash]: Parameters that are appended to the URL.
     def list params = {}
-        validate Docker::API::InvalidParameter, [:filters], params
         @connection.get(build_path("/tasks",params))
     end
 
@@ -40,7 +39,6 @@ class Docker::API::Task < Docker::API::Base
     #
     # @param params (Hash) : Parameters that are appended to the URL.
     def logs name, params = {}
-        validate Docker::API::InvalidParameter, [:details, :follow, :stdout, :stderr, :since, :timestamps, :tail], params
         @connection.get(build_path("/tasks/#{name}/logs", params))
     end
 end

data/lib/docker/api/version.rb

@@ -1,6 +1,6 @@
 module Docker
   module API
-    GEM_VERSION = "0.12.0"
+    GEM_VERSION = "0.13.0"
 
     API_VERSION = "1.40"
 

data/lib/docker/api/volume.rb

@@ -3,7 +3,6 @@ module Docker
         class Volume < Docker::API::Base
 
             def list params = {}
-                validate Docker::API::InvalidParameter, [:filters], params
                 @connection.get(build_path("/volumes", params))
             end
 
@@ -12,17 +11,14 @@ module Docker
             end
 
             def create body = {}
-                validate Docker::API::InvalidRequestBody, [:Name, :Driver, :DriverOpts, :Labels], body
                 @connection.request(method: :post, path: build_path(["create"]), headers: {"Content-Type": "application/json"}, body: body.to_json)
             end
 
             def remove name, params = {}
-                validate Docker::API::InvalidParameter, [:force], params
                 @connection.delete(build_path([name]))
             end
 
             def prune params = {}
-                validate Docker::API::InvalidParameter, [:filters], params
                 @connection.post(build_path(["prune"], params))
             end
 

data/lib/dockerapi.rb

@@ -1,5 +1,7 @@
 require "excon"
 require "json"
+require "base64"
+require "fileutils"
 
 require "docker/api/version"
 require "docker/api/error"
@@ -22,6 +24,140 @@ require "docker/api/plugin"
 
 module Docker
   module API
+
+    PRINT_TO_STDOUT = true
+
+    VALID_PARAMS = {
+      "Docker::API::Image" => {
+        "build" => [:dockerfile, :t, :extrahosts, :remote, :q, :nocache, :cachefrom, :pull, :rm, :forcerm, :memory, :memswap, :cpushares, :cpusetcpus, :cpuperiod, :cpuquota, :buildargs, :shmsize, :squash, :labels, :networkmode, :platform, :target, :outputs],
+        "prune" => [:filters],
+        "list" => [:all, :filters, :digests],
+        "search" => [:term, :limit, :filters],
+        "tag" => [:repo, :tag],
+        "remove" => [:force, :noprune],
+        "import" => [:quiet],
+        "push" => [:tag],
+        "commit" => [:container, :repo, :tag, :comment, :author, :pause, :changes],
+        "create" => [:fromImage, :fromSrc, :repo, :tag, :message, :platform],
+        "delete_cache" => [:all, "keep-storage", :filters]
+      },
+      "Docker::API::Container" => {
+        "list" => [:all, :limit, :size, :filters],
+        "details" => [:size],
+        "top" => [:ps_args],
+        "start" => [:detachKeys],
+        "stop" => [:t],
+        "restart" => [:t],
+        "kill" => [:signal],
+        "wait" => [:condition],
+        "rename" => [:name],
+        "resize" => [:w, :h],
+        "prune" => [:filters],
+        "remove" => [:v, :force, :link],
+        "logs" => [:follow, :stdout, :stderr, :since, :until, :timestamps, :tail],
+        "attach" => [:detachKeys, :logs, :stream, :stdin, :stdout, :stderr],
+        "stats" => [:stream],
+        "archive" => [:path, :noOverwriteDirNonDir, :copyUIDGID],
+        "create" => [:name]
+      },
+      "Docker::API::Volume" => {
+        "list" => [:filters],
+        "remove" => [:force],
+        "prune" => [:filters]
+      },
+      "Docker::API::Network" => {
+        "list" => [:filters],
+        "details" => [:verbose, :scope],
+        "prune" => [:filters]
+      },
+      "Docker::API::System" => {
+        "events" => [:since, :until, :filters]
+      },
+      "Docker::API::Exec" => {
+        "resize" => [:w, :h]
+      },
+      "Docker::API::Swarm" => {
+        "leave" => [:force],
+        "update" => [:version, :rotateWorkerToken, :rotateManagerToken, :rotateManagerUnlockKey]
+      },
+      "Docker::API::Node" => {
+        "list" => [:filters],
+        "update" => [:version],
+        "delete" => [:force]
+      },
+      "Docker::API::Service" => {
+        "list" => [:filters],
+        "update" => [:version, :registryAuthFrom, :rollback],
+        "details" => [:insertDefaults],
+        "logs" => [:details, :follow, :stdout, :stderr, :since, :timestamps, :tail]
+      },
+      "Docker::API::Secret" => {
+        "list" => [:filters],
+        "update" => [:version]
+      },
+      "Docker::API::Task" => {
+        "list" => [:filters],
+        "logs" => [:details, :follow, :stdout, :stderr, :since, :timestamps, :tail]
+      },
+      "Docker::API::Plugin" => {
+        "list" => [:filters],
+        "privileges" => [:remote],
+        "install" => [:remote, :name],
+        "remove" => [:force],
+        "enable" => [:timeout],
+        "upgrade" => [:remote]
+      },
+      "Docker::API::Config" => {
+        "list" => [:filters],
+        "update" => [:version]
+      }
+    }
+
+    VALID_BODY = {
+      "Docker::API::Image" => {
+        "commit" => [: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]
+      },
+      "Docker::API::Container" => {
+        "create" => [: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],
+        "update" => [: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]
+      },
+      "Docker::API::Volume" => {
+        "create" => [:Name, :Driver, :DriverOpts, :Labels]
+      },
+      "Docker::API::Network" => {
+        "create" => [:Name, :CheckDuplicate, :Driver, :Internal, :Attachable, :Ingress, :IPAM, :EnableIPv6, :Options, :Labels],
+        "connect" => [:Container, :EndpointConfig],
+        "disconnect" => [:Container, :Force]
+      },
+      "Docker::API::System" => {
+        "auth" => [:username, :password, :email, :serveraddress, :identitytoken]
+      },
+      "Docker::API::Exec" => {
+        "create" => [:AttachStdin, :AttachStdout, :AttachStderr, :DetachKeys, :Tty, :Env, :Cmd, :Privileged, :User, :WorkingDir],
+        "start" => [:Detach, :Tty]
+      },
+      "Docker::API::Swarm" => {
+        "init" => [:ListenAddr, :AdvertiseAddr, :DataPathAddr, :DataPathPort, :DefaultAddrPool, :ForceNewCluster, :SubnetSize, :Spec],
+        "update" => [:Name, :Labels, :Orchestration, :Raft, :Dispatcher, :CAConfig, :EncryptionConfig, :TaskDefaults],
+        "unlock" => [:UnlockKey],
+        "join" => [:ListenAddr, :AdvertiseAddr, :DataPathAddr, :RemoteAddrs, :JoinToken]
+      },
+      "Docker::API::Node" => {
+        "update" => [:Name, :Labels, :Role, :Availability]
+      },
+      "Docker::API::Service" => {
+        "create" => [:Name, :Labels, :TaskTemplate, :Mode, :UpdateConfig, :RollbackConfig, :Networks, :EndpointSpec],
+        "update" => [:Name, :Labels, :TaskTemplate, :Mode, :UpdateConfig, :RollbackConfig, :Networks, :EndpointSpec]
+      },
+      "Docker::API::Secret" => {
+        "create" => [:Name, :Labels, :Data, :Driver, :Templating],
+        "update" => [:Name, :Labels, :Data, :Driver, :Templating]
+      },
+      "Docker::API::Config" => {
+        "create" => [:Name, :Labels, :Data, :Templating],
+        "update" => [:Name, :Labels, :Data, :Driver, :Templating]
+      }
+    }
     
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dockerapi
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Alysson A. Costa
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-24 00:00:00.000000000 Z
+date: 2020-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: excon