dockerapi 0.1.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39b737a07cdf35864b8be1402ca7d504c59fc854e2092762df7a9f448bb2bf24
-  data.tar.gz: d71d1894cab1f61a3713f0991d24c272f99373832bff140c962604a8d707621f
+  metadata.gz: 90acd383975c4846ca2d6bfb91aa15d9898ce0101557ca50481f20729871ef73
+  data.tar.gz: 03d01594692f5c2093bf3e91b4f67635d2bd8e1bf0360217747ea4aa8d2c6840
 SHA512:
-  metadata.gz: 3622c339bae6e7a93738d110a5d6eaa38dda6288abeebda35c4b376cd354b33fa2b1595bf53fc2da04cf8a5e6f8e78a49f7cea10927afdb3fc719f119d94a8fd
-  data.tar.gz: d40f00a1e7c913a5b005cba33182e2295da22d1631eb0fec23101d45639998391ad89829a03a51b3c197da8f69196c954fb8e70234f90175f2b7bbc410159be1
+  metadata.gz: 56a36a3c8b73fc0a8ae02cc68bd93b6b858be21d8c9c6d033b5f1d34d581f646dbb9e77df2e0a9d216c2a835eec3bd8e1abb62ade82aa6ec818ef081b5181d5d
+  data.tar.gz: 101c74b35333664dc5573d5443f2c7d75d5c8de9a43a2f70a7a54e5bb5673091eebe31dfc9ed5845c1052f47907dc6d7873f3bbe84a5015e10f5411458993cb9

data/CHANGELOG.md

@@ -0,0 +1,93 @@
+# 0.6.0
+
+Add connection parameters specifications with connect_to in Docker::API::Connection.
+
+Add Docker::API::Exec methods:
+* create
+* start
+* resize
+* inspect
+
+# 0.5.0
+
+Add Docker::API::System methods:
+* auth
+* ping
+* info
+* version
+* events
+* df
+
+Add new response class Docker::API::Response with the following methods:
+* json
+* path
+* success?
+
+Error classes output better error messages.
+
+# 0.4.0
+
+Add Docker::API::Network methods:
+* list
+* inspect
+* create
+* remove
+* prune
+* connect
+* disconnect
+
+# 0.3.0
+
+Add Docker::API::Volume methods:
+* list
+* inspect
+* create
+* remove
+* prune
+
+
+# 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.6.0)
+      excon (~> 0.74.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -20,6 +20,75 @@ 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
+
+# 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 image
+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
@@ -82,13 +151,123 @@ Docker::API::Container.remove("nginx")
 Docker::API::Container.prune
 ```
 
+### Volumes
+
+```ruby
+# Create volume
+Docker::API::Volume.create( Name:"my-volume" )
+
+# List volumes
+Docker::API::Volume.list
+
+# Inspect volume
+Docker::API::Volume.inspect("my-volume")
+
+# Remove volume
+Docker::API::Volume.remove("my-volume")
+
+# Remove unused volumes (prune)
+Docker::API::Volume.prune
+```
+
+### Network
+
+```ruby
+# List networks
+Docker::API::Network.list
+
+# Inspect network
+Docker::API::Network.inspect("bridge")
+
+# Create network
+Docker::API::Network.create( Name:"my-network" )
+
+# Remove network
+Docker::API::Network.remove("my-network")
+
+# Remove unused network (prune)
+Docker::API::Network.prune
+
+# Connect container to a network
+Docker::API::Network.connect( "my-network", Container: "my-container" )
+
+# Disconnect container to a network
+Docker::API::Network.disconnect( "my-network", Container: "my-container" )
+```
+
+### System
+
+```ruby
+# Ping docker api
+Docker::API::System.ping
+
+# Docker components versions
+Docker::API::System.version
+
+# System info
+Docker::API::System.info
+
+# System events (stream)
+Docker::API::System.events(until: Time.now.to_i)
+
+# Data usage information
+Docker::API::System.df
+```
+
+### Exec
+
+```ruby
+# Create exec instance, get generated exec ID
+response = Docker::API::Exec.create(container, AttachStdout:true, Cmd: ["ls", "-l"])
+id = response.json["Id"]
+
+# Execute the command, stream from Stdout is stored in response data
+response = Docker::API::Exec.start(id)
+print response.data[:stream]
+
+# Inspect exec instance
+Docker::API::Exec.inspect(id)
+```
+
 ### 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
 
-All requests return a Excon::Response object.
+All requests return a response class that inherits from Excon::Response. Available attribute readers and methods include: `status`, `data`, `body`, `headers`, `json`, `path`, `success?`.
+
+```ruby
+response = Docker::API::Image.create(fromImage: "busybox:latest")
+
+response
+=> #<Docker::API::Response:0x000055bb390b35c0 ... >
+
+response.status
+=> 200
+
+response.data
+=> {:body=>"...", :cookies=>[], :host=>nil, :headers=>{ ... }, :path=>"/images/create?fromImage=busybox:latest", :port=>nil, :status=>200, :status_line=>"HTTP/1.1 200 OK\r\n", :reason_phrase=>"OK"}
+
+response.headers
+=> {"Api-Version"=>"1.40", "Content-Type"=>"application/json", "Docker-Experimental"=>"false", "Ostype"=>"linux", "Server"=>"Docker/19.03.11 (linux)", "Date"=>"Mon, 29 Jun 2020 16:10:06 GMT"}
+
+response.body
+=> "{\"status\":\"Pulling from library/busybox\" ... "
+
+response.json
+=> [{:status=>"Pulling from library/busybox", :id=>"latest"}, {:status=>"Pulling fs layer", :progressDetail=>{}, :id=>"76df9210b28c"}, ... , {:status=>"Status: Downloaded newer image for busybox:latest"}]
+
+response.path
+=> "/images/create?fromImage=busybox:latest"
+
+response.success?
+=> true
+```
+
+### Error handling
+
+`Docker::API::InvalidParameter` and `Docker::API::InvalidRequestBody` may be raised when an invalid option is passed as argument (ie: an option not described in Docker API documentation for request query parameters nor request body (json) parameters). Even if no errors were raised, consider validating the status code and/or message of the response to check if the Docker daemon has fulfilled the operation properly.
 
 ## Development
 
@@ -105,12 +284,12 @@ WIP: Work In Progress
 
 | Class | Tests | Implementation | Refactoring |
 |---|---|---|---|
-| Container | WIP | WIP | NS |
-| Image | NS | NS | NS |
-| Volume | NS | NS | NS |
-| Network | NS | NS | NS |
-| System | NS | NS | NS |
-| Exec | NS | NS | NS |
+| Container | Ok | Ok | NS |
+| Image | Ok | Ok | NS |
+| Volume | Ok | Ok | NS |
+| Network | Ok | Ok | NS |
+| System | Ok | Ok | NS |
+| Exec | Ok | Ok | NS |
 | Swarm | NS | NS | NS |
 | Node | NS | NS | NS |
 | Service | NS | NS | NS |
@@ -118,8 +297,8 @@ WIP: Work In Progress
 | Secret | NS | NS | NS |
 
 Misc: 
-* Improve response object
-* Improve error objects
+* ~~Improve response object~~
+* ~~Improve error objects~~
 
 ## Contributing
 

data/bin/setup

@@ -1,8 +1,22 @@
 #!/usr/bin/env bash
 set -euo pipefail
 IFS=$'\n\t'
-set -vx
-
-bundle install
+#set -vx
 
 # Do any other automated setup that you need to do here
+if [ $USER == 'root' ]
+then
+    echo "Enabling TCP port 2375 for external connection to Docker"
+    echo '{"hosts": ["tcp://0.0.0.0:2375", "unix:///var/run/docker.sock"]}' > /etc/docker/daemon.json
+    mkdir -p /etc/systemd/system/docker.service.d
+    echo '[Service]' > /etc/systemd/system/docker.service.d/override.conf
+    echo 'ExecStart=' >> /etc/systemd/system/docker.service.d/override.conf
+    echo 'ExecStart=/usr/bin/dockerd' >> /etc/systemd/system/docker.service.d/override.conf
+    systemctl daemon-reload
+    systemctl restart docker.service
+    echo "Done!"
+else
+    echo "Running bundle install"
+    bundle install
+    echo "Run this script as root for further configurations"
+fi

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, params
+                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 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

@@ -1,35 +1,23 @@
-require "excon"
 require "singleton"
-require "json"
 module Docker
     module API
         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
+                self.request(method: :post, path: path, headers: { "Content-Type" => "application/json" }, body: body.to_json)
             end
 
-            def head(path)
-                @connection.head(path: path)
+            def request params
+                Docker::API::Response.new(@connection.request(params).data)
             end
 
-            def delete path
-                @connection.delete(path: path)
+            def connect_to params
+                @connection = Excon.new(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/error.rb

@@ -1,6 +1,17 @@
 module Docker
     module API
-      class InvalidParameter < StandardError; end
-      class InvalidRequestBody < StandardError; end
+      class ValidationError < StandardError
+        def initialize permitted, unpermitted
+          super("Unpermitted options found: #{unpermitted.to_s}. Permitted are #{permitted.to_s}")
+        end
+      end
+      class Error < StandardError
+        def initialize msg = "Error without specific message"
+          super(msg)
+        end
+      end
+
+      class InvalidParameter < Docker::API::ValidationError; end
+      class InvalidRequestBody < Docker::API::ValidationError; end
     end
   end

data/lib/docker/api/exec.rb

@@ -0,0 +1,39 @@
+module Docker
+    module API
+        class Exec < Docker::API::Base
+
+            def self.base_path
+                "/exec"
+            end
+
+            def self.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 self.start name, body = {}
+                validate Docker::API::InvalidRequestBody, [:Detach, :Tty], body
+
+                stream = ""
+                response = connection.request(method: :post, 
+                    path: "/exec/#{name}/start", 
+                    headers: {"Content-Type": "application/json"},  
+                    body: body.to_json, 
+                    response_block: lambda { |chunk, remaining_bytes, total_bytes| stream += chunk.to_s.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?') }
+                )
+                response.data.merge!({stream: stream})
+                response
+            end
+
+            def self.resize name, params = {}
+                validate Docker::API::InvalidParameter, [:w, :h], params
+                connection.post(build_path([name, "resize"], params))
+            end
+
+            def self.inspect name
+                connection.get(build_path([name, "json"]))
+            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::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.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/network.rb

@@ -0,0 +1,45 @@
+module Docker
+    module API        
+        class Network < Docker::API::Base
+
+            def self.base_path
+                "/networks"
+            end
+
+            def self.list params = {}
+                validate Docker::API::InvalidParameter, [:filters], params
+                connection.get(build_path("/networks", params))
+            end
+
+            def self.inspect name, params = {}
+                validate Docker::API::InvalidParameter, [:verbose, :scope], params
+                connection.get(build_path([name], params))
+            end
+
+            def self.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
+
+            def self.remove name
+                connection.delete(build_path([name]))
+            end
+
+            def self.prune params = {}
+                validate Docker::API::InvalidParameter, [:filters], params
+                connection.post(build_path(["prune"], params))
+            end
+
+            def self.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 self.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
+
+        end
+    end
+end

data/lib/docker/api/response.rb

@@ -0,0 +1,25 @@
+module Docker
+    module API
+        class Response < Excon::Response
+            attr_reader(:json, :path)
+
+            def initialize data
+                super data
+                @json = parse_json @body
+                @path = @data[:path]
+            end
+
+            def success?
+                (200..204).include? @status
+            end
+
+            private
+
+            def parse_json data
+               return nil unless headers["Content-Type"] == "application/json"
+               return nil if data == ""
+               data.split("\r\n").size > 1 ? data.split("\r\n").map{ |e| eval(e) } : JSON.parse(data)
+            end
+        end
+    end
+end

data/lib/docker/api/system.rb

@@ -0,0 +1,33 @@
+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
+
+            def self.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
+
+            def self.ping
+                connection.get("/_ping")
+            end
+
+            def self.info
+                connection.get("/info")
+            end
+
+            def self.version
+                connection.get("/version")
+            end
+
+            def self.df
+                connection.get("/system/df")
+            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.6.0"
 
     API_VERSION = "1.40"
 

data/lib/docker/api/volume.rb

@@ -0,0 +1,34 @@
+module Docker
+    module API
+        class Volume < Docker::API::Base
+            def self.base_path
+                "/volumes"
+            end
+
+            def self.list params = {}
+                validate Docker::API::InvalidParameter, [:filters], params
+                connection.get(build_path("/volumes", params))
+            end
+
+            def self.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 self.inspect name
+                connection.get(build_path([name]))
+            end
+
+            def self.remove name, params = {}
+                validate Docker::API::InvalidParameter, [:force], params
+                connection.delete(build_path([name]))
+            end
+
+            def self.prune params = {}
+                validate Docker::API::InvalidParameter, [:filters], params
+                connection.post(build_path(["prune"], params))
+            end
+
+        end
+    end
+end

data/lib/dockerapi.rb

@@ -1,9 +1,17 @@
-require "docker/api/version"
+require "excon"
+require "json"
 
+require "docker/api/version"
 require "docker/api/error"
 require "docker/api/connection"
+require "docker/api/response"
+require "docker/api/base"
 require "docker/api/container"
 require "docker/api/image"
+require "docker/api/volume"
+require "docker/api/network"
+require "docker/api/exec"
+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.6.0
 platform: ruby
 authors:
 - Alysson A. Costa
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-22 00:00:00.000000000 Z
+date: 2020-07-03 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,11 +43,17 @@ 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/exec.rb
 - lib/docker/api/image.rb
+- lib/docker/api/network.rb
+- lib/docker/api/response.rb
+- lib/docker/api/system.rb
 - lib/docker/api/version.rb
+- lib/docker/api/volume.rb
 - lib/dockerapi.rb
 homepage: https://github.com/nu12/dockerapi
 licenses:
@@ -54,6 +61,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: