dockerapi 0.12.0 → 0.17.0

data/lib/docker/api/swarm.rb

@@ -1,51 +1,79 @@
-module Docker
-    module API
-        class Swarm < Docker::API::Base
+##
+# This class represents the Docker API endpoints regarding swamrs.
+# @see https://docs.docker.com/engine/api/v1.40/#tag/Swarm
+class Docker::API::Swarm < Docker::API::Base
 
-            def init body = {}
-                validate Docker::API::InvalidRequestBody, [:ListenAddr, :AdvertiseAddr, :DataPathAddr, :DataPathPort, :DefaultAddrPool, :ForceNewCluster, :SubnetSize, :Spec], body
-                @connection.request(method: :post, path: build_path("/swarm/init"), headers: {"Content-Type": "application/json"}, body: body.to_json)
-            end
-
-            def update params = {}, body = {}
-                validate Docker::API::InvalidParameter, [:version, :rotateWorkerToken, :rotateManagerToken, :rotateManagerUnlockKey], params
-                validate Docker::API::InvalidRequestBody, [:Name, :Labels, :Orchestration, :Raft, :Dispatcher, :CAConfig, :EncryptionConfig, :TaskDefaults], body
-                @connection.request(method: :post, path: build_path("/swarm/update", params), headers: {"Content-Type": "application/json"}, body: body.to_json)
-            end
+    ##
+    # Initialize a new swarm.
+    #
+    # Docker API: POST /swarm/init
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/SwarmInit
+    #
+    # @param body [Hash]: Request body to be sent as json.
+    def init body = {}
+        @connection.request(method: :post, path: build_path("/swarm/init"), headers: {"Content-Type": "application/json"}, body: body.to_json)
+    end
 
-            def details
-                @connection.get("/swarm")
-            end
+    ##
+    # Update a swarm.
+    #
+    # Docker API: POST /swarm/update
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/SwarmUpdate
+    #
+    # @param params [Hash]: Parameters that are appended to the URL.
+    # @param body [Hash]: Request body to be sent as json.
+    def update params = {}, body = {}
+        @connection.request(method: :post, path: build_path("/swarm/update", params), headers: {"Content-Type": "application/json"}, body: body.to_json)
+    end
 
-            def unlock_key
-                @connection.get(build_path("/swarm/unlockkey"))
-            end
+    ##
+    # Inspect swarm.
+    #
+    # Docker API: GET /swarm
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/SwarmInspect
+    def details
+        @connection.get("/swarm")
+    end
 
-            def unlock body = {}
-                validate Docker::API::InvalidRequestBody, [:UnlockKey], body
-                @connection.request(method: :post, path: build_path("/swarm/unlock"), headers: {"Content-Type": "application/json"}, body: body.to_json)
-            end
+    ##
+    # Get the unlock key.
+    #
+    # Docker API: GET /swarm/unlockkey
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/SwarmUnlockkey 
+    def unlock_key
+        @connection.get("/swarm/unlockkey")
+    end
 
-            def join body = {}
-                validate Docker::API::InvalidRequestBody, [:ListenAddr, :AdvertiseAddr, :DataPathAddr, :RemoteAddrs, :JoinToken], body
-                @connection.request(method: :post, path: build_path("/swarm/join"), headers: {"Content-Type": "application/json"}, body: body.to_json)
-            end
+    ##
+    # Unlock a locked manager.
+    #
+    # Docker API: POST /swarm/unlock
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/SwarmUnlock
+    #
+    # @param body [Hash]: Request body to be sent as json.
+    def unlock body = {}
+        @connection.request(method: :post, path: "/swarm/unlock", headers: {"Content-Type": "application/json"}, body: body.to_json)
+    end
 
-            def leave params = {}
-                validate Docker::API::InvalidParameter, [:force], params
-                @connection.post(build_path("/swarm/leave", params))
-            end
+    ##
+    # Join an existing swarm.
+    #
+    # Docker API: POST /swarm/join
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/SwarmJoin
+    #
+    # @param body [Hash]: Request body to be sent as json.
+    def join body = {}
+        @connection.request(method: :post, path: "/swarm/join", headers: {"Content-Type": "application/json"}, body: body.to_json)
+    end
 
-            #################################################
-            # Items in this area to be removed before 1.0.0 #
-            #################################################
-            def inspect
-                caller.each { | el | return super.inspect if el.match(/inspector/) }
-                warn  "WARNING: #inspect is deprecated and will be removed in the future, please use #details instead."
-                details
-            end
-            #################################################
-            
-        end
+    ##
+    # Leave a swarm.
+    #
+    # Docker API: POST /swarm/leave
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/SwarmLeave
+    #
+    # @param params [Hash]: Parameters that are appended to the URL.
+    def leave params = {}
+        @connection.post(build_path("/swarm/leave", params))
     end
 end

data/lib/docker/api/system.rb

@@ -1,34 +1,65 @@
-require "json"
-module Docker
-    module API
-        class System < Docker::API::Base
+##
+# This class represents the Docker API system related endpoints.
+# @see https://docs.docker.com/engine/api/v1.40/#tag/System
+class Docker::API::System < Docker::API::Base
 
-            def auth body = {}
-                validate Docker::API::InvalidRequestBody, [:username, :password, :email, :serveraddress, :identitytoken], body
-                @connection.request(method: :post, path: "/auth", headers: { "Content-Type" => "application/json" }, body: body.to_json)
-            end
+    ##
+    # Validate credentials for a registry and, if available, get an identity token for accessing the registry without password.
+    #
+    # Docker API: POST /auth
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/SystemAuth
+    #
+    # @param body [Hash]: Request body to be sent as json.
+    def auth body = {}
+        @connection.request(method: :post, path: "/auth", headers: { "Content-Type" => "application/json" }, body: body.to_json)
+    end
 
-            def events params = {}
-                validate Docker::API::InvalidParameter, [:since, :until, :filters], params
-                @connection.request(method: :get, path: build_path("/events", params), response_block: lambda { |chunk, remaining_bytes, total_bytes| puts chunk.inspect } )
-            end
+    ##
+    # Stream real-time events from the server.
+    #
+    # Docker API: GET /events
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/SystemEvents
+    #
+    # @param params [Hash]: Parameters that are appended to the URL.
+    # @param &block: Replace the default output to stdout behavior.
+    def events params = {}, &block
+        @connection.request(method: :get, path: build_path("/events", params), response_block: block_given? ? block : default_streamer )
+    end
 
-            def ping
-                @connection.get("/_ping")
-            end
+    ##
+    # This is a dummy endpoint you can use to test if the server is accessible.
+    #
+    # Docker API: GET /_ping
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/SystemPing
+    def ping
+        @connection.get("/_ping")
+    end
 
-            def info
-                @connection.get("/info")
-            end
+    ##
+    # Get system information.
+    #
+    # Docker API: GET /info
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/SystemInfo
+    def info
+        @connection.get("/info")
+    end
 
-            def version
-                @connection.get("/version")
-            end
+    ##
+    # Returns the version of Docker that is running and various information about the system that Docker is running on.
+    #
+    # Docker API: GET /version
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/SystemVersion
+    def version
+        @connection.get("/version")
+    end
 
-            def df
-                @connection.get("/system/df")
-            end
-                        
-        end
+    ##
+    # Get data usage information.
+    #
+    # Docker API: GET /system/df
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/SystemDataUsage
+    def df
+        @connection.get("/system/df")
     end
+                
 end

data/lib/docker/api/task.rb

@@ -1,26 +1,22 @@
 # This class represents the Docker API endpoints regarding tasks.
 #
-# @see https://docs.docker.com/engine/api/v1.40/#tag/Task
-#
 # A task is a container running on a swarm. It is the atomic scheduling unit of swarm. Swarm mode must be enabled for these endpoints to work.
+# @see https://docs.docker.com/engine/api/v1.40/#tag/Task
 class Docker::API::Task < Docker::API::Base
 
     # List tasks
     #
     # Docker API: GET /tasks
-    #
     # @see https://docs.docker.com/engine/api/v1.40/#operation/TaskList
     #
     # @param params [Hash]: Parameters that are appended to the URL.
     def list params = {}
-        validate Docker::API::InvalidParameter, [:filters], params
         @connection.get(build_path("/tasks",params))
     end
 
     # Inspect a task
     #
     # Docker API: GET /tasks/{id}
-    #
     # @see https://docs.docker.com/engine/api/v1.40/#operation/TaskInspect
     #
     # @param name [String]: The ID or name of the task.
@@ -30,17 +26,19 @@ class Docker::API::Task < Docker::API::Base
 
     # Get stdout and stderr logs from a task.
     #
-    # Note: This endpoint works only for services with the local, json-file or journald logging drivers.
-    #
     # Docker API: GET /tasks/{id}/logs
-    #
     # @see https://docs.docker.com/engine/api/v1.40/#operation/TaskLogs
     #
     # @param name (String) : The ID or name of the task.
-    #
     # @param params (Hash) : Parameters that are appended to the URL.
-    def logs name, params = {}
-        validate Docker::API::InvalidParameter, [:details, :follow, :stdout, :stderr, :since, :timestamps, :tail], params
-        @connection.get(build_path("/tasks/#{name}/logs", params))
+    # @param &block: Replace the default output to stdout behavior.
+    def logs name, params = {}, &block
+        path = build_path("/tasks/#{name}/logs", params)
+
+        if [true, 1 ].include? params[:follow]
+            @connection.request(method: :get, path: path , response_block: block_given? ? block : default_streamer)
+        else
+            @connection.get(path)
+        end
     end
 end

data/lib/docker/api/version.rb

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

data/lib/docker/api/volume.rb

@@ -1,46 +1,61 @@
-module Docker
-    module API
-        class Volume < Docker::API::Base
-
-            def list params = {}
-                validate Docker::API::InvalidParameter, [:filters], params
-                @connection.get(build_path("/volumes", params))
-            end
-
-            def details name
-                @connection.get(build_path([name]))
-            end
-
-            def create body = {}
-                validate Docker::API::InvalidRequestBody, [:Name, :Driver, :DriverOpts, :Labels], body
-                @connection.request(method: :post, path: build_path(["create"]), headers: {"Content-Type": "application/json"}, body: body.to_json)
-            end
-
-            def remove name, params = {}
-                validate Docker::API::InvalidParameter, [:force], params
-                @connection.delete(build_path([name]))
-            end
+##
+# This class represents the Docker API endpoints regarding volumes.
+# @see https://docs.docker.com/engine/api/v1.40/#tag/Volume
+class Docker::API::Volume < Docker::API::Base
+
+    ##
+    # List volumes.
+    #
+    # Docker API: GET
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/VolumeList
+    #
+    # @param params [Hash]: Parameters that are appended to the URL.
+    def list params = {}
+        @connection.get(build_path("/volumes", params))
+    end
 
-            def prune params = {}
-                validate Docker::API::InvalidParameter, [:filters], params
-                @connection.post(build_path(["prune"], params))
-            end
+    ##
+    # Inspect a volume.
+    #
+    # Docker API: GET /volumes/{name}
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/VolumeInspect
+    #
+    # @param name [String]: The ID or name of the volume.
+    def details name
+        @connection.get("/volumes/#{name}")
+    end
 
-            #################################################
-            # Items in this area to be removed before 1.0.0 #
-            #################################################
-            def base_path
-                "/volumes"
-            end
+    ##
+    # Create a volume.
+    #
+    # Docker API: POST /volumes/create
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/VolumeCreate
+    #
+    # @param body [Hash]: Request body to be sent as json.
+    def create body = {}
+        @connection.request(method: :post, path: "/volumes/create", headers: {"Content-Type": "application/json"}, body: body.to_json)
+    end
 
-            def inspect *args
-                return super.inspect if args.size == 0
-                warn  "WARNING: #inspect is deprecated and will be removed in the future, please use #details instead."
-                name = args[0]
-                @connection.get(build_path([name]))
-            end
-            #################################################
+    ##
+    # Remove a volume.
+    #
+    # Docker API: DELETE /volumes/{name}
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/VolumeDelete
+    #
+    # @param name [String]: The ID or name of the volume.
+    # @param params [Hash]: Parameters that are appended to the URL.
+    def remove name, params = {}
+        @connection.delete(build_path("/volumes/#{name}",params))
+    end
 
-        end
+    ##
+    # Delete unused volumes.
+    #
+    # Docker API: POST /volumes/prune
+    # @see https://docs.docker.com/engine/api/v1.40/#operation/VolumePrune
+    #
+    # @param params [Hash]: Parameters that are appended to the URL.
+    def prune params = {}
+        @connection.post(build_path("/volumes/prune", params))
     end
-end
+end

data/lib/dockerapi.rb

@@ -1,5 +1,7 @@
 require "excon"
 require "json"
+require "base64"
+require "fileutils"
 
 require "docker/api/version"
 require "docker/api/error"
@@ -22,6 +24,147 @@ require "docker/api/plugin"
 
 module Docker
   module API
+
+    ##
+    # This variable controls output verbosity.
+    PRINT_TO_STDOUT = true
+
+    ##
+    # Valid values for parameter validations.
+    VALID_PARAMS = {
+      "Docker::API::Image" => {
+        "build" => [:dockerfile, :t, :extrahosts, :remote, :q, :nocache, :cachefrom, :pull, :rm, :forcerm, :memory, :memswap, :cpushares, :cpusetcpus, :cpuperiod, :cpuquota, :buildargs, :shmsize, :squash, :labels, :networkmode, :platform, :target, :outputs],
+        "prune" => [:filters],
+        "list" => [:all, :filters, :digests],
+        "search" => [:term, :limit, :filters],
+        "tag" => [:repo, :tag],
+        "remove" => [:force, :noprune],
+        "import" => [:quiet],
+        "push" => [:tag],
+        "commit" => [:container, :repo, :tag, :comment, :author, :pause, :changes],
+        "create" => [:fromImage, :fromSrc, :repo, :tag, :message, :platform],
+        "delete_cache" => [:all, "keep-storage", :filters]
+      },
+      "Docker::API::Container" => {
+        "list" => [:all, :limit, :size, :filters],
+        "details" => [:size],
+        "top" => [:ps_args],
+        "start" => [:detachKeys],
+        "stop" => [:t],
+        "restart" => [:t],
+        "kill" => [:signal],
+        "wait" => [:condition],
+        "rename" => [:name],
+        "resize" => [:w, :h],
+        "prune" => [:filters],
+        "remove" => [:v, :force, :link],
+        "logs" => [:follow, :stdout, :stderr, :since, :until, :timestamps, :tail],
+        "attach" => [:detachKeys, :logs, :stream, :stdin, :stdout, :stderr],
+        "stats" => [:stream],
+        "get_archive" => [:path],
+        "put_archive" => [:path, :noOverwriteDirNonDir, :copyUIDGID],
+        "create" => [:name]
+      },
+      "Docker::API::Volume" => {
+        "list" => [:filters],
+        "remove" => [:force],
+        "prune" => [:filters]
+      },
+      "Docker::API::Network" => {
+        "list" => [:filters],
+        "details" => [:verbose, :scope],
+        "prune" => [:filters]
+      },
+      "Docker::API::System" => {
+        "events" => [:since, :until, :filters]
+      },
+      "Docker::API::Exec" => {
+        "resize" => [:w, :h]
+      },
+      "Docker::API::Swarm" => {
+        "leave" => [:force],
+        "update" => [:version, :rotateWorkerToken, :rotateManagerToken, :rotateManagerUnlockKey]
+      },
+      "Docker::API::Node" => {
+        "list" => [:filters],
+        "update" => [:version],
+        "delete" => [:force]
+      },
+      "Docker::API::Service" => {
+        "list" => [:filters],
+        "update" => [:version, :registryAuthFrom, :rollback],
+        "details" => [:insertDefaults],
+        "logs" => [:details, :follow, :stdout, :stderr, :since, :timestamps, :tail]
+      },
+      "Docker::API::Secret" => {
+        "list" => [:filters],
+        "update" => [:version]
+      },
+      "Docker::API::Task" => {
+        "list" => [:filters],
+        "logs" => [:details, :follow, :stdout, :stderr, :since, :timestamps, :tail]
+      },
+      "Docker::API::Plugin" => {
+        "list" => [:filters],
+        "privileges" => [:remote],
+        "install" => [:remote, :name],
+        "remove" => [:force],
+        "enable" => [:timeout],
+        "upgrade" => [:remote]
+      },
+      "Docker::API::Config" => {
+        "list" => [:filters],
+        "update" => [:version]
+      }
+    }
+
+    ##
+    # Valid values for request body validations.
+    VALID_BODY = {
+      "Docker::API::Image" => {
+        "commit" => [:Hostname, :Domainname, :User, :AttachStdin, :AttachStdout, :AttachStderr, :ExposedPorts, :Tty, :OpenStdin, :StdinOnce, :Env, :Cmd, :HealthCheck, :ArgsEscaped, :Image, :Volumes, :WorkingDir, :Entrypoint, :NetworkDisabled, :MacAddress, :OnBuild, :Labels, :StopSignal, :StopTimeout, :Shell]
+      },
+      "Docker::API::Container" => {
+        "create" => [:Hostname,:Domainname,:User,:AttachStdin,:AttachStdout,:AttachStderr,:ExposedPorts,:Tty,:OpenStdin,:StdinOnce,:Env,:Cmd,:HealthCheck,:ArgsEscaped,:Image,:Volumes,:WorkingDir,:Entrypoint,:NetworkDisabled,:MacAddress,:OnBuild,:Labels,:StopSignal,:StopTimeout,:Shell,:HostConfig,:NetworkingConfig],
+        "update" => [:CpuShares, :Memory, :CgroupParent, :BlkioWeight, :BlkioWeightDevice, :BlkioWeightReadBps, :BlkioWeightWriteBps, :BlkioWeightReadOps, :BlkioWeightWriteOps, :CpuPeriod, :CpuQuota, :CpuRealtimePeriod, :CpuRealtimeRuntime, :CpusetCpus, :CpusetMems, :Devices, :DeviceCgroupRules, :DeviceRequest, :Kernel, :Memory, :KernelMemoryTCP, :MemoryReservation, :MemorySwap, :MemorySwappiness, :NanoCPUs, :OomKillDisable, :Init, :PidsLimit, :ULimits, :CpuCount, :CpuPercent, :IOMaximumIOps, :IOMaximumBandwidth, :RestartPolicy]
+      },
+      "Docker::API::Volume" => {
+        "create" => [:Name, :Driver, :DriverOpts, :Labels]
+      },
+      "Docker::API::Network" => {
+        "create" => [:Name, :CheckDuplicate, :Driver, :Internal, :Attachable, :Ingress, :IPAM, :EnableIPv6, :Options, :Labels],
+        "connect" => [:Container, :EndpointConfig],
+        "disconnect" => [:Container, :Force]
+      },
+      "Docker::API::System" => {
+        "auth" => [:username, :password, :email, :serveraddress, :identitytoken]
+      },
+      "Docker::API::Exec" => {
+        "create" => [:AttachStdin, :AttachStdout, :AttachStderr, :DetachKeys, :Tty, :Env, :Cmd, :Privileged, :User, :WorkingDir],
+        "start" => [:Detach, :Tty]
+      },
+      "Docker::API::Swarm" => {
+        "init" => [:ListenAddr, :AdvertiseAddr, :DataPathAddr, :DataPathPort, :DefaultAddrPool, :ForceNewCluster, :SubnetSize, :Spec],
+        "update" => [:Name, :Labels, :Orchestration, :Raft, :Dispatcher, :CAConfig, :EncryptionConfig, :TaskDefaults],
+        "unlock" => [:UnlockKey],
+        "join" => [:ListenAddr, :AdvertiseAddr, :DataPathAddr, :RemoteAddrs, :JoinToken]
+      },
+      "Docker::API::Node" => {
+        "update" => [:Name, :Labels, :Role, :Availability]
+      },
+      "Docker::API::Service" => {
+        "create" => [:Name, :Labels, :TaskTemplate, :Mode, :UpdateConfig, :RollbackConfig, :Networks, :EndpointSpec],
+        "update" => [:Name, :Labels, :TaskTemplate, :Mode, :UpdateConfig, :RollbackConfig, :Networks, :EndpointSpec]
+      },
+      "Docker::API::Secret" => {
+        "create" => [:Name, :Labels, :Data, :Driver, :Templating],
+        "update" => [:Name, :Labels, :Data, :Driver, :Templating]
+      },
+      "Docker::API::Config" => {
+        "create" => [:Name, :Labels, :Data, :Templating],
+        "update" => [:Name, :Labels, :Data, :Driver, :Templating]
+      }
+    }
     
   end
 end