dockerapi 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90acd383975c4846ca2d6bfb91aa15d9898ce0101557ca50481f20729871ef73
-  data.tar.gz: 03d01594692f5c2093bf3e91b4f67635d2bd8e1bf0360217747ea4aa8d2c6840
+  metadata.gz: 756ada080034328ec7c5e7950d5565e6e7d3612bc92af58d9c8f89558a75f5c5
+  data.tar.gz: cba4ac000ef8e9d4374bc36be4e87dd3c2227b2fa59cc062f24ad7a06de11c52
 SHA512:
-  metadata.gz: 56a36a3c8b73fc0a8ae02cc68bd93b6b858be21d8c9c6d033b5f1d34d581f646dbb9e77df2e0a9d216c2a835eec3bd8e1abb62ade82aa6ec818ef081b5181d5d
-  data.tar.gz: 101c74b35333664dc5573d5443f2c7d75d5c8de9a43a2f70a7a54e5bb5673091eebe31dfc9ed5845c1052f47907dc6d7873f3bbe84a5015e10f5411458993cb9
+  metadata.gz: 0c6c059fa47afc4749dac18c62d61a984c2874b41046c2926d7eb884a7761ea088fef4209deaf71fe5864e5351e8e96a975f29520760ae6559209d323dd4f4b6
+  data.tar.gz: 25bad2ed4c92a2b5551d78e3a12833037623e7f26045a829b587d4136c383d7431ae7a3d17bf6b9ca139c4fcc060cbf07f15a61854a4a43f601455613174f943

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 0.7.0
+
+Major changes: Docker::API::Connection is now a regular class intead of a Singleton, allowing multiple connections to be stablished within the same program (replacing the connect_to implementation). To leverage this feature, API-related classes must be initialized and may or may not receive a Docker::API::Connection as parameter, or it'll connect to /var/run/docker.sock by default. For this reason, class methods were replaced with instance methods. Documentation will reflect this changes of implementation.
+
+Bug fix: Image push returns a 20X status even when the push is unsucessful. To prevent false positives, it now requires the authentication parameters to be provided, generating a 403 status for invalid credentials or an error if they are absent.
+
 # 0.6.0
 
 Add connection parameters specifications with connect_to in Docker::API::Connection.

data/Gemfile.lock

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

data/README.md

@@ -20,71 +20,76 @@ Or install it yourself as:
 
 ## Usage
 
+New implementation details as of v0.7.0.
+
 ### Images
 
 ```ruby
+# Connect to local image endpoints
+image = Docker::API::Image.new
+
 # Pull from a public repository
-Docker::API::Image.create( fromImage: "nginx:latest" )
+image.create( fromImage: "nginx:latest" )
 
 # Pull from a private repository
-Docker::API::Image.create( {fromImage: "private/repo:tag"}, {username: "janedoe", password: "password"} )
+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" )
+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" )
+image.create( fromSrc: "https://url.to/file.tar", repo: "repo:tag" )
 
 # List images
-Docker::API::Image.list
+image.list
 
 # Inspect image
-Docker::API::Image.inspect("image")
+image.inspect("image")
 
 # History
-Docker::API::Image.history("image")
+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}})
+image.search(term: "busybox", limit: 2)
+image.search(term: "busybox", filters: {"is-automated": {"true": true}})
+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")
+image.tag("current:tag", repo: "new:tag") # or
+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
+image.push("repo:tag") # to dockerhub
+image.push("localhost:5000/repo:tag") # to local registry
+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)
+image.remove("image")
+image.remove("image", force: true)
 
 # Remove unsued images (prune)
-Docker::API::Image.prune(filters: {dangling: {"false": true}})
+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 )
+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")
+image.build("/path/to/file.tar")
 
 # Build image from a remote tar file
-Docker::API::Image.build(nil, remote: "https://url.to/file.tar")
+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")
+image.build(nil, remote: "https://url.to/Dockerfile")
 
 # Delete builder cache
-Docker::API::Image.delete_cache
+image.delete_cache
 
 # Export repo
-Docker::API::Image.export("repo:tag", "~/exported_image.tar")
+image.export("repo:tag", "~/exported_image.tar")
 
 # Import repo
-Docker::API::Image.import("/path/to/file.tar")
+image.import("/path/to/file.tar")
 ```
 
 ### Containers 
@@ -93,140 +98,177 @@ Let's test a Nginx container
 
 ```ruby
 # Pull nginx image
-Docker::API::Image.create( fromImage: "nginx:latest" )
+Docker::API::Image.new.create( fromImage: "nginx:latest" )
+
+# Connect to local container endpoints
+container = Docker::API::Container.new
 
 # Create container
-Docker::API::Container.create( {name: "nginx"}, {Image: "nginx:latest", HostConfig: {PortBindings: {"80/tcp": [ {HostIp: "0.0.0.0", HostPort: "80"} ]}}})
+container.create( {name: "nginx"}, {Image: "nginx:latest", HostConfig: {PortBindings: {"80/tcp": [ {HostIp: "0.0.0.0", HostPort: "80"} ]}}})
 
 # Start container
-Docker::API::Container.start("nginx")
+container.start("nginx")
 
 # Open localhost or machine IP to check the container running
 
 # Restart container
-Docker::API::Container.restart("nginx")
+container.restart("nginx")
 
 # Pause/unpause container
-Docker::API::Container.pause("nginx")
-Docker::API::Container.unpause("nginx")
+container.pause("nginx")
+container.unpause("nginx")
 
 # List containers
-Docker::API::Container::list
+container.list
 
 # List containers (including stopped ones)
-Docker::API::Container::list(all: true)
+container.list(all: true)
 
 # Inspect container
-Docker::API::Container.inspect("nginx")
+container.inspect("nginx")
 
 # View container's processes
-Docker::API::Container.top("nginx")
+container.top("nginx")
 
-# Let's enhance the output
-JSON.parse(Docker::API::Container.top("nginx").body)
+# Using json output
+container.top("nginx").json
 
 # View filesystem changes
-Docker::API::Container.changes("nginx")
+container.changes("nginx")
 
 # View filesystem logs
-Docker::API::Container.logs("nginx", stdout: true)
-Docker::API::Container.logs("nginx", stdout: true, follow: true)
+container.logs("nginx", stdout: true)
+container.logs("nginx", stdout: true, follow: true)
 
 # View filesystem stats
-Docker::API::Container.stats("nginx", stream: true)
+container.stats("nginx", stream: true)
 
 # Export container
-Docker::API::Container.export("nginx", "~/exported_container")
+container.export("nginx", "~/exported_container")
 
 # Get files from container
-Docker::API::Container.archive("nginx", "~/html.tar", path: "/usr/share/nginx/html/")
+container.archive("nginx", "~/html.tar", path: "/usr/share/nginx/html/")
 
 # Stop container
-Docker::API::Container.stop("nginx")
+container.stop("nginx")
 
 # Remove container
-Docker::API::Container.remove("nginx")
+container.remove("nginx")
 
 # Remove stopped containers (prune)
-Docker::API::Container.prune
+container.prune
 ```
 
 ### Volumes
 
 ```ruby
+# Connect to local volume endpoints
+volume = Docker::API::Volume.new
+
 # Create volume
-Docker::API::Volume.create( Name:"my-volume" )
+volume.create( Name:"my-volume" )
 
 # List volumes
-Docker::API::Volume.list
+volume.list
 
 # Inspect volume
-Docker::API::Volume.inspect("my-volume")
+volume.inspect("my-volume")
 
 # Remove volume
-Docker::API::Volume.remove("my-volume")
+volume.remove("my-volume")
 
 # Remove unused volumes (prune)
-Docker::API::Volume.prune
+volume.prune
 ```
 
 ### Network
 
 ```ruby
+# Connect to local network endpoints
+network = Docker::API::Network.new
+
 # List networks
-Docker::API::Network.list
+network.list
 
 # Inspect network
-Docker::API::Network.inspect("bridge")
+network.inspect("bridge")
 
 # Create network
-Docker::API::Network.create( Name:"my-network" )
+network.create( Name:"my-network" )
 
 # Remove network
-Docker::API::Network.remove("my-network")
+network.remove("my-network")
 
 # Remove unused network (prune)
-Docker::API::Network.prune
+network.prune
 
 # Connect container to a network
-Docker::API::Network.connect( "my-network", Container: "my-container" )
+network.connect( "my-network", Container: "my-container" )
 
 # Disconnect container to a network
-Docker::API::Network.disconnect( "my-network", Container: "my-container" )
+network.disconnect( "my-network", Container: "my-container" )
 ```
 
 ### System
 
 ```ruby
+# Connect to local system endpoints
+sys = Docker::API::System.new
+
 # Ping docker api
-Docker::API::System.ping
+sys.ping
 
 # Docker components versions
-Docker::API::System.version
+sys.version
 
 # System info
-Docker::API::System.info
+sys.info
 
 # System events (stream)
-Docker::API::System.events(until: Time.now.to_i)
+sys.events(until: Time.now.to_i)
 
 # Data usage information
-Docker::API::System.df
+sys.df
 ```
 
 ### Exec
 
 ```ruby
+# Connect to local exec endpoints
+exe = Docker::API::Exec.new
+
 # Create exec instance, get generated exec ID
-response = Docker::API::Exec.create(container, AttachStdout:true, Cmd: ["ls", "-l"])
+response = exe.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)
+response = exe.start(id)
 print response.data[:stream]
 
 # Inspect exec instance
-Docker::API::Exec.inspect(id)
+exe.inspect(id)
+```
+
+### Connection
+
+By default Docker::API::Connection will connect to local Docker socket at `/var/run/docker.sock`. See examples below to use a different path or connect to a remote address.
+
+```ruby
+# Setting different connections
+local = Docker::API::Connection.new('unix:///', socket: "/path/to/docker.sock")
+remote = Docker::API::Connection.new("http://127.0.0.1:2375") # change the IP address accordingly
+
+# Using default /var/run/docker.sock
+image_default = Docker::API::Image.new
+image_default.list
+
+# Using custom socket path
+image_custom = Docker::API::Image.new(local)
+image_custom.list
+
+# Using remote address
+image_remote = Docker::API::Image.new(remote)
+image_remote.list
 ```
 
 ### Requests
@@ -238,7 +280,7 @@ Requests should work as described in [Docker API documentation](https://docs.doc
 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::Image.new.create(fromImage: "busybox:latest")
 
 response
 => #<Docker::API::Response:0x000055bb390b35c0 ... >

data/lib/docker/api/base.rb

@@ -1,18 +1,18 @@
 module Docker
     module API
         class Base
+
+            def initialize connection = nil
+                @connection = connection || Docker::API::Connection.new
+            end
             
             private
 
-            def self.base_path
+            def base_path
                 "/"
             end
 
-            def self.connection
-                Docker::API::Connection.instance
-            end
-
-            def self.validate error, permitted, params
+            def validate error, permitted, params
                 unpermitted = params.keys.map(&:to_s) - permitted.map(&:to_s)
                 raise error.new(permitted, unpermitted) if unpermitted.size > 0
             end
@@ -20,13 +20,13 @@ module Docker
             ## 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
+            def 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 = {}
+            def 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

data/lib/docker/api/connection.rb

@@ -1,28 +1,18 @@
-require "singleton"
 module Docker
     module API
         class Connection
-            include Singleton
-
             [:get, :post, :head, :delete, :put].each do | method |
                 define_method(method) { | path | self.request(method: method, path: path) }
             end
 
-            def post(path, body = nil)
-                self.request(method: :post, path: path, headers: { "Content-Type" => "application/json" }, body: body.to_json)
-            end
-
             def request params
                 Docker::API::Response.new(@connection.request(params).data)
             end
-
-            def connect_to params
-                @connection = Excon.new(params)
-            end
             
-            private
-            def initialize
-                @connection = Excon.new('unix:///', :socket => '/var/run/docker.sock')
+            def initialize url = nil, params = nil
+                url ||= 'unix:///'
+                params ||= url == 'unix:///' ? {socket: '/var/run/docker.sock'} : {}
+                @connection = Excon.new(url, params)
             end
 
         end

data/lib/docker/api/container.rb

@@ -5,111 +5,111 @@ module Docker
 
         class Container < Docker::API::Base
 
-            def self.base_path
+            def base_path
                 "/containers"
             end
 
-            def self.list params = {}
+            def list params = {}
                 validate Docker::API::InvalidParameter, [:all, :limit, :size, :filters], params
-                connection.get(build_path(["json"], params))
+                @connection.get(build_path(["json"], params))
             end
 
-            def self.inspect name, params = {}
+            def inspect name, params = {}
                 validate Docker::API::InvalidParameter, [:size], params
-                connection.get(build_path([name, "json"], params))
+                @connection.get(build_path([name, "json"], params))
             end
 
-            def self.top name, params = {}
+            def top name, params = {}
                 validate Docker::API::InvalidParameter, [:ps_args], params
-                connection.get(build_path([name, "top"], params))
+                @connection.get(build_path([name, "top"], params))
             end
 
-            def self.changes name
-                connection.get(build_path([name, "changes"]))
+            def changes name
+                @connection.get(build_path([name, "changes"]))
             end
 
-            def self.start name, params = {}
+            def start name, params = {}
                 validate Docker::API::InvalidParameter, [:detachKeys], params
-                connection.post(build_path([name, "start"], params))
+                @connection.post(build_path([name, "start"], params))
             end
 
-            def self.stop name, params = {}
+            def stop name, params = {}
                 validate Docker::API::InvalidParameter, [:t], params
-                connection.post(build_path([name, "stop"], params))
+                @connection.post(build_path([name, "stop"], params))
             end
 
-            def self.restart name, params = {}
+            def restart name, params = {}
                 validate Docker::API::InvalidParameter, [:t], params
-                connection.post(build_path([name, "restart"], params))
+                @connection.post(build_path([name, "restart"], params))
             end
 
-            def self.kill name, params = {}
+            def kill name, params = {}
                 validate Docker::API::InvalidParameter, [:signal], params
-                connection.post(build_path([name, "kill"], params))
+                @connection.post(build_path([name, "kill"], params))
             end
 
-            def self.wait name, params = {}
+            def wait name, params = {}
                 validate Docker::API::InvalidParameter, [:condition], params
-                connection.post(build_path([name, "wait"], params))
+                @connection.post(build_path([name, "wait"], params))
             end
 
-            def self.update name, body = {}
+            def update name, body = {}
                 validate Docker::API::InvalidRequestBody, Docker::API::UpdateBody, body
-                connection.post(build_path([name, "update"]), body)
+                @connection.request(method: :post, path: build_path([name, "update"]), headers: {"Content-Type": "application/json"}, body: body.to_json)
             end
 
-            def self.rename name, params = {}
+            def rename name, params = {}
                 validate Docker::API::InvalidParameter, [:name], params
-                connection.post(build_path([name, "rename"], params))
+                @connection.post(build_path([name, "rename"], params))
             end
 
-            def self.resize name, params = {}
+            def resize name, params = {}
                 validate Docker::API::InvalidParameter, [:w, :h], params
-                connection.post(build_path([name, "resize"], params))
+                @connection.post(build_path([name, "resize"], params))
             end
 
-            def self.prune params = {}
+            def prune params = {}
                 validate Docker::API::InvalidParameter, [:filters], params
-                connection.post(build_path(["prune"], params))
+                @connection.post(build_path(["prune"], params))
             end
 
-            def self.pause name
-                connection.post(build_path([name, "pause"]))
+            def pause name
+                @connection.post(build_path([name, "pause"]))
             end
 
-            def self.unpause name
-                connection.post(build_path([name, "unpause"]))
+            def unpause name
+                @connection.post(build_path([name, "unpause"]))
             end
 
-            def self.remove name, params = {}
+            def remove name, params = {}
                 validate Docker::API::InvalidParameter, [:v, :force, :link], params
-                connection.delete(build_path([name]))
+                @connection.delete(build_path([name]))
             end
 
-            def self.logs name, params = {}
+            def logs name, params = {}
                 validate Docker::API::InvalidParameter, [:follow, :stdout, :stderr, :since, :until, :timestamps, :tail], params
                 
                 path = build_path([name, "logs"], params)
 
                 if params[:follow] == true || params[:follow] == 1
-                    connection.request(method: :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
-                    connection.get(path)
+                    @connection.get(path)
                 end
             end
 
-            def self.attach name, params = {}
+            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 })
+                @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 = {}
+            def create params = {}, body = {}
                 validate Docker::API::InvalidParameter, [:name], params
                 validate Docker::API::InvalidRequestBody, Docker::API::CreateBody, body
-                connection.post(build_path(["create"], params), body)
+                @connection.request(method: :post, path: build_path(["create"], params), headers: {"Content-Type": "application/json"}, body: body.to_json)
             end
 
-            def self.stats name, params = {}
+            def stats name, params = {}
                 validate Docker::API::InvalidParameter, [:stream], params
                 path = build_path([name, "stats"], params)
 
@@ -117,37 +117,37 @@ module Docker
                     streamer = lambda do |chunk, remaining_bytes, total_bytes|
                         puts chunk
                     end
-                    connection.request(method: :get, path: path , response_block: streamer)
+                    @connection.request(method: :get, path: path , response_block: streamer)
                 else
-                    connection.get(path)
+                    @connection.get(path)
                 end
             end
 
-            def self.export name, path = "exported_container"
-                response = Docker::API::Container.inspect(name)
+            def export name, path = "exported_container"
+                response = self.inspect(name)
                 if response.status == 200
                     file = File.open(File.expand_path(path), "wb")
                     streamer = lambda do |chunk, remaining_bytes, total_bytes|
                         file.write(chunk)
                     end
-                    response = connection.request(method: :get, path: 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 = {}
+            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")
-                    response = connection.request(method: :put, path: 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 = connection.head(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 = connection.request(method: :get, path: 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

data/lib/docker/api/exec.rb

@@ -2,20 +2,20 @@ module Docker
     module API
         class Exec < Docker::API::Base
 
-            def self.base_path
+            def base_path
                 "/exec"
             end
 
-            def self.create name, body = {}
+            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 )
+                @connection.request(method: :post, path: "/containers/#{name}/exec", headers: {"Content-Type": "application/json"}, body: body.to_json )
             end
 
-            def self.start name, body = {}
+            def start name, body = {}
                 validate Docker::API::InvalidRequestBody, [:Detach, :Tty], body
 
                 stream = ""
-                response = connection.request(method: :post, 
+                response = @connection.request(method: :post, 
                     path: "/exec/#{name}/start", 
                     headers: {"Content-Type": "application/json"},  
                     body: body.to_json, 
@@ -25,13 +25,13 @@ module Docker
                 response
             end
 
-            def self.resize name, params = {}
+            def resize name, params = {}
                 validate Docker::API::InvalidParameter, [:w, :h], params
-                connection.post(build_path([name, "resize"], params))
+                @connection.post(build_path([name, "resize"], params))
             end
 
-            def self.inspect name
-                connection.get(build_path([name, "json"]))
+            def inspect name
+                @connection.get(build_path([name, "json"]))
             end
 
         end

data/lib/docker/api/image.rb

@@ -7,113 +7,111 @@ module Docker
         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 self.base_path
+            def base_path
                 "/images"
             end
 
-            def self.inspect name
-                connection.get(build_path([name, "json"]))
+            def inspect name
+                @connection.get(build_path([name, "json"]))
             end
 
-            def self.history name
-                connection.get(build_path([name, "history"]))
+            def history name
+                @connection.get(build_path([name, "history"]))
             end
 
-            def self.list params = {}
+            def list params = {}
                 validate Docker::API::InvalidParameter, [:all, :filters, :digests], params
-                connection.get(build_path(["json"], params)) 
+                @connection.get(build_path(["json"], params)) 
             end
 
-            def self.search params = {}
+            def search params = {}
                 validate Docker::API::InvalidParameter, [:term, :limit, :filters], params
-                connection.get(build_path(["search"], params)) 
+                @connection.get(build_path(["search"], params)) 
             end
 
-            def self.tag name, params = {}
+            def tag name, params = {}
                 validate Docker::API::InvalidParameter, [:repo, :tag], params
-                connection.post(build_path([name, "tag"], params))
+                @connection.post(build_path([name, "tag"], params))
             end
 
-            def self.prune params = {}
+            def prune params = {}
                 validate Docker::API::InvalidParameter, [:filters], params
-                connection.post(build_path(["prune"], params))
+                @connection.post(build_path(["prune"], params))
             end
 
-            def self.remove name, params = {}
+            def remove name, params = {}
                 validate Docker::API::InvalidParameter, [:force, :noprune], params
-                connection.delete(build_path([name], params))
+                @connection.delete(build_path([name], params))
             end
 
-            def self.export name, path = "exported_image"
+            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)
+                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 self.import path, params = {}
+            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} )
+                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 = {}
+            def 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 } )
+                    @connection.request(method: :post, path: build_path([name, "push"], params), headers: { "X-Registry-Auth" => Base64.urlsafe_encode64(authentication.to_json.to_s).chomp } )
                 else
-                    connection.post(build_path([name, "push"], params))
+                    raise Docker::API::Error.new("Provide authentication parameters to push an image")
                 end
             end
 
-            def self.commit params = {}, body = {}
+            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.inspect(params[:container])
+                container = Docker::API::Container.new.inspect(params[:container])
                 return container if [404, 301].include? container.status
                 body = JSON.parse(container.body)["Config"].merge(body)
-                connection.request(method: :post, path: build_path("/commit", params), headers: {"Content-Type": "application/json"}, body: body.to_json)
+                @connection.request(method: :post, path: build_path("/commit", params), headers: {"Content-Type": "application/json"}, body: body.to_json)
             end
 
-            def self.create params = {}, authentication = {}
+            def 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)
+                    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 } )
+                    @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))
+                        @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} )
+                        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))
+                    @connection.post(build_path(["create"], params))
                 end
             end
 
-            def self.build path, params = {}, authentication = {}
+            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.auth({username: authentication[server][:username] ,password:authentication[server][:password], serveraddress: 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})
@@ -121,17 +119,17 @@ module Docker
 
                 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})
+                    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)
+                    response = @connection.request(method: :post, path: build_path("/build", params), headers: header)
                 end
                 response
             end
 
-            def self.delete_cache params = {}
+            def delete_cache params = {}
                 validate Docker::API::InvalidParameter, [:all, "keep-storage", :filters], params
-                connection.post(build_path("/build/prune", params))
+                @connection.post(build_path("/build/prune", params))
             end
 
         end

data/lib/docker/api/network.rb

@@ -2,42 +2,42 @@ module Docker
     module API        
         class Network < Docker::API::Base
 
-            def self.base_path
+            def base_path
                 "/networks"
             end
 
-            def self.list params = {}
+            def list params = {}
                 validate Docker::API::InvalidParameter, [:filters], params
-                connection.get(build_path("/networks", params))
+                @connection.get(build_path("/networks", params))
             end
 
-            def self.inspect name, params = {}
+            def inspect name, params = {}
                 validate Docker::API::InvalidParameter, [:verbose, :scope], params
-                connection.get(build_path([name], params))
+                @connection.get(build_path([name], params))
             end
 
-            def self.create body = {}
+            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)
+                @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]))
+            def remove name
+                @connection.delete(build_path([name]))
             end
 
-            def self.prune params = {}
+            def prune params = {}
                 validate Docker::API::InvalidParameter, [:filters], params
-                connection.post(build_path(["prune"], params))
+                @connection.post(build_path(["prune"], params))
             end
 
-            def self.connect name, body = {}
+            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)
+                @connection.request(method: :post, path: build_path([name, "connect"]), headers: {"Content-Type": "application/json"}, body: body.to_json)
             end
 
-            def self.disconnect name, body = {}
+            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)
+                @connection.request(method: :post, path: build_path([name, "disconnect"]), headers: {"Content-Type": "application/json"}, body: body.to_json)
             end
 
         end

data/lib/docker/api/system.rb

@@ -2,32 +2,33 @@ require "json"
 module Docker
     module API
         class System < Docker::API::Base
-            
-            def self.auth body = {}
+
+            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)
+                @connection.request(method: :post, path: "/auth", headers: { "Content-Type" => "application/json" }, body: body.to_json)
             end
 
-            def self.events params = {}
+            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 } )
+                @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")
+            def ping
+                @connection.get("/_ping")
             end
 
-            def self.info
-                connection.get("/info")
+            def info
+                @connection.get("/info")
             end
 
-            def self.version
-                connection.get("/version")
+            def version
+                @connection.get("/version")
             end
 
-            def self.df
-                connection.get("/system/df")
+            def 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.6.0"
+    GEM_VERSION = "0.7.0"
 
     API_VERSION = "1.40"
 

data/lib/docker/api/volume.rb

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

metadata

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