docker-swarm-api 1.0 → 1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d963d1a5f11dc79f4f59209b15831f5de846fba
-  data.tar.gz: 0cd84643a8db6339b35b9ac57cc43089dc2d3113
+  metadata.gz: 04b3f0bbdfe51472c479d55d01b295dd1fbd700a
+  data.tar.gz: ea9e5330f567696ad9e3feae4fd49c809502cb5a
 SHA512:
-  metadata.gz: 3011ab70801130ee1b0f5267a31d0ad497fc5bd6797be0cf5021aa2bf52ea3c44b891dd4806347758037f94cacba805e5841c77a5b920308c1bdc6bbfd1679ff
-  data.tar.gz: f95c92b052331db406d6d933053471c79fa7fdcda46e5ad9321c50921c605498703cfc4e78f4f1255daa9857f8bf9100f95134f3f7ebad885234ab0ebda4c71a
+  metadata.gz: 605b03b067f0762243ff3cd7942c48313918550ec7589b2c0a43c0644ec08cbd46f6b56c77183643d5bbb4033ab660b3256b26f03ee6e5420eca6e4d494c9f42
+  data.tar.gz: 01d83aaa468cfc32fcadc2e570407565ce26affec0983ce579c3eb47cb14945e2546973cd23b66012bdf34b41a1656a4063107677a6ebc8406b0941402cd64fe

data/README.md

@@ -3,7 +3,8 @@
 Sample Usage
 ------------
 ```ruby
-master_connection = Docker::Swarm::Connection.new('http://10.20.30.1')
+ # Create a Swarm cluster
+master_connection = Docker::Swarm::Connection.new('http://10.20.30.1:2375')
 
  # Manager node intializes swarm
 swarm_init_options = {
@@ -17,14 +18,17 @@ nodes = Docker::Swarm::Node.all({}, master_connection)
 expect(nodes.length).to eq 1
 
  # Worker joins swarm
-worker_connection = Docker::Swarm::Connection.new('http://10.20.30.2')
+worker_connection = Docker::Swarm::Connection.new('http://10.20.30.2:2375')
 swarm.join(worker_ip, worker_connection)
 
  # Gather all nodes of swarm
-nodes = Docker::Swarm::Node.all({}, master_connection)
+nodes = swarm.nodes
 
  # Create a network which connect services
-network = Docker::Swarm::Network.create(network_name, opts = {}, master_connection)
+network = swarm.create_network(network_name)
+
+ # Find all networks in swarm cluster
+networks = swarm.networks
 
  # Create a service with 5 replicas
 service_create_options = {
@@ -83,7 +87,7 @@ service_create_options = {
     }
   }
 
-service = Docker::Swarm::Service.create(service_create_options, master_connection)
+service = swarm.create_service(service_create_options)
 
  # Retrieve all manager nodes of swarm
 manager_nodes = swarm.manager_nodes
@@ -96,15 +100,15 @@ worker_node = worker_nodes.first
 worker_node.drain
 
  # Gather all tasks (containers for service) being hosted by the swarm cluster
-tasks = Docker::Swarm::Task.all({}, master_connection)
+tasks = swarm.tasks
 
  # Scale up or down the number of replicas on a service
 service.scale(20)
-
       
  # Worker leaves the swarm - no forcing
-Docker::Swarm::Swarm.leave(false, worker_connection)
+swarm.leave(false, worker_connection)
 
  # Manager leaves the swarm - forced because manager's need to force the issue.
-Docker::Swarm::Swarm.leave(true, master_connection)
+swarm.leave(true, master_connection)
+
 ```

data/lib/docker/swarm/node.rb

@@ -2,15 +2,21 @@
 class Docker::Swarm::Node
   #include Docker::Base
   attr_reader :hash
+  attr_accessor :connection
   AVAILABILITY = {
     active: "active",
     drain:  "drain"
   }
 
-  def initialize(hash, connection)
+  def initialize(swarm, hash)
     @hash = hash
-    @connection = connection
-    hash['Description']['Hostname']
+    @swarm = swarm
+  end
+  
+  def refresh
+    query = {}
+    response = @swarm.connection.get("/nodes/#{id}", query, expects: [200])
+    @hash = JSON.parse(response)
   end
   
   def id 
@@ -47,26 +53,21 @@ class Docker::Swarm::Node
     change_availability(:active)
   end
   
+  def remove
+    Docker::Swarm::Node.remove(id(), @connection)
+  end
+  
   def change_availability(availability)
     raise "Bad availability param: #{availability}" if (!AVAILABILITY[availability])
     @hash['Spec']['Availability'] = AVAILABILITY[availability]
     query = {version: @hash['Version']['Index']}
-    response = @connection.post("/nodes/#{self.id}/update", query, :body => @hash['Spec'].to_json)
+    response = @swarm.connection.post("/nodes/#{self.id}/update", query, :body => @hash['Spec'].to_json)
   end
-
-  # Return all of the Nodes.
-  def self.all(opts = {}, conn = Docker.connection)
-    raise "opts needs to be hash" if (opts.class != Hash)
+  
+  def remove
     query = {}
-    resp = conn.get('/nodes', query, :body => opts.to_json)
-    hashes = JSON.parse(resp)
-    nodes = []
-    hashes.each do |node_hash|
-      nodes << Docker::Swarm::Node.new(node_hash, conn)
-    end
-    return nodes
+    response = @swarm.connection.delete("/nodes/#{self.id}", query, expects: [200, 406])
   end
-
-  # private :path_for
-  # private_class_method :new
+  
+  
 end

data/lib/docker/swarm/service.rb

@@ -4,8 +4,8 @@ class Docker::Swarm::Service
   #include Docker::Base
   attr_reader :hash
 
-  def initialize(hash, connection)
-    @connection = connection
+  def initialize(swarm, hash)
+    @swarm = swarm
     @hash = hash
   end
 
@@ -15,36 +15,20 @@ class Docker::Swarm::Service
   
   def remove(opts = {})
     query = {}
-    @connection.delete("/services/#{self.id}", query, :body => opts.to_json)
+    @swarm.connection.delete("/services/#{self.id}", query, :body => opts.to_json)
   end
   
   def update(opts)
     query = {}
     version = @hash['Version']['Index']
-    response = @connection.post("/services/#{self.id}/update?version=#{version}", query, :body => opts.to_json)
+    response = @swarm.connection.post("/services/#{self.id}/update?version=#{version}", query, :body => opts.to_json)
   end
 
-
   def scale(count)
     @hash['Spec']['Mode']['Replicated']['Replicas'] = count
     self.update(@hash['Spec'])
   end
 
-  def self.create(opts = {}, conn = Docker.connection)
-    query = {}
-    response = conn.post('/services/create', query, :body => opts.to_json)
-    info = JSON.parse(response)
-    service_id = info['ID']
-    return self.find(service_id, conn)
-  end
-  
-  def self.find(id, conn = Docker.connection)
-    query = {}
-    opts = {}
-    response = conn.get("/services/#{id}", query, :body => opts.to_json)
-    hash = JSON.parse(response)
-    return Docker::Swarm::Service.new(hash, conn)
-  end
   
   
 end

data/lib/docker/swarm/swarm.rb

@@ -2,74 +2,171 @@ require 'docker-api'
 
 # This class represents a Docker Swarm Node.
 class Docker::Swarm::Swarm
-  attr_reader :worker_join_token, :manager_join_token, :id, :hash
+  include Docker
+  attr_reader :worker_join_token, :manager_join_token, :id, :hash, :node_hash
 
-  def initialize(hash, connection)
-    @connection = connection
+  def initialize(hash, manager_connection)
     @hash = hash
     @id = hash['ID']
     @worker_join_token = hash['JoinTokens']['Worker']
     @manager_join_token = hash['JoinTokens']['Manager']
-    @workers = []
+    manager_node = nodes(manager_connection).first
+    @node_hash = {}
+    @node_hash[manager_node.id] = {hash: manager_node.hash, connection: manager_connection}
   end
 
-  def join(worker_ip, worker_connection)
+  def join(node_connection, join_token)
+    node_ids_before = nodes().collect {|n| n.id}
     query = {}
-    master_ip = @connection.url.split("//").last.split(":").first
+    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",
-            "AdvertiseAddr" => "#{worker_ip}:2377",
+            "AdvertiseAddr" => "#{new_node_ip}:2377",
             "RemoteAddrs" => ["#{master_ip}:2377"],
-            "JoinToken" => @worker_join_token
+            "JoinToken" => join_token
           }
-    resp = worker_connection.post('/swarm/join', query, :body => join_options.to_json)
-    @workers << {address: worker_ip, connection: worker_connection}
+    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)
+        @node_hash[node.id] = {hash: node.hash, connection: node_connection}
+      end
+    end
+  end
+  
+  def connection
+    @node_hash.keys.each do |node_id|
+      node_info = @node_hash[node_id]
+      if (node_info[:hash]['ManagerStatus'])
+        return node_info[:connection]
+      end
+    end
+    raise "No manager connection found for swarm"
+  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
+    worker_nodes.each do |node|
+      leave(node, true)
+    end
+    manager_nodes.each do |node|
+      leave(node, true)
+    end
+  end
+  
+  def tasks
+    items = []
+    query = {}
+    opts = {}
+    resp = self.connection.get('/tasks', query, :body => opts.to_json)
+    hashes = JSON.parse(resp)
+    items = []
+    hashes.each do |hash|
+      items << Swarm::Task.new(self, hash)
+    end
+    return items
+  end
+
+  def leave(node, force = false)
+    node.connection = self.connection
+    node_info = @node_hash[node.id]
+    if (node_info)
+      Docker::Swarm::Swarm.leave(force, node_info[:connection])
+    end
+  end
+  
+  def remove_node(worker_node)
+    Swarm::Node.remove(worker_node.id, self.connection)
+  end
+  
   def manager_nodes
-    nodes = Docker::Swarm::Node.all({}, @connection)
-    nodes.select { |node|
-      node.role == :manager
-    }
+    return nodes.select { |node| node.role == :manager} || []
   end
 
   def worker_nodes
-    nodes = Docker::Swarm::Node.all({}, @connection)
-    nodes.select { |node|
-      node.role == :worker
-    }
+    return nodes.select { |node| node.role == :worker} || []
+  end
+  
+  def networks
+    networks = Docker::Network.all({}, self.connection)
+  end
+  
+  def create_network(network_name)
+    return Docker::Swarm::Network.create(network_name, opts = {}, self.connection)
+  end
+  
+  def find_network_by_name(network_name)
+    return Docker::Swarm::Network::find_by_name(network_name, self.connection)
+  end
+  
+  # Return all of the Nodes.
+  def nodes(conn = self.connection)
+    opts = {}
+    query = {}
+    response = conn.get('/nodes', query, :body => opts.to_json, expects: [200, 406], full_response: true)
+    if (response.status == 200)
+      hashes = JSON.parse(response.body)
+      nodes = []
+      hashes.each do |node_hash|
+        nodes << Docker::Swarm::Node.new(self, node_hash)
+      end
+      return nodes || []
+    else
+      return []
+    end
   end
 
-  def leave(force = true)
-    Docker::Swarm::Swarm.leave(force, @connection)
+  def create_service(opts = {})
+    query = {}
+    response = self.connection.post('/services/create', query, :body => opts.to_json)
+    info = JSON.parse(response)
+    service_id = info['ID']
+    return self.find_service(service_id)
+  end
+  
+  def find_service(id)
+    query = {}
+    opts = {}
+    response = self.connection.get("/services/#{id}", query, :body => opts.to_json)
+    hash = JSON.parse(response)
+    return Docker::Swarm::Service.new(self, hash)
   end
 
+
   # Initialize Swarm
-  def self.init(opts, conn = Docker.connection)
+  def self.init(opts, connection)
     query = {}
-    resp = conn.post('/swarm/init', query, :body => opts.to_json, full_response: true)
-    return Docker::Swarm::Swarm.swarm(opts, conn)
+    resp = connection.post('/swarm/init', query, :body => opts.to_json, full_response: true)
+    return Docker::Swarm::Swarm.swarm(opts, connection)
   end
 
   # docker swarm join-token -q worker
-  def self.swarm(opts, conn = Docker.connection)
+  def self.swarm(opts, connection)
     query = {}
-    resp = conn.get('/swarm', query, :body => opts.to_json, expects: [200, 406], full_response: true)
+    resp = connection.get('/swarm', query, :body => opts.to_json, expects: [200, 406], full_response: true)
     if (resp.status == 406)
       return nil
     elsif (resp.status == 200)
       hash = JSON.parse(resp.body)
-      return Docker::Swarm::Swarm.new(hash, conn)
+      return Docker::Swarm::Swarm.new(hash, connection)
     else
       raise "Bad response: #{resp.status} #{resp.body}"
     end
   end
   
-  def self.leave(force, conn = Docker.connection)
+  def self.leave(force, connection)
     query = {}
     query['force'] = force
-    conn.post('/swarm/leave', query, expects: [200, 406])
+    connection.post('/swarm/leave', query, expects: [200, 406])
   end
   
+  
 
 end

data/lib/docker/swarm/task.rb

@@ -3,8 +3,9 @@ class Docker::Swarm::Task
   #include Docker::Base
   attr_reader :hash
 
-  def initialize(hash)
+  def initialize(swarm, hash)
     @hash = hash
+    @swarm = swarm
   end
   
   def id 
@@ -31,17 +32,5 @@ class Docker::Swarm::Task
     @hash['Status']['State'].to_sym
   end
 
-  # Return all of the Nodes.
-  def self.all(opts = {}, conn = Docker.connection)
-    raise "opts needs to be hash" if (opts.class != Hash)
-    query = {}
-    resp = conn.get('/tasks', query, :body => opts.to_json)
-    hashes = JSON.parse(resp)
-    items = []
-    hashes.each do |hash|
-      items << Docker::Swarm::Task.new(hash)
-    end
-    return items
-  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.0'
+    VERSION = '1.1'
 
     # The version of the compatible Docker remote API.
     API_VERSION = '1.24'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: docker-swarm-api
 version: !ruby/object:Gem::Version
-  version: '1.0'
+  version: '1.1'
 platform: ruby
 authors:
 - Mike Moore / Rogue Wave Software
@@ -53,19 +53,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '6.0'
 - !ruby/object:Gem::Dependency
-  name: retries
+  name: retry_block
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.5
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement