docker-swarm-sdk 1.2.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 166f2d37a054fea0b51d90d32f48cdace6ccd133
+  data.tar.gz: 990589c2d8478c55dcb45ca6d868f034ceeb94f6
+SHA512:
+  metadata.gz: 4bafe8fd12192bb44d9d1074f08b385d1c38cf93583f5fed4f698021e1d1c3096d1ea5e262242173cf2ee2f0e09aef61345f2123aec78591f8b79008c22369ec
+  data.tar.gz: 271c2ea0d98e7a9ebe679b94f79f623bc691b08bb80e390949852ce834523d0f9f283bbb09acc7d51d5b563f27766cd37b8384e5e5899f95521c113b484b5b22

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Mike Moore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,103 @@
+# docker-swarm-api
+
+Ruby GEM providing API for managing Docker Swarm clusters.
+
+MIT License
+
+Must use Docker Engine Version of 1.12 or above.  Docker Engine version 1.12.5 required to make overlay networks with API.
+
+Must use Docker API Version of 1.24 or above.
+
+
+Docker Swarm is improving rapidly.  The controls for services has seen great improvements lately.  This GEM helps connect your Ruby scripts/applications to create and extend your swarm and then manage services upon the swarm.
+
+This project leverages swipely/docker-api (https://github.com/swipely/docker-api), and adds Docker Swarm capability.
+
+Sample Usage
+------------
+```ruby
+ # 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')
+
+# If swarm on the swarm master and using socket:
+master_connection = Docker::Swarm::Connection.new('unix:///var/run/docker.sock')
+
+ # Manager node intializes swarm
+swarm_init_options = { "ListenAddr" => "0.0.0.0:2377" }
+swarm = Docker::Swarm::Swarm.init(swarm_init_options, 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(worker_connection)
+
+# Worker joins without master api connection
+swarm_options = { "manager_ip" => "10.20.30.1", "node_ip" => "10.20.30.2", "JoinTokens" => {"Worker" => "FooBar" }}
+swarm = Docker::Swarm::Swarm.new(swarm_options)
+local_connection = Docker::Swarm::Connection.new('unix:///var/run/docker.sock')
+swarm.join_worker(local_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)
+
+# Manager joins without master api connection
+swarm_options = { "manager_ip" => "10.20.30.1", "node_ip" => "10.20.30.2", "JoinTokens" => {"Master" => "FooBar" }}
+swarm = Docker::Swarm::Swarm.new(swarm_options)
+local_connection = Docker::Swarm::Connection.new('unix:///var/run/docker.sock')
+swarm.join_manager(local_connection)
+
+ # Gather all nodes of swarm
+nodes = swarm.nodes()
+
+ # Create a network which connect services
+network = swarm.create_overlay_network(network_name)
+
+ # Find all networks in swarm cluster
+networks = swarm.networks()
+
+ # Create a service with 5 replicas
+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()
+
+ # Retrieve all worker nodes (that aren't managers)
+worker_nodes = swarm.worker_nodes()
+
+ # Drain a worker node - stop hosting tasks/containers of services
+worker_node = worker_nodes.first
+worker_node.drain()
+
+ # Gather all tasks (containers for service) being hosted by the swarm cluster
+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(worker_node, node)
+
+ # 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-sdk.rb

@@ -0,0 +1 @@
+require_relative './docker-swarm'

data/lib/docker-swarm.rb

@@ -0,0 +1,139 @@
+require 'cgi'
+require 'json'
+require 'excon'
+require 'tempfile'
+require 'base64'
+require 'find'
+require 'rubygems/package'
+require 'uri'
+require 'open-uri'
+
+# Add the Hijack middleware at the top of the middleware stack so it can
+# potentially hijack HTTP sockets (when attaching to stdin) before other
+# middlewares try and parse the response.
+require 'excon/middlewares/hijack'
+Excon.defaults[:middlewares].unshift Excon::Middleware::Hijack
+
+Excon.defaults[:middlewares] << Excon::Middleware::RedirectFollower
+
+# The top-level module for this gem. Its purpose is to hold global
+# configuration variables that are used as defaults in other classes.
+module Docker
+  module Swarm
+    attr_accessor :creds, :logger
+
+    require_relative './docker/swarm/node'
+    require_relative './docker/swarm/service'
+    require_relative './docker/swarm/swarm'
+    require_relative './docker/swarm/connection'
+    require_relative './docker/swarm/network'
+    require_relative './docker/swarm/task'
+
+    def default_socket_url
+      'unix:///var/run/docker.sock'
+    end
+
+    def env_url
+      ENV['DOCKER_URL'] || ENV['DOCKER_HOST']
+    end
+
+    def env_options
+      if cert_path = ENV['DOCKER_CERT_PATH']
+        {
+          client_cert: File.join(cert_path, 'cert.pem'),
+          client_key: File.join(cert_path, 'key.pem'),
+          ssl_ca_file: File.join(cert_path, 'ca.pem'),
+          scheme: 'https'
+        }.merge(ssl_options)
+      else
+        {}
+      end
+    end
+
+    def ssl_options
+      if ENV['DOCKER_SSL_VERIFY'] == 'false'
+        {
+          ssl_verify_peer: false
+        }
+      else
+        {}
+      end
+    end
+
+    def url
+      @url ||= env_url || default_socket_url
+      # docker uses a default notation tcp:// which means tcp://localhost:2375
+      if @url == 'tcp://'
+        @url = 'tcp://localhost:2375'
+      end
+      @url
+    end
+
+    def options
+      @options ||= env_options
+    end
+
+    def url=(new_url)
+      @url = new_url
+      reset_connection!
+    end
+
+    def options=(new_options)
+      @options = env_options.merge(new_options || {})
+      reset_connection!
+    end
+
+    def connection
+      @connection ||= Connection.new(url, options)
+    end
+
+    def reset!
+      @url = nil
+      @options = nil
+      reset_connection!
+    end
+
+    def reset_connection!
+      @connection = nil
+    end
+
+    # Get the version of Go, Docker, and optionally the Git commit.
+    def version(connection = self.connection)
+      Util.parse_json(connection.get('/version'))
+    end
+
+    # Get more information about the Docker server.
+    def info(connection = self.connection)
+      Util.parse_json(connection.get('/info'))
+    end
+
+    # Ping the Docker server.
+    def ping(connection = self.connection)
+      connection.get('/_ping')
+    end
+
+    # Login to the Docker registry.
+    def authenticate!(options = {}, connection = self.connection)
+      creds = options.to_json
+      connection.post('/auth', {}, :body => creds)
+      @creds = creds
+      true
+    rescue Docker::Error::ServerError, Docker::Error::UnauthorizedError
+      raise Docker::Error::AuthenticationError
+    end
+
+    # When the correct version of Docker is installed, returns true. Otherwise,
+    # raises a VersionError.
+    def validate_version!
+      Docker.info
+      true
+    rescue Docker::Error::DockerError
+      raise Docker::Error::VersionError, "Expected API Version: #{API_VERSION}"
+    end
+
+    module_function :default_socket_url, :env_url, :url, :url=, :env_options,
+                    :options, :options=, :creds, :creds=, :logger, :logger=,
+                    :connection, :reset!, :reset_connection!, :version, :info,
+                    :ping, :authenticate!, :validate_version!, :ssl_options
+  end
+end

data/lib/docker/swarm/connection.rb

@@ -0,0 +1,21 @@
+# This class represents a Connection to a Docker server. The Connection is
+# immutable in that once the url and options is set they cannot be changed.
+class Docker::Swarm::Connection < Docker::Connection
+  
+  def initialize(url, opts = {})
+    super(url, opts)
+  end
+  
+
+  # Send a request to the server with the `
+  def request(*args, &block)
+    request = compile_request_params(*args, &block)
+    log_request(request)
+    if (args.last[:full_response] == true)
+      resource.request(request)
+    else
+      resource.request(request).body
+    end
+  end
+
+end

data/lib/docker/swarm/network.rb

@@ -0,0 +1,68 @@
+require 'docker-api'
+
+class Docker::Swarm::Network 
+  attr_reader :hash
+  
+  def initialize(swarm, hash)
+    @hash = hash
+    @swarm = swarm
+  end
+  
+  def connection
+    return @swarm.connection
+  end
+  
+  def id
+    return @hash['Id']
+  end
+  
+  def name
+    return @hash['Name']
+  end
+
+  def driver
+    return @hash['Driver']
+  end
+  
+  def subnets
+    if (@hash['IPAM']) && (@hash['IPAM']['Config'])
+      return @hash['IPAM']['Config']
+    end
+    return []
+  end
+
+  def remove
+    if (@swarm)
+      @swarm.nodes.each do |node|
+        node.remove_network(self)
+      end
+    end
+  end
+  
+end
+
+# EXAMPLE INSPECT OF OVERLAY NETWORK:
+# {
+#         "Name": "overlay1",
+#         "Id": "3eluvldbrv17xw6w39xxgg30a",
+#         "Scope": "swarm",
+#         "Driver": "overlay",
+#         "EnableIPv6": false,
+#         "IPAM": {
+#             "Driver": "default",
+#             "Options": null,
+#             "Config": [
+#                 {
+#                     "Subnet": "10.0.9.0/24",
+#                     "Gateway": "10.0.9.1"
+#                 }
+#             ]
+#         },
+#         "Internal": false,
+#         "Containers": null,
+#         "Options": {
+#             "com.docker.network.driver.overlay.vxlanid_list": "257"
+#         },
+#         "Labels": null
+#     }
+    

data/lib/docker/swarm/node.rb

@@ -0,0 +1,191 @@
+# This class represents a Docker Swarm Node.
+class Docker::Swarm::Node
+  attr_reader :hash, :swarm
+  AVAILABILITY = {
+    active: "active",
+    drain:  "drain"
+  }
+
+  def initialize(swarm, hash)
+    @hash = hash
+    @swarm = swarm
+  end
+  
+  def refresh
+    query = {}
+    response = @swarm.connection.get("/nodes/#{id}", query, expects: [200])
+    @hash = JSON.parse(response)
+  end
+  
+  def id 
+    return @hash['ID']
+  end
+  
+  def host_name
+    return @hash['Description']['Hostname']
+  end
+  
+  def connection
+    if (@swarm) && (@swarm.node_hash[id()])
+      return @swarm.node_hash[id()][:connection]
+    else
+      return nil
+    end
+  end
+  
+  def role
+    if (@hash['Spec']['Role'] == "worker")
+      return :worker
+    elsif (@hash['Spec']['Role'] == "manager")
+      return :manager
+    else
+      raise "Couldn't determine machine role from spec: #{@hash['Spec']}"
+    end
+  end
+  
+  def availability
+    return @hash['Spec']['Availability'].to_sym
+  end
+  
+  def status
+    return @hash['Status']['State']
+  end
+  
+  def drain(opts = {})
+    change_availability(:drain)
+    if (opts[:wait_for_drain])
+      opts[:wait_seconds]
+      while (running_tasks.length > 0)
+        puts "Waiting for node (#{host_name}) to drain.  Still has #{running_tasks.length} tasks running."
+      end
+    end
+  end
+  
+  def swarm_connection
+    node_hash = @swarm.node_hash[self.id]
+    if (node_hash)
+      return node_hash[:connection]
+    end
+    return nil
+  end
+
+  
+  def running_tasks
+    return tasks.select {|t| t.status == 'running'}
+  end
+  
+  def tasks
+    return @swarm.tasks.select {|t| 
+      (t.node != nil) && (t.node.id == self.id)
+    }
+  end
+
+  def activate
+    change_availability(:active)
+  end
+  
+  def remove
+    leave(true)
+    refresh
+    start_time = Time.now
+    while (self.status != 'down')
+      refresh
+      raise "Node not down 60 seconds after leaving swarm: #{self.host_name}" if (Time.now.to_i - start_time.to_i > 60)
+    end
+    Docker::Swarm::Node.remove(self.id, @swarm.connection)
+  end
+  
+  
+  def remove_network_with_name(network_name)
+    network = find_network_by_name(network_name)
+    self.remove_network(network) if (network)
+  end
+  
+  def remove_network(network)
+    attempts = 0
+    if (self.connection == nil)
+      puts "Warning:  node asked to remove network, but no connection for node: #{self.id} #{self.host_name}"
+    else
+      while (self.find_network_by_id(network.id) != nil)
+        response = self.connection.delete("/networks/#{network.id}", {}, expects: [204, 404, 500], full_response: true)
+        if (response.status == 500)
+          puts "Warning:  Deleting network (#{network.name}) from #{self.host_name} returned HTTP-#{response.status}  #{response.body}"
+        end
+  
+        sleep 1
+        attempts += 1
+        if (attempts > 30)
+          raise "Failed to remove network: #{network.name} from #{self.host_name}, operation timed out. Response: HTTP#{response.status}  #{response.body}"
+        end
+      end
+    end
+  end
+  
+  
+  def leave(force = true)
+    drain(wait_for_drain: true, wait_seconds: 60)
+    # change_availability(:active)
+    @swarm.leave(self, force)
+  end
+  
+  def change_availability(new_availability)
+    raise "Bad availability param: #{availability}" if (!AVAILABILITY[availability])
+    refresh
+    if (self.availability != new_availability)
+      @hash['Spec']['Availability'] = AVAILABILITY[new_availability]
+      query = {version: @hash['Version']['Index']}
+      response = @swarm.connection.post("/nodes/#{self.id}/update", query, :body => @hash['Spec'].to_json, expects: [200, 500], full_response: true)
+      if (response.status != 200)
+        raise "Error changing node availability: #{response.body} HTTP-#{response.status}"
+      end
+    end
+  end
+  
+  def networks()
+    if (connection)
+      return Docker::Swarm::Node.networks_on_host(connection, @swarm)
+    else
+      debugger
+      raise "No connection set for node: #{self.host_name}, ID: #{self.id}"
+    end
+  end
+  
+  def find_network_by_name(network_name)
+    networks.each do |network|
+      if (network.name == network_name)
+        return network
+      end
+    end
+    return nil
+  end
+
+  def find_network_by_id(network_id)
+    networks.each do |network|
+      if (network.id == network_id)
+        return network
+      end
+    end
+    return nil
+  end
+  
+  
+  def self.remove(node_id, connection)
+    query = {}
+    response = connection.delete("/nodes/#{node_id}", query, expects: [200, 406, 500], full_response: true)
+    if (response.status != 200)
+      raise "Error deleting node: HTTP-#{response.status} #{response.body}"
+    end
+  end
+  
+  def self.networks_on_host(connection, swarm)
+    networks = []
+    response = connection.get("/networks", {}, full_response: true, expects: [200])
+    network_hashes = JSON.parse(response.body)
+    network_hashes.each do |network_hash|
+      networks << Docker::Swarm::Network.new(swarm, network_hash)
+    end
+    return networks
+  end
+  
+  
+end

data/lib/docker/swarm/service.rb

@@ -0,0 +1,121 @@
+require 'docker-api'
+require 'active_support'
+
+class Docker::Swarm::Service
+  attr_reader :hash
+
+  def initialize(swarm, hash)
+    @swarm = swarm
+    @hash = hash
+  end
+
+  def name()
+    @hash['Spec']['Name']
+  end
+
+  def id()
+    return @hash['ID']
+  end
+
+  def reload()
+    s = @swarm.find_service(id())
+    @hash = s.hash
+    return self
+  end
+
+  def network_ids
+    network_ids = []
+    if (@hash['Endpoint']['VirtualIPs'])
+      @hash['Endpoint']['VirtualIPs'].each do |network_info|
+        network_ids << network_info['NetworkID']
+      end
+    end
+    return network_ids
+  end
+
+  def remove(opts = {})
+    query = {}
+    @swarm.connection.delete("/services/#{self.id}", query, :body => opts.to_json)
+  end
+
+  def update(options = {})
+    specs = @hash['Spec'].deep_merge(options)
+    query = {}
+    version = @hash['Version']['Index']
+    response = @swarm.connection.post("/services/#{self.id}/update?version=#{version}", query, :body => specs.to_json)
+  end
+
+  def restart
+    options = {}
+    options['TaskTemplate'] = {'ForceUpdate' => 1}
+    update(options)
+  end
+
+  def scale(count)
+    @hash['Spec']['Mode']['Replicated']['Replicas'] = count
+    self.update(@hash['Spec'])
+  end
+
+  def replicas
+    @hash['Spec']['Mode']['Replicated']['Replicas']
+  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

@@ -0,0 +1,374 @@
+require 'docker-api'
+require 'resolv'
+
+
+# This class represents a Docker Swarm Node.
+class Docker::Swarm::Swarm
+  include Docker
+  attr_reader :node_ip, :manager_ip, :worker_join_token, :manager_join_token, :id, :hash, :node_hash
+
+  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 update_data(hash)
+    @hash = hash
+  end
+
+  def socket_connection(node_connection)
+    node_connection.url.include?('unix:///')
+  end
+
+  def join(node_connection, node_ip = nil, manager_ip = nil, join_token = nil, listen_address = "0.0.0.0:2377")
+    node_ids_before = []
+    query = {}
+
+    unless socket_connection(node_connection)
+      node_ids_before = nodes().collect {|n| n.id}
+      node_ip = node_connection.url.split("//").last.split(":").first
+      manager_ip = self.connection.url.split("//").last.split(":").first
+    end
+
+    join_options = {
+            "ListenAddr" => "#{listen_address}",
+            "AdvertiseAddr" => "#{node_ip}:2377",
+            "RemoteAddrs" => ["#{manager_ip}:2377"],
+            "JoinToken" => join_token
+          }
+
+    new_node = nil
+    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 unless socket_connection(node_connection)
+      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
+  end
+
+  def join_worker(node_connection, listen_address = "0.0.0.0:2377")
+    join(node_connection, @node_ip, @manager_ip, @worker_join_token)
+  end
+
+  def join_manager(node_connection, listen_address = "0.0.0.0:2377")
+    join(node_connection, @node_ip, @manager_ip, @manager_join_token, listen_address)
+  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
+    return @manager_connection
+  end
+
+  def remove
+    services().each do |service|
+      service.remove()
+    end
+
+    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_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
+    return nodes.select { |node| node.role == :manager} || []
+  end
+
+  def worker_nodes
+    return nodes.select { |node| node.role == :worker} || []
+  end
+
+  def networks
+    all_networks = []
+    response = connection.get("/networks", {}, full_response: true)
+    if (response.status == 200)
+      hashes = JSON.parse(response.body)
+      hashes.each do |hash|
+        all_networks << Docker::Swarm::Network.new(self, hash)
+      end
+    else
+      raise "Error finding netw"
+    end
+    return all_networks
+  end
+
+  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)
+    subnet_16_parts = [10, 10, 0, 0]
+    max_vxlanid = 200
+
+    # Sometimes nodes have leftover networks not on other nodes, that have subnets that can't be duplicated in
+    # the new overlay network.
+    nodes.each do |node|
+      node.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
+
+        # Make sure our new network doesn't duplicate subnet of other network.
+        if (network.hash['IPAM']) && (network.hash['IPAM']['Config'])
+          network.hash['IPAM']['Config'].each do |subnet_config|
+            if (subnet_config['Subnet'])
+              subnet = subnet_config['Subnet']
+              subnet = subnet.split(".")
+              if (subnet[0] == '10') && (subnet[1] == '255')
+              else
+                if (subnet[0].to_i == subnet_16_parts[0])
+                  if (subnet[1].to_i >= subnet_16_parts[1])
+                    subnet_16_parts[1] = subnet[1].to_i + 1
+                    if (subnet_16_parts[1] >= 255)
+                      raise "Ran out of subnets"
+                    end
+                  end
+                end
+              end
+  #            subnet_config['Gateway']
+            end
+          end
+        end
+      end
+    end
+
+
+    options = {
+        "Name" => network_name,
+        "CheckDuplicate" => true,
+        "Driver" => "overlay",
+        "EnableIPv6" => false,
+        "IPAM" => {
+          "Driver" => "default",
+          "Config" => [
+            {
+             "Subnet" => "#{subnet_16_parts.join(".")}/16",
+             "Gateway"=> "#{subnet_16_parts[0, 3].join('.')}.1"
+           }
+          ],
+           "Options" => {
+           }
+        },
+        "Internal" => false,
+        "Options" => {
+          "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"
+        }
+      }
+      create_network(options)
+  end
+
+  # Return all of the Nodes.
+  def nodes
+    opts = {}
+    query = {}
+    response = self.connection.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|
+        node  = Docker::Swarm::Node.new(self, node_hash)
+        nodes << node
+      end
+      return nodes || []
+    else
+      return []
+    end
+  end
+
+  def create_service(opts = {})
+    query = {}
+    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']
+      return self.find_service(service_id)
+    else
+      raise "Error creating service:  HTTP-#{response.status}  #{response.body}"
+    end
+    return nil
+  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
+
+  def find_service_by_name(name)
+    services.each do |service|
+      return service if (service.name == name)
+    end
+    return nil
+  end
+
+  def services
+    items = []
+    query = {}
+    opts = {}
+    response = self.connection.get("/services", query, :body => opts.to_json)
+    hashes = JSON.parse(response)
+    hashes.each do |hash|
+      items << Docker::Swarm::Service.new(self, hash)
+    end
+    return items
+  end
+
+
+  # Initialize Swarm
+  def self.init(opts, connection)
+    query = {}
+    resp = connection.post('/swarm/init', query, :body => opts.to_json, full_response: true, expects: [200, 404, 406, 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)
+      }
+      byebug
+      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(connection, options = {})
+    query = {}
+    resp = connection.get('/swarm', query, :body => options.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)
+      swarm = self.find_swarm_for_id(hash['ID'])
+      if (swarm)
+        swarm.update_data(hash)
+      else
+        swarm = Docker::Swarm::Swarm.new(hash, connection, options)
+      end
+    else
+      raise "Bad response: #{resp.status} #{resp.body}"
+    end
+  end
+
+  def self.leave(force, connection)
+    query = {}
+    query['force'] = force
+    response = connection.post('/swarm/leave', query, expects: [200, 406, 500], full_response: true)
+    if (response.status == 500)
+      raise "Error leaving: #{response.body}  HTTP-#{response.status}"
+    end
+  end
+
+  def self.find(connection, options = {})
+    query = {}
+    response = connection.get('/swarm', query, expects: [200, 404, 406], full_response: true)
+    if (response.status == 200)
+      hash = JSON.parse(response.body)
+      swarm = self.find_swarm_for_id(hash['ID'])
+      if (swarm)
+        swarm.update_data(hash)
+      else
+        swarm = Docker::Swarm::Swarm.new(hash, connection, options)
+      end
+      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 > 200)
+      return nil
+    else
+      raise "Error finding swarm: HTTP-#{response.status} #{response.body}"
+    end
+  end
+
+
+ private
+ @@swarms = {}
+
+ def self.find_swarm_for_id(swarm_id)
+   return @@swarms[swarm_id]
+ end
+
+ def initialize(hash, manager_connection = nil, options = {})
+   @hash = hash
+   @id = hash['ID']
+   @node_ip = hash['node_ip']
+   @manager_ip = hash['manager_ip']
+   @worker_join_token = hash['JoinTokens']['Worker']
+   @manager_join_token = hash['JoinTokens']['Manager']
+   @node_hash = {}
+   @manager_connection = manager_connection
+   @@swarms[@id] = self
+ end
+
+
+
+
+end

data/lib/docker/swarm/task.rb

@@ -0,0 +1,64 @@
+# This class represents a Docker Swarm Node.
+class Docker::Swarm::Task
+  #include Docker::Base
+  attr_reader :hash
+
+  def initialize(swarm, hash)
+    @hash = hash
+    @swarm = swarm
+  end
+
+  def id
+    return @hash['ID']
+  end
+
+  def image
+    return @hash['Spec']['ContainerSpec']['Image']
+  end
+
+  def service_id
+    @hash['ServiceID']
+  end
+
+  def service
+    return @swarm.services.find { |service|
+      self.service_id == service.id
+    }
+  end
+
+  def node_id
+    @hash['NodeID']
+  end
+
+  def node
+    return @swarm.nodes.find {|n| n.id == self.node_id}
+  end
+
+  def created_at
+    return DateTime.parse(@hash.first['CreatedAt'])
+  end
+
+  def status
+    @hash['Status']['State'].to_sym
+  end
+
+  def status_timestamp
+    return DateTime.parse(@hash['Status']['Timestamp'])
+  end
+
+  def status_message
+    @hash['Status']['Message']
+  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

@@ -0,0 +1,9 @@
+module Docker
+  module Swarm
+    # The version of this gem.
+    VERSION = '1.2.5'
+
+    # The version of the compatible Docker remote API.
+    API_VERSION = '1.24'
+  end
+end

metadata

@@ -0,0 +1,209 @@
+--- !ruby/object:Gem::Specification
+name: docker-swarm-sdk
+version: !ruby/object:Gem::Version
+  version: 1.2.5
+platform: ruby
+authors:
+- Mike Moore
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.33.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.33.1
+- !ruby/object:Gem::Dependency
+  name: retry_block
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.4
+- !ruby/object:Gem::Dependency
+  name: single_cov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.8
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+description: API for creating container clusters and services using Docker Swarm.  Includes
+  service, node, task management
+email: m.moore.denver@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/docker-swarm-sdk.rb
+- lib/docker-swarm.rb
+- lib/docker/swarm/connection.rb
+- lib/docker/swarm/network.rb
+- lib/docker/swarm/node.rb
+- lib/docker/swarm/service.rb
+- lib/docker/swarm/swarm.rb
+- lib/docker/swarm/task.rb
+- lib/docker/swarm/version.rb
+homepage: https://github.com/mikejmoore/docker-swarm-api
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Ruby API for Docker Swarm
+test_files: []