docker-swarm-api 1.2.2 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a8630271a889f20bc866426d01c86a9892e6fbe
-  data.tar.gz: 41d722648cf609db8f83da1e27715cd7f519040f
+  metadata.gz: f231ed6bde66591fce70f5c3c5d653d3c21abd52
+  data.tar.gz: e33c69b6e3ad5a10a070d9de06f358093413780d
 SHA512:
-  metadata.gz: 5c84719528dfc669814d3444647fb96b052da5a61be9480dbbb68992e6309e80ba1f34db7c7606c0144a3c8ff5fa5c76178676c35c20f81916a6c646373c6a6a
-  data.tar.gz: 430e4921e366265643d67c917b77b4c97b7f8ce71d4216a352ea3fc2e5db6513f3f11a947d39c95e583e81072d4cdcf888bfbb5348353cef535314508241ed38
+  metadata.gz: 3885fddc8388316922b7a4371d1d10a64084a59fb8d373fd4e2a2df8fd76f241f510ce7bb4d098ed7427c95e2bf9f6702e52092b82372a6d9464a15abe033d52
+  data.tar.gz: 52a89eb4cede7dff51e836db236737711ceccd7e648d13ada96e18f50b5f91f7b18078194d10092306f3e21aa112d546389a81c581974bce888a1327efacbb29

data/README.md

@@ -1,120 +1,85 @@
 # docker-swarm-api
 
-Must use Docker API Version of 1.24 or above.
+Ruby GEM providing API for managing Docker Swarm clusters.
+
+MIT License
 
-This project leverages swipely/docker-api, and adds Docker Swarm capability.
+Must use Docker Engine Version of 1.12 or above.  Docker Engine version 1.12.5 required to make overlay networks with API.
 
-Warning: cannot create overlay network in Docker Engine versions less than 1.13.  
+Must use Docker API Version of 1.24 or above.
+
+This project leverages swipely/docker-api (https://github.com/swipely/docker-api), and adds Docker Swarm capability.
 
 Sample Usage
 ------------
 ```ruby
- # Create a Swarm cluster
+ # Make a connection to the Swarm manager's API.  (Assumes port 2375 exposed for API)
 master_connection = Docker::Swarm::Connection.new('http://10.20.30.1:2375')
 
  # Manager node intializes swarm
-swarm_init_options = {
-"ListenAddr" => "0.0.0.0:2377",
-}
+swarm_init_options = { "ListenAddr" => "0.0.0.0:2377" }
 swarm = Docker::Swarm::Swarm.init(swarm_init_options, master_connection)
 
-expect(swarm).to_not be nil
-
-nodes = Docker::Swarm::Node.all({}, master_connection)
+ # Gather all nodes available to swarm (overlay and bridges)
+nodes = swarm.nodes()
 expect(nodes.length).to eq 1
 
  # Worker joins swarm
 worker_connection = Docker::Swarm::Connection.new('http://10.20.30.2:2375')
-swarm.join(worker_ip, worker_connection)
+swarm.join_worker(worker_connection)
+
+ # Join another manager to the swarm
+manager_2_connection = Docker::Swarm::Connection.new('http://10.20.30.3:2375')
+swarm.join_manager(manager_2_connection)
 
  # Gather all nodes of swarm
-nodes = swarm.nodes
+nodes = swarm.nodes()
 
  # Create a network which connect services
-network = swarm.create_network(network_name)
+network = swarm.create_overlay_network(network_name)
 
  # Find all networks in swarm cluster
-networks = swarm.networks
+networks = swarm.networks()
 
  # Create a service with 5 replicas
-service_create_options = {
-    "Name" => "nginx",
-    "TaskTemplate" => {
-      "ContainerSpec" => {
-        "Networks" => [network.id],
-        "Image" => "nginx:1.11.7",
-        "Mounts" => [
-        ],
-        "User" => "root"
-      },
-      "Env" => ["TEST_ENV=test"],
-      "LogDriver" => {
-        "Name" => "json-file",
-        "Options" => {
-          "max-file" => "3",
-          "max-size" => "10M"
-        }
-      },
-       "Placement" => {},
-       "Resources" => {
-         "Limits" => {
-           "MemoryBytes" => 104857600
-         },
-         "Reservations" => {
-         }
-       },
-      "RestartPolicy" => {
-        "Condition" => "on-failure",
-        "Delay" => 1,
-        "MaxAttempts" => 3
-      }
-    },
-    "Mode" => {
-      "Replicated" => {
-        "Replicas" => 5
-      }
-    },
-    "UpdateConfig" => {
-      "Delay" => 2,
-      "Parallelism" => 2,
-      "FailureAction" => "pause"
-    },
-    "EndpointSpec" => {
-      "Ports" => [
-        {
-          "Protocol" => "tcp",
-          "PublishedPort" => 80,
-          "TargetPort" => 80
-        }
-      ]
-    },
-    "Labels" => {
-      "foo" => "bar"
-    }
-  }
-
+service_create_options = {"Name"=>"nginx",
+ "TaskTemplate" =>
+  {"ContainerSpec" =>
+    {"Networks" => [], "Image" => "nginx:1.11.7", "Mounts" => [], "User" => "root"},
+   "Env" => ["TEST_ENV=test"],
+   "LogDriver" => {"Name"=>"json-file", "Options"=>{"max-file"=>"3", "max-size"=>"10M"}},
+   "Placement" => {},
+   "Resources" => {"Limits"=>{"MemoryBytes"=>104857600}, "Reservations"=>{}},
+   "RestartPolicy" => {"Condition"=>"on-failure", "Delay"=>1, "MaxAttempts"=>3}},
+ "Mode"=>{"Replicated" => {"Replicas" => 5}},
+ "UpdateConfig" => {"Delay" => 2, "Parallelism" => 2, "FailureAction" => "pause"},
+ "EndpointSpec"=>
+  {"Ports" => [{"Protocol"=>"tcp", "PublishedPort" => 8181, "TargetPort" => 80}]},
+ "Labels" => {"layer" => "database"},
+ "Networks" => [{"Target" => "my-network"}]
+}
 service = swarm.create_service(service_create_options)
 
  # Retrieve all manager nodes of swarm
-manager_nodes = swarm.manager_nodes
+manager_nodes = swarm.manager_nodes()
 
  # Retrieve all worker nodes (that aren't managers)
-worker_nodes = swarm.worker_nodes
+worker_nodes = swarm.worker_nodes()
 
  # Drain a worker node - stop hosting tasks/containers of services
 worker_node = worker_nodes.first
-worker_node.drain
+worker_node.drain()
 
  # Gather all tasks (containers for service) being hosted by the swarm cluster
-tasks = swarm.tasks
+tasks = swarm.tasks()
 
  # Scale up or down the number of replicas on a service
 service.scale(20)
       
  # Worker leaves the swarm - no forcing
-swarm.leave(false, worker_connection)
+swarm.leave(worker_node, node)
 
- # Manager leaves the swarm - forced because manager's need to force the issue.
-swarm.leave(true, master_connection)
+ # Manager leaves the swarm - forced because last manager needs to use 'force' to leave the issue.
+swarm.leave(manager_node, true)
 
 ```

data/lib/docker/swarm/network.rb

@@ -20,13 +20,20 @@ class Docker::Swarm::Network
     return @hash['Name']
   end
 
+  def driver
+    return @hash['Driver']
+  end
+
   def remove
+    network_name = name
     response = @swarm.connection.delete("/networks/#{id()}", {}, expects: [200, 204, 500], full_response: true)
     if (response.status > 204)
       raise "Error deleting network (#{name})  HTTP-#{response.status}  #{response.body}"
     end
+    while (@swarm.find_network_by_name(network_name) != nil)
+      sleep 1
+    end
   end
-  
 end
 
 # EXAMPLE INSPECT OF OVERLAY NETWORK:

data/lib/docker/swarm/service.rb

@@ -17,6 +17,12 @@ class Docker::Swarm::Service
     return @hash['ID']
   end
   
+  def reload()
+    s = @swarm.find_service(id())
+    @hash = s.hash
+    return self
+  end
+  
   def network_ids
     network_ids = []
     @hash['Endpoint']['VirtualIPs'].each do |network_info|
@@ -41,6 +47,65 @@ class Docker::Swarm::Service
     self.update(@hash['Spec'])
   end
 
+
+  def self.DEFAULT_OPTIONS
+    default_service_create_options = {
+        "Name" => "<<Required>>",
+        "TaskTemplate" => {
+          "ContainerSpec" => {
+            "Image" => "<<Required>>",
+            "Mounts" => [],
+            "User" => "root"
+          },
+          "Env" => [],
+          "LogDriver" => {
+            "Name" => "json-file",
+            "Options" => {
+              "max-file" => "3",
+              "max-size" => "10M"
+            }
+          },
+          "Placement" => {},
+          "Resources" => {
+            "Limits" => {
+              "MemoryBytes" => 104857600
+            },
+            "Reservations" => {
+#              "NanoCPUs" => ?
+#              MemoryBytes => 
+           }
+          },
+          "RestartPolicy" => {
+            "Condition" => "on-failure",
+            "Delay" => 1,
+            "MaxAttempts" => 3
+          }
+        }, # End of TaskTemplate
+        "Mode" => {
+          "Replicated" => {
+            "Replicas" => 1
+          }
+        },
+        "UpdateConfig" => {
+          "Delay" => 2,
+          "Parallelism" => 2,
+          "FailureAction" => "pause"
+        },
+        "EndpointSpec" => {
+          "Ports" => [
+            {
+    #          "Protocol" => "http",
+    #          "PublishedPort" => 2881,
+    #          "TargetPort" => 2881
+            }
+          ]
+        },
+        "Labels" => {
+          "foo" => "bar"
+        }
+      }
+    return default_service_create_options
+  end
   
   
 end

data/lib/docker/swarm/swarm.rb

@@ -9,61 +9,58 @@ class Docker::Swarm::Swarm
 
   def initialize(hash, manager_connection, options = {})
     @hash = hash
-#    @manager_connection = manager_connection
     @id = hash['ID']
     @worker_join_token = hash['JoinTokens']['Worker']
     @manager_join_token = hash['JoinTokens']['Manager']
     @node_hash = {}
     @manager_connection = manager_connection
-    nodes.each do |node|
-      node_connection = nil
-      docker_port = options[:docker_api_port] || 2375
-      if (node.hash['ManagerStatus'])
-        ip_address = node.hash['ManagerStatus']['Addr'].split(":").first
-        manager_ip_address = @manager_connection.url.split('//').last.split(':').first
-        if (ip_address == manager_ip_address)
-          node.connection = @manager_connection
-        else
-          node.connection = Docker::Swarm::Connection.new("tcp://#{ip_address}:#{docker_port}")
-        end
-      else
-        ip_address = nil
-        begin
-          ip_address = Resolv::DNS.new.getaddress(node.host_name())
-        rescue
-          ip_address = Resolv::Hosts.new.getaddress(node.host_name())
-          if (!ip_address)
-            host_addresses = options[:host_addresses]
-            ip_address = host_addresses[node.host_name]
-          end
-        end
-        node.connection = Docker::Swarm::Connection.new("tcp://#{ip_address}:#{docker_port}")
-      end
-      @node_hash[node.id] = {hash: node.hash, connection: node.connection}
-      
-    end
+  end
+  
+  def store_manager(manager_connection, listen_address_and_port)
+    node = nodes.find {|n| 
+      (n.hash['ManagerStatus']) && (n.hash['ManagerStatus']['Leader'] == true) && (n.hash['ManagerStatus']['Addr'] == listen_address_and_port) 
+    }
+    raise "Node not found for: #{listen_address}" if (!node)
+    @node_hash[node.id] = {hash: node.hash, connection: manager_connection}
   end
 
-  def join(node_connection, join_token)
+  def join(node_connection, join_token = nil, listen_address = "0.0.0.0:2377")
+    join_token = @worker_join_token
     node_ids_before = nodes().collect {|n| n.id}
     query = {}
     master_ip = self.connection.url.split("//").last.split(":").first
     new_node_ip = node_connection.url.split("//").last.split(":").first
+    
     join_options = {
-            "ListenAddr" => "0.0.0.0:2377",
+            "ListenAddr" => "#{listen_address}",
             "AdvertiseAddr" => "#{new_node_ip}:2377",
             "RemoteAddrs" => ["#{master_ip}:2377"],
             "JoinToken" => join_token
           }
     new_node = nil
-    resp = node_connection.post('/swarm/join', query, :body => join_options.to_json, expects: [200])
-    nodes.each do |node|
-      if (!node_ids_before.include? node.id)
-        new_node = node
-        @node_hash[node.id] = {hash: node.hash, connection: node_connection}
+    response = node_connection.post('/swarm/join', query, :body => join_options.to_json, expects: [200, 406, 500], full_response: true)
+    if (response.status == 200)
+      nodes.each do |node|
+        if (!node_ids_before.include? node.id)
+          new_node = node
+          @node_hash[node.id] = {hash: node.hash, connection: node_connection}
+        end
       end
+      return new_node
+    elsif (response.status == 406)
+      puts "Node is already part of a swarm - maybe this swarm, maybe another swarm."
+      return nil
+    else
+      raise "Error joining (#{node_connection}):  HTTP-#{response.status}  #{response.body}"
     end
-    return new_node
+  end
+
+  def join_worker(node_connection, listen_address = "0.0.0.0:2377")
+    join(node_connection, @worker_join_token)
+  end
+  
+  def join_manager(manager_connection, listen_address = "0.0.0.0:2377")
+    join(node_connection, @manager_join_token, listen_address)
   end
   
   def connection
@@ -76,14 +73,6 @@ class Docker::Swarm::Swarm
     return @manager_connection
   end
 
-  def join_worker(node_connection)
-    join(node_connection, @worker_join_token)
-  end
-  
-  def join_manager(manager_connection)
-    join(node_connection, @manager_join_token)
-  end
-
   def remove
     services().each do |service|
       service.remove()
@@ -144,46 +133,54 @@ class Docker::Swarm::Swarm
     return all_networks
   end
   
-  def create_network(network_name, options = {})
-    defaults = {
+  def create_network(options)
+    response = connection.post('/networks/create', {},  body: options.to_json, expects: [200, 201, 500], full_response: true)
+    if (response.status <= 201)
+      hash = JSON.parse(response.body)
+      response = connection.get("/networks/#{hash['Id']}", {}, expects: [200, 201], full_response: true)
+      hash = Docker::Util.parse_json(response.body)
+      network = Docker::Swarm::Network.new(self, hash)
+      return network
+    else
+      raise "Error creating network: HTTP-#{response.status} - #{response.body}"
+    end
+  end
+  
+  def create_network_overlay(network_name)
+    max_vxlanid = 200
+    networks.each do |network|
+      if (network.driver == 'overlay')
+        if (network.hash['Options'])
+          vxlanid = network.hash['Options']["com.docker.network.driver.overlay.vxlanid_list"]
+          if (vxlanid) && (vxlanid.to_i > max_vxlanid)
+            max_vxlanid = vxlanid.to_i
+          end
+        end
+      end
+    end
+
+    options = {
         "Name" => network_name,
         "CheckDuplicate" => true,
-#        "Driver" => "bridge",
         "Driver" => "overlay",
         "EnableIPv6" => false,
-#         "IPAM" => {
-#           "Driver" => "default",
-#           "Config" => [
-#             {
-#              "Subnet" => "172.20.0.0/16",
-#              "IPRange" => "172.20.10.0/24",
-#              "Gateway" => "172.20.10.11"
-#             }
-#           ],
-#           "Options" => {
-# #            "foo" => "bar"
-#           }
-#          },
+        "IPAM" => {
+          "Driver" => "default",
+          "Config" => [
+          ],
+           "Options" => {
+           }
+        },
         "Internal" => false,
         "Options" => {
-            "com.docker.network.driver.overlay.vxlanid_list" => "257"
+            "com.docker.network.driver.overlay.vxlanid_list" => (max_vxlanid + 1).to_s
         },
         "Labels" => {
           # "com.example.some-label": "some-value",
           # "com.example.some-other-label": "some-other-value"
         }
       }
-      opts = defaults.merge(options)
-      response = connection.post('/networks/create', {},  body: opts.to_json, expects: [200, 201, 500], full_response: true)
-      if (response.status <= 201)
-        hash = JSON.parse(response.body)
-        response = connection.get("/networks/#{hash['Id']}", {}, expects: [200, 201], full_response: true)
-        hash = Docker::Util.parse_json(response.body)
-        network = Docker::Swarm::Network.new(self, hash)
-        return network
-      else
-        raise "Error creating network: HTTP-#{response.status} - #{response.body}"
-      end
+      create_network(options)
   end
   
   def find_network_by_name(network_name)
@@ -194,7 +191,7 @@ class Docker::Swarm::Swarm
     end
     return nil
   end
-  
+
   # Return all of the Nodes.
   def nodes
     opts = {}
@@ -215,7 +212,7 @@ class Docker::Swarm::Swarm
 
   def create_service(opts = {})
     query = {}
-    response = self.connection.post('/services/create', query, :body => opts.to_json, expects: [201, 500], full_response: true)
+    response = self.connection.post('/services/create', query, :body => opts.to_json, expects: [201, 404, 409, 500], full_response: true)
     if (response.status <= 201)
       info = JSON.parse(response.body)
       service_id = info['ID']
@@ -234,7 +231,7 @@ class Docker::Swarm::Swarm
     return Docker::Swarm::Service.new(self, hash)
   end
   
-  def find_service_with_name(name)
+  def find_service_by_name(name)
     services.each do |service|
       return service if (service.name == name)
     end
@@ -253,23 +250,28 @@ class Docker::Swarm::Swarm
     return items
   end
   
-  def discover_nodes
-    # {discover_nodes: true, worker_docker_port: 2375}
-    
-  end
-
   # Initialize Swarm
   def self.init(opts, connection)
     query = {}
-    resp = connection.post('/swarm/init', query, :body => opts.to_json, full_response: true)
-    return Docker::Swarm::Swarm.swarm(opts, connection)
+    resp = connection.post('/swarm/init', query, :body => opts.to_json, full_response: true, expects: [200, 404, 500])
+    if (resp.status == 200)
+      swarm = Docker::Swarm::Swarm.swarm(opts, connection)
+      manager_node = swarm.nodes.find {|n|  
+        (n.hash['ManagerStatus']) && (n.hash['ManagerStatus']['Leader'] == true) 
+      }
+      listen_address = manager_node.hash['ManagerStatus']['Addr']
+      swarm.store_manager(connection, listen_address)
+      return swarm
+    else
+      raise "Bad response: #{resp.status} #{resp.body}"
+    end
   end
 
   # docker swarm join-token -q worker
   def self.swarm(opts, connection)
     query = {}
-    resp = connection.get('/swarm', query, :body => opts.to_json, expects: [200, 406], full_response: true)
-    if (resp.status == 406)
+    resp = connection.get('/swarm', query, :body => opts.to_json, expects: [200, 404, 406], full_response: true)
+    if (resp.status == 406) || (resp.status == 404)
       return nil
     elsif (resp.status == 200)
       hash = JSON.parse(resp.body)
@@ -290,11 +292,16 @@ class Docker::Swarm::Swarm
   
   def self.find(connection, options = {})
     query = {}
-    response = connection.get('/swarm', query, expects: [200, 406], full_response: true)
+    response = connection.get('/swarm', query, expects: [200, 404, 406], full_response: true)
     if (response.status == 200)
       swarm = Docker::Swarm::Swarm.new(JSON.parse(response.body), connection, options)
+      manager_node = swarm.nodes.find {|n|  
+        (n.hash['ManagerStatus']) && (n.hash['ManagerStatus']['Leader'] == true) 
+      }
+      listen_address = manager_node.hash['ManagerStatus']['Addr']
+      swarm.store_manager(connection, listen_address)
       return swarm
-    elsif (response.status == 406)
+    elsif (response.status > 200)
       return nil
     else 
       raise "Error finding swarm: HTTP-#{response.status} #{response.body}"

data/lib/docker/swarm/task.rb

@@ -19,6 +19,12 @@ class Docker::Swarm::Task
   def service_id
     @hash['ServiceID']
   end
+  
+  def service
+    return @swarm.services.find { |service|
+      self.service_id == service.id
+    }
+  end
 
   def node_id
     @hash['NodeID']
@@ -36,5 +42,15 @@ class Docker::Swarm::Task
     @hash['Status']['State'].to_sym
   end
 
+  def networks
+    all_networks = @swarm.networks
+    nets = []
+    self.hash['NetworksAttachments'].each do |net_hash|
+      hash = net_hash['Network']
+      network_id = hash['ID']
+      nets << all_networks.find {|net| net.id == network_id}
+    end
+    return nets
+  end
 
 end

data/lib/docker/swarm/version.rb

@@ -1,7 +1,7 @@
 module Docker
   module Swarm
     # The version of the docker-api gem.
-    VERSION = '1.2.2'
+    VERSION = '1.2.3'
 
     # The version of the compatible Docker remote API.
     API_VERSION = '1.24'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: docker-swarm-api
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.3
 platform: ruby
 authors:
 - Mike Moore / Rogue Wave Software
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-28 00:00:00.000000000 Z
+date: 2017-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json