be more explicit with types

Author: gesellix

client/src/main/groovy/de/gesellix/docker/client/container/ManageContainer.groovy

@@ -20,9 +20,9 @@ interface ManageContainer {
 
 //    commit      Create a new image from a container's changes
 
-  EngineResponse commit(container, query)
+  EngineResponse commit(String container, Map query)
 
-  EngineResponse commit(container, query, config)
+  EngineResponse commit(String container, Map query, Map config)
 
 //    cp          Copy files/folders between a container and the local filesystem
 
@@ -90,7 +90,7 @@ interface ManageContainer {
 
   EngineResponse ps()
 
-  EngineResponse ps(query)
+  EngineResponse ps(Map<String, ?> query)
 
 //    pause       Pause all processes within one or more containers
 

client/src/main/groovy/de/gesellix/docker/client/container/ManageContainerClient.groovy

@@ -83,7 +83,7 @@ class ManageContainerClient implements ManageContainer {
   }
 
   @Override
-  EngineResponse commit(container, query, config = [:]) {
+  EngineResponse commit(String container, Map query, Map config = [:]) {
     log.info "docker commit"
 
     def finalQuery = query ?: [:]
@@ -363,10 +363,10 @@ class ManageContainerClient implements ManageContainer {
   }
 
   @Override
-  EngineResponse ps(query = [:]) {
+  EngineResponse ps(Map<String, ?> query = [:]) {
     log.info "docker ps"
-    def actualQuery = query ?: [:]
-    def defaults = [all: true, size: false]
+    Map actualQuery = query ?: [:]
+    Map defaults = [all: true, size: false]
     queryUtil.applyDefaults(actualQuery, defaults)
     queryUtil.jsonEncodeFilters(actualQuery)
     def response = client.get([path : "/containers/json",

client/src/main/groovy/de/gesellix/docker/client/service/ManageService.groovy

@@ -24,17 +24,17 @@ interface ManageService {
 
 //    ps          List the tasks of a service
 
-  def tasksOfService(service)
+  EngineResponse tasksOfService(service)
 
-  def tasksOfService(service, query)
+  EngineResponse tasksOfService(service, query)
 
 //    rm          Remove one or more services
 
-  def rmService(name)
+  EngineResponse rmService(name)
 
 //    scale       Scale one or multiple replicated services
 
-  def scaleService(name, int replicas)
+  EngineResponse scaleService(name, int replicas)
 
 //    update      Update a service
 

client/src/main/groovy/de/gesellix/docker/client/service/ManageServiceClient.groovy

@@ -59,9 +59,9 @@ class ManageServiceClient implements ManageService {
   }
 
   @Override
-  rmService(name) {
+  EngineResponse rmService(name) {
     log.info "docker service rm"
-    def response = client.delete([path: "/services/$name".toString()])
+    EngineResponse response = client.delete([path: "/services/$name".toString()])
     responseHandler.ensureSuccessfulResponse(response, new IllegalStateException("docker service rm failed"))
     IOUtils.closeQuietly(response.stream)
     return response
@@ -104,7 +104,7 @@ class ManageServiceClient implements ManageService {
   }
 
   @Override
-  scaleService(name, int replicas) {
+  EngineResponse scaleService(name, int replicas) {
     log.info "docker service scale"
     def service = inspectService(name).content
     def mode = service.Spec.Mode
@@ -116,7 +116,7 @@ class ManageServiceClient implements ManageService {
   }
 
   @Override
-  tasksOfService(service, query = [:]) {
+  EngineResponse tasksOfService(service, query = [:]) {
     log.info "docker service ps"
     def actualQuery = query ?: [:]
     if (!actualQuery.containsKey('filters')) {

client/src/main/groovy/de/gesellix/docker/client/swarm/ManageSwarm.groovy

@@ -1,50 +1,52 @@
 package de.gesellix.docker.client.swarm
 
+import de.gesellix.docker.engine.EngineResponse
+
 interface ManageSwarm {
 
   Map newSwarmConfig()
 
 //    init        Initialize a swarm
 
-  def initSwarm()
+  EngineResponse initSwarm()
 
-  def initSwarm(Map config)
+  EngineResponse initSwarm(Map config)
 
 //    join        Join a swarm as a node and/or manager
 
-  def joinSwarm(Map config)
+  EngineResponse joinSwarm(Map config)
 
 //    join-token  Manage join tokens
 
-  def inspectSwarm()
+  EngineResponse inspectSwarm()
 
-  def inspectSwarm(Map query)
+  EngineResponse inspectSwarm(Map query)
 
-  def getSwarmWorkerToken()
+  String getSwarmWorkerToken()
 
-  def rotateSwarmWorkerToken()
+  String rotateSwarmWorkerToken()
 
-  def getSwarmManagerToken()
+  String getSwarmManagerToken()
 
-  def rotateSwarmManagerToken()
+  String rotateSwarmManagerToken()
 
 //    leave       Leave the swarm
 
-  def leaveSwarm()
+  EngineResponse leaveSwarm()
 
-  def leaveSwarm(Map query)
+  EngineResponse leaveSwarm(Map query)
 
 //    unlock      Unlock swarm
 
-  def unlockSwarm(String unlockKey)
+  EngineResponse unlockSwarm(String unlockKey)
 
 //    unlock-key  Manage the unlock key
 
-  def getSwarmManagerUnlockKey()
+  String getSwarmManagerUnlockKey()
 
-  def rotateSwarmManagerUnlockKey()
+  String rotateSwarmManagerUnlockKey()
 
 //    update      Update the swarm
 
-  def updateSwarm(Map query, Map config)
+  EngineResponse updateSwarm(Map query, Map config)
 }

client/src/main/groovy/de/gesellix/docker/client/swarm/ManageSwarmClient.groovy

@@ -2,6 +2,7 @@ package de.gesellix.docker.client.swarm
 
 import de.gesellix.docker.client.DockerResponseHandler
 import de.gesellix.docker.engine.EngineClient
+import de.gesellix.docker.engine.EngineResponse
 import de.gesellix.util.IOUtils
 import de.gesellix.util.QueryUtil
 import groovy.util.logging.Slf4j
@@ -40,12 +41,12 @@ class ManageSwarmClient implements ManageSwarm {
   }
 
   @Override
-  initSwarm() {
+  EngineResponse initSwarm() {
     initSwarm(newSwarmConfig())
   }
 
   @Override
-  initSwarm(Map config) {
+  EngineResponse initSwarm(Map config) {
     log.info "docker swarm init"
 
     /*
@@ -104,51 +105,51 @@ return nil
   }
 
   @Override
-  joinSwarm(Map config) {
+  EngineResponse joinSwarm(Map config) {
     log.info "docker swarm join"
     config = config ?: [:]
-    def response = client.post([path              : "/swarm/join",
-                                body              : config,
-                                requestContentType: "application/json"])
+    EngineResponse response = client.post([path              : "/swarm/join",
+                                           body              : config,
+                                           requestContentType: "application/json"])
     responseHandler.ensureSuccessfulResponse(response, new IllegalStateException("docker swarm join failed"))
     IOUtils.closeQuietly(response.stream)
     return response
   }
 
   @Override
-  leaveSwarm(Map query = [:]) {
+  EngineResponse leaveSwarm(Map query = [:]) {
     log.info "docker swarm leave"
     def actualQuery = query ?: [:]
-    def response = client.post([path : "/swarm/leave",
-                                query: actualQuery])
+    EngineResponse response = client.post([path : "/swarm/leave",
+                                           query: actualQuery])
     responseHandler.ensureSuccessfulResponse(response, new IllegalStateException("docker swarm leave failed"))
     IOUtils.closeQuietly(response.stream)
     return response
   }
 
   @Override
-  updateSwarm(Map query, Map config) {
+  EngineResponse updateSwarm(Map query, Map config) {
     log.info "docker swarm update"
     def actualQuery = query ?: [:]
     config = config ?: [:]
-    def response = client.post([path              : "/swarm/update",
-                                query             : actualQuery,
-                                body              : config,
-                                requestContentType: "application/json"])
+    EngineResponse response = client.post([path              : "/swarm/update",
+                                           query             : actualQuery,
+                                           body              : config,
+                                           requestContentType: "application/json"])
     responseHandler.ensureSuccessfulResponse(response, new IllegalStateException("docker swarm update failed"))
     IOUtils.closeQuietly(response.stream)
     return response
   }
 
   @Override
-  getSwarmWorkerToken() {
+  String getSwarmWorkerToken() {
     log.info "docker swarm join-token worker"
     def swarm = inspectSwarm().content
     return swarm.JoinTokens.Worker
   }
 
   @Override
-  rotateSwarmWorkerToken() {
+  String rotateSwarmWorkerToken() {
     log.info "docker swarm join-token rotate worker token"
 
     def swarm = inspectSwarm().content
@@ -163,14 +164,14 @@ return nil
   }
 
   @Override
-  getSwarmManagerToken() {
+  String getSwarmManagerToken() {
     log.info "docker swarm join-token manager"
     def swarm = inspectSwarm().content
     return swarm.JoinTokens.Manager
   }
 
   @Override
-  rotateSwarmManagerToken() {
+  String rotateSwarmManagerToken() {
     log.info "docker swarm join-token rotate manager token"
 
     def swarm = inspectSwarm().content
@@ -185,15 +186,15 @@ return nil
   }
 
   @Override
-  getSwarmManagerUnlockKey() {
+  String getSwarmManagerUnlockKey() {
     log.info "docker swarm manager unlock key"
     def response = client.get([path: "/swarm/unlockkey"])
     responseHandler.ensureSuccessfulResponse(response, new IllegalStateException("get swarm manager unlock key failed"))
     return response.content.UnlockKey
   }
 
   @Override
-  rotateSwarmManagerUnlockKey() {
+  String rotateSwarmManagerUnlockKey() {
     log.info "docker swarm join-token rotate manager unlock key"
 
     def swarm = inspectSwarm().content
@@ -208,22 +209,22 @@ return nil
   }
 
   @Override
-  unlockSwarm(String unlockKey) {
+  EngineResponse unlockSwarm(String unlockKey) {
     log.info "docker swarm unlock"
-    def response = client.post([path              : "/swarm/unlock",
-                                body              : [UnlockKey: unlockKey],
-                                requestContentType: "application/json"])
+    EngineResponse response = client.post([path              : "/swarm/unlock",
+                                           body              : [UnlockKey: unlockKey],
+                                           requestContentType: "application/json"])
     responseHandler.ensureSuccessfulResponse(response, new IllegalStateException("unlock swarm failed"))
     return response
   }
 
   @Override
-  inspectSwarm(Map query = [:]) {
+  EngineResponse inspectSwarm(Map query = [:]) {
     log.info "docker swarm inspect"
     def actualQuery = query ?: [:]
     queryUtil.jsonEncodeFilters(actualQuery)
-    def response = client.get([path : "/swarm",
-                               query: actualQuery])
+    EngineResponse response = client.get([path : "/swarm",
+                                          query: actualQuery])
     responseHandler.ensureSuccessfulResponse(response, new IllegalStateException("docker swarm inspect failed"))
     return response
   }

client/src/main/groovy/de/gesellix/docker/client/tasks/ManageTask.groovy

@@ -8,5 +8,5 @@ interface ManageTask {
 
   EngineResponse tasks(query)
 
-  def inspectTask(name)
+  EngineResponse inspectTask(name)
 }

client/src/main/groovy/de/gesellix/docker/client/tasks/ManageTaskClient.groovy

@@ -31,9 +31,9 @@ class ManageTaskClient implements ManageTask {
   }
 
   @Override
-  inspectTask(name) {
+  EngineResponse inspectTask(name) {
     log.info "docker task inspect"
-    def response = client.get([path: "/tasks/$name".toString()])
+    EngineResponse response = client.get([path: "/tasks/$name".toString()])
     responseHandler.ensureSuccessfulResponse(response, new IllegalStateException("docker task inspect failed"))
     return response
   }