dockerapi 0.4.0 → 0.8.1

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/lib/docker/api/base.rb

@@ -1,33 +1,35 @@
 module Docker
     module API
         class Base
+
+            def initialize connection = nil
+                raise Docker::API::Error.new("Expect connection to be a Docker::API::Connection class") if connection != nil && !connection.is_a?(Docker::API::Connection)
+                @connection = connection || Docker::API::Connection.new
+            end
             
             private
 
-            def self.base_path
+            def base_path # TODO: this method to be removed?
                 "/"
             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
+            def validate error, permitted, params
+                return if params[:skip_validation]
+                unpermitted = params.keys.map(&:to_s) - permitted.map(&:to_s)
+                raise error.new(permitted, unpermitted) if unpermitted.size > 0
             end
 
             ## Converts Ruby Hash into query parameters
             ## In general, the format is key=value
             ## If value is another Hash, it should keep a json syntax {key:value}
-            def 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}") }
+                h.delete_if{ | k, v | k.to_s == "skip_validation" }.each { |k,v| p.push( v.is_a?(Hash) ? "#{k}=#{v.to_json}" : "#{k}=#{v}") }
                 p.join("&").gsub(" ","")
             end
 
-            def self.build_path path, params = {}
-                p = path.is_a?(Array) ? ([base_path] << path).join("/") : path
+            def build_path path, params = {}
+                p = path.is_a?(Array) ? ([base_path] << path).join("/") : path # TODO: this line to be removed?
                 params.size > 0 ? [p, hash_to_params(params)].join("?") : p
             end
 

data/lib/docker/api/connection.rb

@@ -1,26 +1,18 @@
-require "excon"
-require "singleton"
-require "json"
 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
-                @connection.request(params)
+                Docker::API::Response.new(@connection.request(params).data)
             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,113 @@ module Docker
 
         class Container < Docker::API::Base
 
-            def self.base_path
+            def base_path
                 "/containers"
             end
 
-            def self.list params = {}
-                validate Docker::API::InvalidParameter, [:all, :limit, :size, :filters], params
-                connection.get(build_path(["json"], params))
+            def inspect *args
+                return super.inspect if args.size == 0
+                name, params = args[0], args[1] || {}
+                validate Docker::API::InvalidParameter, [:size], params
+                @connection.get(build_path([name, "json"], params))
             end
 
-            def self.inspect name, params = {}
-                validate Docker::API::InvalidParameter, [:size], params
-                connection.get(build_path([name, "json"], params))
+            def list params = {}
+                validate Docker::API::InvalidParameter, [:all, :limit, :size, :filters], params
+                @connection.get(build_path(["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 +119,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/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,37 @@
+module Docker
+    module API
+        class Exec < Docker::API::Base
+
+            def inspect *args
+                return super.inspect if args.size == 0
+                name = args[0]
+                @connection.get("/exec/#{name}/json")
+            end
+
+            def create name, body = {}
+                validate Docker::API::InvalidRequestBody, [:AttachStdin, :AttachStdout, :AttachStderr, :DetachKeys, :Tty, :Env, :Cmd, :Privileged, :User, :WorkingDir], body
+                @connection.request(method: :post, path: "/containers/#{name}/exec", headers: {"Content-Type": "application/json"}, body: body.to_json )
+            end
+
+            def start name, body = {}
+                validate Docker::API::InvalidRequestBody, [:Detach, :Tty], body
+
+                stream = ""
+                response = @connection.request(method: :post, 
+                    path: "/exec/#{name}/start", 
+                    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 resize name, params = {}
+                validate Docker::API::InvalidParameter, [:w, :h], params
+                @connection.post(build_path("/exec/#{name}/resize", params))
+            end
+
+        end
+    end
+end

data/lib/docker/api/image.rb

@@ -7,113 +7,113 @@ 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 *args
+                return super.inspect if args.size == 0
+                name = args[0]
+                @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 = {}
-                raise Docker::API::InvalidRequestBody unless path || params[:remote] 
+            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 +121,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