dockerapi 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39b737a07cdf35864b8be1402ca7d504c59fc854e2092762df7a9f448bb2bf24
-  data.tar.gz: d71d1894cab1f61a3713f0991d24c272f99373832bff140c962604a8d707621f
+  metadata.gz: 12366435331bd8fc215857a65d28b337f9ccb22556d8451e6f213d4fda8a5113
+  data.tar.gz: 724f52952a3f24dc664dc1b1b5cc66a75ae920b281de61b36ae74ed5431d7159
 SHA512:
-  metadata.gz: 3622c339bae6e7a93738d110a5d6eaa38dda6288abeebda35c4b376cd354b33fa2b1595bf53fc2da04cf8a5e6f8e78a49f7cea10927afdb3fc719f119d94a8fd
-  data.tar.gz: d40f00a1e7c913a5b005cba33182e2295da22d1631eb0fec23101d45639998391ad89829a03a51b3c197da8f69196c954fb8e70234f90175f2b7bbc410159be1
+  metadata.gz: 61ac762e369e72c7b715b2ae3c19cc9046fd25425ef865bbb723a86f79df57716dfa1c1d42720830b10f441150d96def147649921e764180c194e778589071bd
+  data.tar.gz: 9d2327454dc893fe4cf9ab5adf06619a69142dea22bad32536886552711f3f6119060f859092af4ab17285d2a740e2aa56b563d32fb367c5a55cc6183c2967dd

data/CHANGELOG.md

@@ -0,0 +1,45 @@
+# 0.2.0
+
+Add Docker::API::Image methods:
+* inspect
+* history
+* list
+* search
+* tag
+* prune
+* remove
+* export
+* import
+* push
+* commit
+* create
+* build
+* delete_cache
+
+Add Docker::API::System.auth (untested) for basic authentication
+
+# 0.1.0
+
+Add Docker::API::Container methods:
+* list
+* inspect
+* top
+* changes
+* start
+* stop
+* restart
+* kill
+* wait
+* update
+* rename
+* resize
+* prune
+* pause
+* unpause
+* remove
+* logs
+* attach
+* create
+* stats
+* export
+* archive

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    dockerapi (0.1.0)
-      excon
+    dockerapi (0.2.0)
+      excon (~> 0.74.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -20,6 +20,76 @@ Or install it yourself as:
 
 ## Usage
 
+### Images
+
+```ruby
+# Pull from a public repository
+Docker::API::Image.create( fromImage: "nginx:latest" )
+
+# Pull from a private repository
+Docker::API::Image.create( {fromImage: "private/repo:tag"}, {username: "janedoe", password: "password"} )
+
+# Create image from local tar file
+Docker::API::Image.create( fromSrc: "/path/to/file.tar", repo: "repo:tag" )
+
+# Create image from remote tar file
+Docker::API::Image.create( fromSrc: "https://url.to/file.tar", repo: "repo:tag" )
+
+# List images
+Docker::API::Image.list
+Docker::API::Image.list( all:true )
+
+# Inspect image
+Docker::API::Image.inspect("image")
+
+# History
+Docker::API::Image.history("image")
+
+# Search image
+Docker::API::Image.search(term: "busybox", limit: 2)
+Docker::API::Image.search(term: "busybox", filters: {"is-automated": {"true": true}})
+Docker::API::Image.search(term: "busybox", filters: {"is-official": {"true": true}})
+
+# Tag image
+Docker::API::Image.tag("current:tag", repo: "new:tag") # or
+Docker::API::Image.tag("current:tag", repo: "new", tag: "tag")
+
+# Push image
+Docker::API::Image.push("repo:tag") # to dockerhub
+Docker::API::Image.push("localhost:5000/repo:tag") # to local registry
+Docker::API::Image.push("private/repo", {tag: "tag"}, {username: "janedoe", password: "password"} # to private repository
+
+# Remove container
+Docker::API::Image.remove("image")
+Docker::API::Image.remove("image", force: true)
+
+# Remove unsued images (prune)
+Docker::API::Image.prune(filters: {dangling: {"false": true}})
+
+# Create image from a container (commit)
+Docker::API::Image.commit(container: container, repo: "my/image", tag: "latest", comment: "Comment from commit", author: "dockerapi", pause: false )
+
+# Build image from a local tar file
+Docker::API::Image.build("/path/to/file.tar")
+
+# Build image from a remote tar file
+Docker::API::Image.build(nil, remote: "https://url.to/file.tar")
+
+# Build image from a remote Dockerfile
+Docker::API::Image.build(nil, remote: "https://url.to/Dockerfile")
+
+# Delete builder cache
+Docker::API::Image.delete_cache
+
+# Export repo
+Docker::API::Image.export("repo:tag", "~/exported_image.tar")
+
+# Import repo
+Docker::API::Image.import("/path/to/file.tar")
+```
+
+### Containers 
+
 Let's test a Nginx container
 
 ```ruby
@@ -84,7 +154,7 @@ Docker::API::Container.prune
 
 ### Requests
 
-Requests should work as described in Docker API documentation.
+Requests should work as described in [Docker API documentation](https://docs.docker.com/engine/api/v1.40). Check it out to customize your requests.
 
 ### Response
 
@@ -105,8 +175,8 @@ WIP: Work In Progress
 
 | Class | Tests | Implementation | Refactoring |
 |---|---|---|---|
-| Container | WIP | WIP | NS |
-| Image | NS | NS | NS |
+| Container | Ok | Ok | NS |
+| Image | Ok | Ok | NS |
 | Volume | NS | NS | NS |
 | Network | NS | NS | NS |
 | System | NS | NS | NS |

data/dockerapi.gemspec

@@ -14,16 +14,16 @@ Gem::Specification.new do |spec|
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/nu12/dockerapi.git"
-  #spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  spec.metadata["changelog_uri"] = "https://github.com/nu12/dockerapi/blob/master/CHANGELOG.md"
 
   # 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)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|resources)/}) }
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "excon"
+  spec.add_dependency("excon", "~> 0.74.0")
 end

data/lib/docker/api/base.rb

@@ -0,0 +1,36 @@
+module Docker
+    module API
+        class Base
+            
+            private
+
+            def self.base_path
+                "/"
+            end
+
+            def self.connection
+                Docker::API::Connection.instance
+            end
+
+            def self.validate error, permitted_keys, params
+                not_permitted = params.keys.map(&:to_s) - permitted_keys.map(&:to_s)
+                raise error if not_permitted.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 self.hash_to_params h
+                p = []
+                h.each { |k,v| p.push( v.is_a?(Hash) ? "#{k}=#{v.to_json}" : "#{k}=#{v}") }
+                p.join("&").gsub(" ","")
+            end
+
+            def self.build_path path, params = {}
+                p = path.is_a?(Array) ? ([base_path] << path).join("/") : path
+                params.size > 0 ? [p, hash_to_params(params)].join("?") : p
+            end
+
+        end
+    end
+end

data/lib/docker/api/connection.rb

@@ -6,30 +6,16 @@ module Docker
         class Connection
             include Singleton
 
-            attr_reader(:connection)
-
-            def get path
-                r = @connection.get(path: path)
-                #p r
-                r
+            [:get, :post, :head, :delete, :put].each do | method |
+                define_method(method) { | path | self.request(method: method, path: path) }
             end
 
             def post(path, body = nil)
-                if body
-                    r = @connection.post(path: path, headers: { "Content-Type" => "application/json" }, body: body.to_json)
-                else
-                    r = @connection.post(path: path)
-                end
-                #p r
-                r
-            end
-
-            def head(path)
-                @connection.head(path: path)
+                self.request(method: :post, path: path, headers: { "Content-Type" => "application/json" }, body: body.to_json)
             end
 
-            def delete path
-                @connection.delete(path: path)
+            def request params
+                @connection.request(params)
             end
             
             private

data/lib/docker/api/container.rb

@@ -3,121 +3,123 @@ module Docker
         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
+        class Container < Docker::API::Base
 
-            @@base_path = "/containers"
+            def self.base_path
+                "/containers"
+            end
 
             def self.list params = {}
-                self.validate Docker::API::InvalidParameter, [:all, :limit, :size, :filters], params
-                Docker::API::Connection.instance.get(self.build_path(["json"], params))
+                validate Docker::API::InvalidParameter, [:all, :limit, :size, :filters], params
+                connection.get(build_path(["json"], params))
             end
 
             def self.inspect name, params = {}
-                self.validate Docker::API::InvalidParameter, [:size], params
-                Docker::API::Connection.instance.get(self.build_path([name, "json"], params))
+                validate Docker::API::InvalidParameter, [:size], params
+                connection.get(build_path([name, "json"], params))
             end
 
             def self.top name, params = {}
-                self.validate Docker::API::InvalidParameter, [:ps_args], params
-                Docker::API::Connection.instance.get(self.build_path([name, "top"], params))
+                validate Docker::API::InvalidParameter, [:ps_args], params
+                connection.get(build_path([name, "top"], params))
             end
 
             def self.changes name
-                Docker::API::Connection.instance.get(self.build_path([name, "changes"]))
+                connection.get(build_path([name, "changes"]))
             end
 
             def self.start name, params = {}
-                self.validate Docker::API::InvalidParameter, [:detachKeys], params
-                Docker::API::Connection.instance.post(self.build_path([name, "start"], params))
+                validate Docker::API::InvalidParameter, [:detachKeys], params
+                connection.post(build_path([name, "start"], params))
             end
 
             def self.stop name, params = {}
-                self.validate Docker::API::InvalidParameter, [:t], params
-                Docker::API::Connection.instance.post(self.build_path([name, "stop"], params))
+                validate Docker::API::InvalidParameter, [:t], params
+                connection.post(build_path([name, "stop"], params))
             end
 
             def self.restart name, params = {}
-                self.validate Docker::API::InvalidParameter, [:t], params
-                Docker::API::Connection.instance.post(self.build_path([name, "restart"], params))
+                validate Docker::API::InvalidParameter, [:t], params
+                connection.post(build_path([name, "restart"], params))
             end
 
             def self.kill name, params = {}
-                self.validate Docker::API::InvalidParameter, [:signal], params
-                Docker::API::Connection.instance.post(self.build_path([name, "kill"], params))
+                validate Docker::API::InvalidParameter, [:signal], params
+                connection.post(build_path([name, "kill"], params))
             end
 
             def self.wait name, params = {}
-                self.validate Docker::API::InvalidParameter, [:condition], params
-                Docker::API::Connection.instance.post(self.build_path([name, "wait"], params))
+                validate Docker::API::InvalidParameter, [:condition], params
+                connection.post(build_path([name, "wait"], params))
             end
 
             def self.update name, body = {}
-                self.validate Docker::API::InvalidRequestBody, Docker::API::UpdateBody, body
-                Docker::API::Connection.instance.post(self.build_path([name, "update"]), body)
+                validate Docker::API::InvalidRequestBody, Docker::API::UpdateBody, body
+                connection.post(build_path([name, "update"]), body)
             end
 
             def self.rename name, params = {}
-                self.validate Docker::API::InvalidParameter, [:name], params
-                Docker::API::Connection.instance.post(self.build_path([name, "rename"], params))
+                validate Docker::API::InvalidParameter, [:name], params
+                connection.post(build_path([name, "rename"], params))
             end
 
             def self.resize name, params = {}
-                self.validate Docker::API::InvalidParameter, [:w, :h], params
-                Docker::API::Connection.instance.post(self.build_path([name, "resize"], params))
+                validate Docker::API::InvalidParameter, [:w, :h], params
+                connection.post(build_path([name, "resize"], params))
             end
 
             def self.prune params = {}
-                self.validate Docker::API::InvalidParameter, [:filters], params
-                Docker::API::Connection.instance.post(self.build_path(["prune"], params))
+                validate Docker::API::InvalidParameter, [:filters], params
+                connection.post(build_path(["prune"], params))
             end
 
             def self.pause name
-                Docker::API::Connection.instance.post(self.build_path([name, "pause"]))
+                connection.post(build_path([name, "pause"]))
             end
 
             def self.unpause name
-                Docker::API::Connection.instance.post(self.build_path([name, "unpause"]))
+                connection.post(build_path([name, "unpause"]))
             end
 
             def self.remove name, params = {}
-                self.validate Docker::API::InvalidParameter, [:v, :force, :link], params
-                Docker::API::Connection.instance.delete(self.build_path([name]))
+                validate Docker::API::InvalidParameter, [:v, :force, :link], params
+                connection.delete(build_path([name]))
             end
 
             def self.logs name, params = {}
-                self.validate Docker::API::InvalidParameter, [:follow, :stdout, :stderr, :since, :until, :timestamps, :tail], params
+                validate Docker::API::InvalidParameter, [:follow, :stdout, :stderr, :since, :until, :timestamps, :tail], params
                 
-                path = self.build_path([name, "logs"], params)
+                path = build_path([name, "logs"], params)
 
                 if params[:follow] == true || params[:follow] == 1
-                    Docker::API::Connection.instance.connection.get(path: path , response_block: lambda { |chunk, remaining_bytes, total_bytes| puts chunk.inspect })
+                    connection.request(method: :get, path: path , response_block: lambda { |chunk, remaining_bytes, total_bytes| puts chunk.inspect })
                 else
-                    Docker::API::Connection.instance.get(path)
+                    connection.get(path)
                 end
             end
 
             def self.attach name, params = {}
-                self.validate Docker::API::InvalidParameter, [:detachKeys, :logs, :stream, :stdin, :stdout, :stderr], params
-                Docker::API::Connection.instance.connection.request(method: :post, path: self.build_path([name, "attach"], params) , response_block: lambda { |chunk, remaining_bytes, total_bytes| puts chunk.inspect })
+                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 self.create params = {}, body = {}
-                self.validate Docker::API::InvalidParameter, [:name], params
-                self.validate Docker::API::InvalidRequestBody, Docker::API::CreateBody, body
-                Docker::API::Connection.instance.post(self.build_path(["create"], params), body)
+                validate Docker::API::InvalidParameter, [:name], params
+                validate Docker::API::InvalidRequestBody, Docker::API::CreateBody, body
+                connection.post(build_path(["create"], params), body)
             end
 
             def self.stats name, params = {}
-                self.validate Docker::API::InvalidParameter, [:stream], params
-                path = self.build_path([name, "stats"], params)
+                validate Docker::API::InvalidParameter, [:stream], params
+                path = build_path([name, "stats"], params)
 
                 if params[:stream] == true || params[:stream] == 1
                     streamer = lambda do |chunk, remaining_bytes, total_bytes|
                         puts chunk
                     end
-                    Docker::API::Connection.instance.connection.get(path: path , response_block: streamer)
+                    connection.request(method: :get, path: path , response_block: streamer)
                 else
-                    Docker::API::Connection.instance.get(path)
+                    connection.get(path)
                 end
             end
 
@@ -128,56 +130,30 @@ module Docker
                     streamer = lambda do |chunk, remaining_bytes, total_bytes|
                         file.write(chunk)
                     end
-                    response = Docker::API::Connection.instance.connection.get(path: self.build_path([name, "export"]) , response_block: streamer)
+                    response = connection.request(method: :get, path: build_path([name, "export"]) , response_block: streamer)
                     file.close
                 end
                 response
             end
 
             def self.archive name, file, params = {}
-                self.validate Docker::API::InvalidParameter, [:path, :noOverwriteDirNonDir, :copyUIDGID], 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")
-                    response = Docker::API::Connection.instance.connection.put(path: self.build_path([name, "archive"], params) , request_block: lambda { file.read(Excon.defaults[:chunk_size]).to_s} )
+                    response = connection.request(method: :put, path: build_path([name, "archive"], params) , request_block: lambda { file.read(Excon.defaults[:chunk_size]).to_s} )
                     file.close
                 rescue Errno::ENOENT # File doesnt exist, get it from container
-                    response = Docker::API::Connection.instance.head(self.build_path([name, "archive"], params))
+                    response = connection.head(build_path([name, "archive"], params))
                     if response.status == 200 # file exists in container
                         file = File.open( File.expand_path( file ) , "wb")
-                        response = Docker::API::Connection.instance.connection.get(path: self.build_path([name, "archive"], params) , response_block: lambda { |chunk, remaining_bytes, total_bytes| file.write(chunk) })
+                        response = connection.request(method: :get, path: build_path([name, "archive"], params) , response_block: lambda { |chunk, remaining_bytes, total_bytes| file.write(chunk) })
                         file.close
                     end
                 end
                 response
             end
-      
-            private
-
-            def self.validate error, permitted_keys, params
-                not_permitted = params.keys - permitted_keys
-                raise error if not_permitted.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 self.hash_to_params h
-                p = []
-                h.each do |k,v|
-                    if v.is_a?(Hash)
-                        p << "#{k}=#{v.to_json}"
-                    else
-                        p << "#{k}=#{v}"
-                    end
-                end
-                p.join("&").gsub(" ","")
-            end
 
-            def self.build_path path, params = {}
-                p = ([@@base_path] << path).join("/")
-                params.size > 0 ? [p, self.hash_to_params(params)].join("?") : p
-            end
         end
     end
 end

data/lib/docker/api/image.rb

@@ -1,23 +1,139 @@
+require "base64"
+require "json"
+require 'fileutils'
 module Docker
     module API
-        class Image
+        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
 
-            @@base_path = "/images"
+            def self.base_path
+                "/images"
+            end
+
+            def self.inspect name
+                connection.get(build_path([name, "json"]))
+            end
+
+            def self.history name
+                connection.get(build_path([name, "history"]))
+            end
+
+            def self.list params = {}
+                validate Docker::API::InvalidParameter, [:all, :filters, :digests], params
+                connection.get(build_path(["json"], params)) 
+            end
+
+            def self.search params = {}
+                validate Docker::API::InvalidParameter, [:term, :limit, :filters], params
+                connection.get(build_path(["search"], params)) 
+            end
+
+            def self.tag name, params = {}
+                validate Docker::API::InvalidParameter, [:repo, :tag], params
+                connection.post(build_path([name, "tag"], params))
+            end
+
+            def self.prune params = {}
+                validate Docker::API::InvalidParameter, [:filters], params
+                connection.post(build_path(["prune"], params))
+            end
 
-            def self.create query_params = {}
-                Docker::API::Connection.instance.post(self.build_path(["create"], query_params))
+            def self.remove name, params = {}
+                validate Docker::API::InvalidParameter, [:force, :noprune], params
+                connection.delete(build_path([name], params))
             end
 
-            def self.remove name, query_params = {}
-                Docker::API::Connection.instance.delete(self.build_path([name],  query_params))
+            def self.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
 
-            private
+            def self.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 self.push name, params = {}, authentication = {}
+                validate Docker::API::InvalidParameter, [:tag], params
+
+                if authentication.keys.size > 0
+                    auth = Docker::API::System.auth(authentication)
+                    return auth unless [200, 204].include? auth.status
+                    connection.request(method: :post, path: build_path([name, "push"], params), headers: { "X-Registry-Auth" => Base64.encode64(authentication.to_json.to_s).chomp } )
+                else
+                    connection.post(build_path([name, "push"], params))
+                end
+            end
 
-            def self.build_path path, params = {}
-                p = ([@@base_path] << path).join("/")
-                params.size > 0 ? [p, params.map {|k,v| "#{k}=#{v}"}.join("&")].join("?") : p
+            def self.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.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 self.create params = {}, authentication = {}
+                validate Docker::API::InvalidParameter, [:fromImage, :fromSrc, :repo, :tag, :message, :platform], params
+                
+                if authentication.keys.size > 0
+                    auth = Docker::API::System.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 self.build path, params = {}, authentication = {}
+                raise Docker::API::InvalidRequestBody 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.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 self.delete_cache params = {}
+                validate Docker::API::InvalidParameter, [:all, "keep-storage", :filters], params
+                connection.post(build_path("/build/prune", params))
+            end
+
         end
 
     end

data/lib/docker/api/system.rb

@@ -0,0 +1,12 @@
+require "json"
+module Docker
+    module API
+        class System < Docker::API::Base
+            
+            def self.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
+        end
+    end
+end

data/lib/docker/api/version.rb

@@ -1,6 +1,6 @@
 module Docker
   module API
-    GEM_VERSION = "0.1.0"
+    GEM_VERSION = "0.2.0"
 
     API_VERSION = "1.40"
 

data/lib/dockerapi.rb

@@ -2,8 +2,10 @@ require "docker/api/version"
 
 require "docker/api/error"
 require "docker/api/connection"
+require "docker/api/base"
 require "docker/api/container"
 require "docker/api/image"
+require "docker/api/system"
 
 module Docker
   module API

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: dockerapi
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Alysson A. Costa
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-22 00:00:00.000000000 Z
+date: 2020-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: excon
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.74.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.74.0
 description: Interact directly with Docker API from Ruby code.
 email:
 - alysson.avila.costa@gmail.com
@@ -34,6 +34,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -42,10 +43,12 @@ files:
 - bin/console
 - bin/setup
 - dockerapi.gemspec
+- lib/docker/api/base.rb
 - lib/docker/api/connection.rb
 - lib/docker/api/container.rb
 - lib/docker/api/error.rb
 - lib/docker/api/image.rb
+- lib/docker/api/system.rb
 - lib/docker/api/version.rb
 - lib/dockerapi.rb
 homepage: https://github.com/nu12/dockerapi
@@ -54,6 +57,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/nu12/dockerapi
   source_code_uri: https://github.com/nu12/dockerapi.git
+  changelog_uri: https://github.com/nu12/dockerapi/blob/master/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths: