algo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bb278f86fccf497cb5ece005a59c45ac56929fef
+  data.tar.gz: 8cf7c48ff992326edf08c6500cb48de73e8be902
+SHA512:
+  metadata.gz: 4b3a4d6561a8adda98ad72b85e5b6e22896e5b8fad5f719adc81b9702b5b7bbcd416b50d9c04e02516cc1bb5aad81b4493d0533d82927875a9babb2f797c646c
+  data.tar.gz: d54c9d0a2d304a8fbf8fa635f988241ba2f4b925b0c787034d93cbbc2413368287470041a2b6fcaf4a44aecd78b8006fe12aa3f1610947599860a166abbd379e

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.12.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in algo.gemspec
+gemspec

data/README.md

@@ -0,0 +1,132 @@
+# Algo
+Docker container orchestration tool for swarm cluster.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'algo'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install algo
+
+
+## Usage
+
+### Definition
+
+```rb
+cluster 'awesomecluster' do
+
+  # Define service/network prefix for cluster
+  prefix 'awsm'
+
+  # Define cluster wide available environment variable
+  env 'CLUSTER_ENV', 'PRODUCTION'
+
+  # Define cluster wide available label
+  label 'com.example.sample', 'clusterwidelabel'
+
+  # Define network
+  network 'net1'
+
+  # Define service
+  service 'name' do
+    image 'quay.io/yss44/curl'
+    replicas 3
+    command 'sh'
+    args '-ic', "while true; do curl -s awsm-nginx > /dev/null; echo $?; sleep 3; done"
+
+    update_parallelism 2
+
+    # Service related environment variable
+    env 'APP_DOMAIN', 'example.com'
+
+    network 'net1'
+  end
+
+  # Define another service
+  service 'nginx' do
+    image 'nginx:alpine'
+    replicas 2
+    network 'net1'
+  end
+
+end
+```
+
+### Execution
+
+```sh
+# Prepare playground for algo
+docker-machine create --driver virtualbox \
+                      --virtualbox-boot2docker-url="https://github.com/boot2docker/boot2docker/releases/download/v1.12.0-rc4/boot2docker-experimental.iso" \
+                      algo
+eval $(docker-machine env algo)
+
+# Create initial cluster
+algo apply examples/awesomecluster.rb
+# Applying to cluster awesomecluster...
+# network: awsm-net1, status: created
+# service: awsm-name, status: created
+# service: awsm-nginx, status: created
+# Complete applying for cluster awesomecluster!
+
+# Change configuration
+sed -i s/replicas 2/replicas 1/g examples/awesomecluster.rb
+
+# Dry-run
+algo apply examples/awesomecluster.rb --dry-run
+# Running with dry-run mode...
+# Applying to cluster awesomecluster...
+# network: awsm-net1, status: ok
+# service: awsm-name, status: ok
+# service: awsm-nginx, status: changed
+# Complete applying for cluster awesomecluster!
+
+# Apply changes
+algo apply examples/awesomecluster.rb --dry-run
+# Applying to cluster awesomecluster...
+# network: awsm-net1, status: ok
+# service: awsm-name, status: ok
+# service: awsm-nginx, status: changed
+# Complete applying for cluster awesomecluster!
+
+# Dry-run terminating cluster
+algo apply examples/awesomecluster.rb --dry-run
+# Running with dry-run mode...
+# Terminating cluster awesomecluster...
+# service: awsm-name, status: removed
+# service: awsm-nginx, status: removed
+# network: awsm-net1, status: removed
+# Complete Termination for cluster awesomecluster...
+
+# Terminate cluster
+algo apply examples/awesomecluster.rb
+# Terminating cluster awesomecluster...
+# service: awsm-name, status: removed
+# service: awsm-nginx, status: removed
+# network: awsm-net1, status: removed
+# Complete Termination for cluster awesomecluster...
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/yoshiso/algo/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/algo.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'algo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "algo"
+  spec.version       = Algo::VERSION
+  spec.authors       = ["yoshiso"]
+  spec.email         = ["nya060@gmail.com"]
+
+  spec.summary       = %q{Docker container orchestration tool for swarm cluster.}
+  spec.description   = %q{Docker container orchestration tool for swarm cluster.}
+  spec.homepage      = "https://github.com/yoshiso/algo"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'activesupport', '~> 4.0'
+  spec.add_dependency 'excon', '0.51.0'
+  spec.add_dependency 'thor'
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry", "~> 0.10"
+end

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "algo"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/awesome-cluster.rb

@@ -0,0 +1,36 @@
+cluster 'awesomecluster' do
+
+  # Define service/network prefix for cluster
+  prefix 'awsm'
+
+  # Define cluster wide available environment variable
+  env 'CLUSTER_ENV', 'PRODUCTION'
+
+  # Define cluster wide available label
+  label 'com.example.sample', 'clusterwidelabel'
+
+  # Define network
+  network 'net1'
+
+  # Define service
+  service 'name' do
+    image 'quay.io/yss44/curl'
+    replicas 3
+    command 'sh'
+    args '-ic', "while true; do curl -s awsm-nginx > /dev/null; echo $?; sleep 3; done"
+
+    update_parallelism 2
+
+    env 'APP_DOMAIN', 'example.com'
+
+    network 'net1'
+  end
+
+  # Define another service
+  service 'nginx' do
+    image 'nginx:alpine'
+    replicas 2
+    network 'net1'
+  end
+
+end

data/exe/algo

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "algo"
+
+Algo::Cli.start

data/lib/algo/cli.rb

@@ -0,0 +1,155 @@
+module Algo
+  class Cli < Thor
+    class ValidationError < StandardError; end
+
+    class ServiceValidator
+      def initialize srv_spec
+        @srv_spec = srv_spec
+      end
+
+      def validate
+        begin
+          @srv = Algo::Docker::Service.find(@srv_spec['Name'])
+        rescue Algo::Docker::Error::NotFoundError
+          @srv = nil
+        end
+        check_networks
+      end
+
+      def self.validate srv_spec
+        new(srv_spec).validate
+      end
+
+      private
+
+      def check_networks
+        return true if @srv.blank? or @srv.spec.networks.blank?
+        srv_networks = @srv.spec.networks.map { |n| { 'Target' => n.info['Name'] } }
+        unless srv_networks != @srv_spec['Networks']
+          @srv_spec['Networks'] = @srv.spec.networks.map { |n| { 'Target' => n.info['Id'] } }
+          return true
+        end
+        raise ValidationError, 'changing network in service is not supported'
+      end
+    end
+
+    class ServiceUpdator
+
+      def initialize srv_spec, options
+        @srv_spec = srv_spec
+        @options = options
+      end
+
+      def update
+        begin
+          srv = Algo::Docker::Service.find(@srv_spec['Name'])
+          if srv.raw_spec == @srv_spec
+            puts "service: #{@srv_spec['Name']}, status: ok"
+            return
+          end
+          srv.update @srv_spec unless dryrun?
+          puts "service: #{@srv_spec['Name']}, status: changed"
+        rescue Algo::Docker::Error::NotFoundError
+          Algo::Docker::Service.create(@srv_spec) unless dryrun?
+          puts "service: #{@srv_spec['Name']}, status: created"
+        end
+      end
+
+      def self.update srv_spec, dryrun=false
+        new(srv_spec, {dryrun: dryrun}).update
+      end
+
+      private
+
+      def dryrun?
+        @options[:dryrun]
+      end
+    end
+
+    desc 'apply [INVENTRY_FILE]', 'Apply configuration to clusters'
+    option :'dry-run', type: :boolean, default: false
+    option :'url', type: :string, desc: 'docker swarm url like tcp://localhost:2375'
+    option :'client_key', type: :string, desc: 'docker swarm client key path'
+    option :'client_sert', type: :string, desc: 'docker swarm client sert path'
+    option :'ssl_ca_file', type: :string, desc: 'docker swarm ssl ca file path'
+    option :'scheme', type: :string, desc: 'docker swarm connection scheme'
+    def apply inventry
+      Algo::Docker.url = options[:host] if options[:host]
+      Algo::Docker.options = docker_opts if docker_opts.present?
+      puts 'Running with dry-run mode...' if options[:'dry-run']
+      configuration = Algo::Dsl.load({}, inventry)
+      configuration.each do |cluster|
+        puts "Applying to cluster #{cluster['name']}..."
+
+        cluster['networks'].each do |net_spec|
+          begin
+            net = Algo::Docker::Network.find net_spec['Name']
+            puts "network: #{net_spec['Name']}, status: ok"
+          rescue Algo::Docker::Error::NotFoundError
+            Algo::Docker::Network.create net_spec unless options[:'dry-run']
+            puts "network: #{net_spec['Name']}, status: created"
+          end
+        end
+
+        cluster['services'].each do |srv_spec|
+          ServiceValidator.validate srv_spec
+        end
+        cluster['services'].each do |srv_spec|
+          ServiceUpdator.update srv_spec, options[:'dry-run']
+        end
+        Algo::Docker::Service.all
+          .select { |srv| srv.spec.name.start_with?("#{cluster['prefix']}-") }
+          .select { |srv| ! srv.spec.name.in? cluster['services'].map { |spec| spec['Name'] } }
+          .map { |srv|
+            srv_name = srv.spec.name
+            srv.remove unless options[:'dry-run']
+            puts "service: #{srv_name}, status: removed"
+          }
+        Algo::Docker::Network.all(skip_default=true)
+          .select { |net| net.info['Name'].start_with?("#{cluster['prefix']}-") }
+          .select { |net| ! net.info['Name'].in? cluster['networks'].map { |net_spec| net_spec['Name'] } }
+          .map { |net|
+            net_name = net.info['Name']
+            net.remove unless options[:'dry-run']
+            puts "network: #{net_name}, status: removed"
+          }
+        puts "Complete applying for cluster #{cluster['name']}!"
+      end
+    rescue ValidationError => e
+      puts 'configuration validation failed because ' + e.message
+    end
+
+    desc 'rm [INVENTRY_FILE]', 'Terminate clusters'
+    option :'dry-run', type: :boolean, default: false
+    def rm inventry
+      puts 'Running with dry-run mode...' if options[:'dry-run']
+      configuration = Algo::Dsl.load({}, inventry)
+      configuration.each do |cluster|
+        puts "Terminating cluster #{cluster['name']}..."
+        Algo::Docker::Service.all
+          .select { |srv| srv.spec.name.start_with?("#{cluster['prefix']}-") }
+          .map { |srv|
+            srv_name = srv.spec.name
+            srv.remove unless options[:'dry-run']
+            puts "service: #{srv_name}, status: removed"
+          }
+        Algo::Docker::Network.all(skip_default=true)
+          .select { |net| net.info['Name'].start_with?("#{cluster['prefix']}-") }
+          .select { |net| ! net.info['Name'].in? cluster['networks'].map { |net_spec| "#{cluster['prefix']}-#{net_spec['Name']}" } }
+          .map { |net|
+            net_name = net.info['Name']
+            net.remove unless options[:'dry-run']
+            puts "network: #{net_name}, status: removed"
+          }
+        puts "Complete Termination for cluster #{cluster['name']}..."
+      end
+    end
+
+    private
+
+    def docker_opts
+      options.slice(:client_key, :client_sert, :ssl_ca_file, :scheme)
+    end
+
+  end
+end

data/lib/algo/docker/base.rb

@@ -0,0 +1,26 @@
+module Algo
+  module Docker
+    class Base
+      include Docker::Error
+
+      attr_reader :id, :info
+
+      def initialize(connection, hash={})
+        unless connection.is_a?(Docker::Connection)
+          raise ArgumentError, "Expected a Docker::Connection, got: #{connection}."
+        end
+        normalize_hash(hash)
+        @connection, @info, @id = connection, hash, hash['Id']
+        raise ArgumentError, "Must have id, got: #{hash}" unless @id
+      end
+
+      private
+      attr_accessor :connection
+
+      def normalize_hash(hash)
+        hash["Id"] ||= hash.delete("ID")
+      end
+
+    end
+  end
+end

data/lib/algo/docker/connection.rb

@@ -0,0 +1,98 @@
+module Algo
+  module Docker
+    class Connection
+      include Docker::Error
+      attr_reader :url, :options
+
+      # Create a new Connection. This method takes a url (String) and options
+      # (Hash). These are passed to Excon, so any options valid for `Excon.new`
+      # can be passed here.
+      def initialize(url, opts)
+        case
+        when !url.is_a?(String)
+          raise ArgumentError, "Expected a String, got: '#{url}'"
+        when !opts.is_a?(Hash)
+          raise ArgumentError, "Expected a Hash, got: '#{opts}'"
+        else
+          uri = URI.parse(url)
+          if uri.scheme == "unix"
+            @url, @options = 'unix:///', {:socket => uri.path}.merge(opts)
+          elsif uri.scheme =~ /^(https?|tcp)$/
+            @url, @options = url, opts
+          else
+            @url, @options = "http://#{uri}", opts
+          end
+        end
+      end
+
+      # The actual client that sends HTTP methods to the Docker server. This value
+      # is not cached, since doing so may cause socket errors after bad requests.
+      def resource
+        Excon.new(url, options)
+      end
+      private :resource
+
+      # Send a request to the server with the `
+      def request(*args, &block)
+        request = compile_request_params(*args, &block)
+        # log_request(request)
+        response = resource.request(request).body
+        JSON.parse(response) unless response.blank?
+      rescue Excon::Errors::BadRequest => ex
+        raise ClientError, ex.response.body
+      rescue Excon::Errors::Unauthorized => ex
+        raise UnauthorizedError, ex.response.body
+      rescue Excon::Errors::NotFound => ex
+        raise NotFoundError, ex.response.body
+      rescue Excon::Errors::Conflict => ex
+        raise ConflictError, ex.response.body
+      rescue Excon::Errors::InternalServerError => ex
+        raise ServerError, ex.response.body
+      rescue Excon::Errors::Timeout => ex
+        raise TimeoutError, ex.message
+      end
+
+      # def log_request(request)
+      #   if Docker.logger
+      #     Docker.logger.debug(
+      #       [request[:method], request[:path], request[:query], request[:body]]
+      #     )
+      #   end
+      # end
+
+      # Delegate all HTTP methods to the #request.
+      [:get, :put, :post, :delete].each do |method|
+        define_method(method) { |*args, &block| request(method, *args, &block) }
+      end
+
+      def to_s
+        "Docker::Connection { :url => #{url}, :options => #{options} }"
+      end
+
+    private
+      # Given an HTTP method, path, optional query, extra options, and block,
+      # compiles a request.
+      def compile_request_params(http_method, path, query = nil, opts = nil, &block)
+        query ||= {}
+        opts ||= {}
+        headers = opts.delete(:headers) || {}
+        content_type = opts[:body].nil? ?  'text/plain' : 'application/json'
+        user_agent = "github.com:yoshiso/algo v#{Algo::VERSION}"
+        {
+          :method        => http_method,
+          :path          => "/v#{Docker::API_VERSION}#{path}",
+          :query         => query,
+          :headers       => { 'Content-Type' => content_type,
+                              'User-Agent'   => user_agent,
+                            }.merge(headers),
+          :expects       => (200..204).to_a << 304,
+          :idempotent    => http_method == :get,
+          :request_block => block
+        }.merge(opts).reject { |_, v| v.nil? }
+      end
+
+
+    end
+
+  end
+end

data/lib/algo/docker/error.rb

@@ -0,0 +1,44 @@
+# This module holds the Errors for the gem.
+module Algo
+  module Docker
+    module Error
+
+      # The default error. It's never actually raised, but can be used to catch all
+      # gem-specific errors that are thrown as they all subclass from this.
+      class DockerError < StandardError; end
+
+      # Raised when invalid arguments are passed to a method.
+      class ArgumentError < DockerError; end
+
+      # Raised when a request returns a 400.
+      class ClientError < DockerError; end
+
+      # Raised when a request returns a 401.
+      class UnauthorizedError < DockerError; end
+
+      # Raised when a request returns a 404.
+      class NotFoundError < DockerError; end
+
+      # Raised when a request returns a 409.
+      class ConflictError < DockerError; end
+
+      # Raised when a request returns a 500.
+      class ServerError < DockerError; end
+
+      # Raised when there is an unexpected response code / body.
+      class UnexpectedResponseError < DockerError; end
+
+      # Raised when there is an incompatible version of Docker.
+      class VersionError < DockerError; end
+
+      # Raised when a request times out.
+      class TimeoutError < DockerError; end
+
+      # Raised when login fails.
+      class AuthenticationError < DockerError; end
+
+      # Raised when an IO action fails.
+      class IOError < DockerError; end
+    end
+  end
+end

data/lib/algo/docker/network.rb

@@ -0,0 +1,43 @@
+module Algo
+  module Docker
+    class Network < Base
+      DEFAULT_NETWORKS = %w(ingress none host bridge docker_gwbridge)
+
+      def inspect
+          "<Algo::Docker::Network name=#{info['Name']} scope=#{info['Scope']}>"
+      end
+
+      def info
+        @info = self.class.find(@info["Id"]).info unless @info["Name"]
+        @info
+      end
+
+      def to_h
+        @info
+      end
+
+      def remove
+        self.class.remove @info['Id']
+      end
+
+      def self.find(id, conn=Docker.connection)
+        new(conn, conn.get("/networks/#{id}"))
+      end
+
+      def self.remove(id_or_name, conn=Docker.connection)
+        conn.delete("/networks/#{id_or_name}")
+      end
+
+      def self.create(init_spec, conn=Docker.connection)
+        new(conn, conn.post("/networks/create", nil, body: JSON.generate(init_spec)))
+      end
+
+      def self.all(skip_default=false, conn=Docker.connection)
+        hashes = conn.get('/networks')
+        hashes.select { |h| !skip_default || !h['Name'].in?(DEFAULT_NETWORKS) }
+              .map{ |h| new(conn, h) }
+      end
+
+    end
+  end
+end

data/lib/algo/docker/service.rb

@@ -0,0 +1,84 @@
+module Algo
+
+  module Docker
+
+    class Service < Base
+
+      Spec = Struct.new('Spec', :name, :task_template, :mode, :update_config,
+                                :networks, :endpoint_spec)
+
+      attr_reader :spec
+
+      def initialize conn, hash
+        super(conn, hash)
+        @spec = nil
+      end
+
+      def info
+        @info = Docker::Service.find(@info["Id"]).info if @info["Spec"].blank?
+        @info
+      end
+
+      def spec
+        if @spec.blank?
+          @spec = Spec.new(
+            info["Spec"]["Name"],
+            info["Spec"]["TaskTemplate"],
+            info["Spec"]["Mode"],
+            info["Spec"]["UpdateConfig"],
+            info["Spec"]["Networks"].tap { |network|
+              unless network.blank?
+                break network.map { |net| Network.new(@connection, {'Id' => net['Target']}) }
+              end
+            },
+            info["Spec"]["EndpointSpec"]
+          )
+        end
+        @spec
+      end
+
+      def raw_spec
+        info["Spec"]
+      end
+
+      def inspect
+        "<Algo::Docker::Service name=#{spec.name}>"
+      end
+
+      def remove
+        self.class.remove info['Id']
+      end
+
+      def update next_spec
+        self.class.update info['Id'], info['Version']['Index'], next_spec
+        @info = self.class.find(@info["Id"]).info
+      end
+
+      def self.find(id_or_name, conn=Docker.connection)
+        new(conn, conn.get("/services/#{id_or_name}"))
+      end
+
+      def self.create(init_spec, conn=Docker.connection)
+        new(conn, conn.post('/services/create', nil, body: JSON.generate(init_spec)))
+      end
+
+      def self.remove(id_or_name, conn=Docker.connection)
+        conn.delete("/services/#{id_or_name}")
+      end
+
+      def self.update(id_or_name, version, next_spec, conn=Docker.connection)
+        conn.post("/services/#{id_or_name}/update",
+                  { version: version },
+                  body: JSON.generate(next_spec))
+      end
+
+      def self.all(conn=Docker.connection)
+        hashes = conn.get('/services')
+        hashes.map{ |h| new(conn, h) }
+      end
+
+    end
+
+  end
+
+end

data/lib/algo/docker/version.rb

@@ -0,0 +1,5 @@
+module Algo
+  module Docker
+    API_VERSION = '1.24'
+  end
+end

data/lib/algo/docker.rb

@@ -0,0 +1,63 @@
+module Algo
+  module Docker
+    require 'algo/docker/version'
+    require 'algo/docker/error'
+    require 'algo/docker/base'
+    require 'algo/docker/connection'
+
+    # Entities
+    require 'algo/docker/network'
+    require 'algo/docker/service'
+
+    def connection
+      @connection ||= Connection.new(url, options)
+    end
+
+    def url
+      @url || env_url
+    end
+
+    def url=(new_url)
+      @url = new_url
+    end
+
+    def options
+      @options || env_options
+    end
+
+    def options=(new_options)
+      @options = env_options.merge(new_options)
+    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
+
+    module_function :env_options, :url, :url=, :options, :options=, :env_url, :ssl_options,
+                    :connection
+
+  end
+end

data/lib/algo/dsl/cluster.rb

@@ -0,0 +1,47 @@
+module Algo
+  class Dsl
+    module Cluster
+
+      class Context
+        include Dsl::Network
+        include Dsl::Service
+
+        attr_reader :context
+
+        def initialize name
+          @context = {
+            "services" => [],
+            "networks" => [],
+            "env" => [],
+            "labels" => {},
+            'name' => name,
+            'prefix' => name
+          }
+        end
+
+        # Assign cluster-wide used prefix.
+        # @param [String] pref_name
+        def prefix pref_name
+          @context['prefix'] = pref_name
+        end
+
+        def env key, val
+          @context['env'] << "#{key}=#{val}"
+        end
+
+        def label key, val
+          @context['labels'][key] = val
+        end
+
+      end
+
+      def cluster name, &block
+        ctx = Cluster::Context.new(name).tap do |ctx|
+          ctx.instance_eval(&block)
+        end
+        @clusters << ctx.context
+      end
+
+    end
+  end
+end

data/lib/algo/dsl/network.rb

@@ -0,0 +1,57 @@
+module Algo
+  class Dsl
+    module Network
+
+      class Context
+
+        attr_reader :context
+
+        def initialize name, cluster
+          @cluster = cluster
+          @context = {
+            'Name' => "#{cluster_prefix}#{name}",
+            'Driver' => 'overlay',
+            'CheckDuplicate' => true,
+            'EnableIPv6' => false,
+            'IPAM' => {
+              'Config' => [],
+              'Driver' => 'default',
+              'Options' => {}
+            },
+            'Internal' => false,
+            'Labels' => cluster['labels'],
+            'Options' => {}
+          }
+        end
+
+        def internal
+          @context['Internal'] = true
+        end
+
+        def label key, val
+          @context['Labels'][key] = val
+        end
+
+        def ipv6
+          @context['EnableIPv6'] = true
+        end
+
+        private
+
+        def cluster_prefix
+          "#{@cluster['prefix']}-" if @cluster['prefix']
+        end
+
+      end
+
+      def network name, &block
+        raise 'should be called in cluster' unless @context
+        ctx = Network::Context.new(name, @context).tap do |ctx|
+          ctx.instance_eval(&block) if block_given?
+        end
+        @context['networks'] << ctx.context
+      end
+
+    end
+  end
+end

data/lib/algo/dsl/service.rb

@@ -0,0 +1,110 @@
+module Algo
+  class Dsl
+    module Service
+
+      class Context
+        attr_reader :context
+
+        def initialize name, cluster
+          @cluster = cluster
+          @context = {
+            'Name' => "#{cluster_prefix}#{name}",
+            'TaskTemplate' => {
+              'ContainerSpec' => {
+                'Image' => nil
+              }
+            },
+            'Mode' => {
+              'Replicated' => {
+                'Replicas' => 1
+              }
+            },
+            'Labels' => @cluster['labels']
+          }
+          @context['TaskTemplate']['ContainerSpec']['Env'] = @cluster['env'] if @cluster['env'].present?
+        end
+
+        # ContainerSpec
+
+        def image image_name
+          @context['TaskTemplate']['ContainerSpec']['Image'] = image_name
+        end
+
+        def command *item
+          @context['TaskTemplate']['ContainerSpec']['Command'] = item
+        end
+
+        def args *items
+          @context['TaskTemplate']['ContainerSpec']['Args'] = items
+        end
+
+        def env key, val
+          @context['TaskTemplate']['ContainerSpec']['Env'] ||= []
+          @context['TaskTemplate']['ContainerSpec']['Env'] << "#{key}=#{val}"
+        end
+
+        # @param [String] period period string like 30s, 1m, 4h
+        def stop_grace_period period
+          if period.end_with?('s')
+            period = period.chomp('s').to_i
+          elsif period.end_with?('m')
+            period = period.chomp('m').to_i * 60
+          elsif period.end_with?('h')
+            period = period.chomp('m').to_i * 60 * 60
+          else
+            raise
+          end
+          @context['TaskTemplate']['ContainerSpec']['StopGracePeriod'] = period * 1000000000
+        end
+
+        # Label
+
+        def label key, val
+          @context['Labels'] ||= {}
+          @context['Labels'][key] = val
+        end
+
+        # Mode
+
+        def replicas replica_size
+          @context['Mode']['Replicated']['Replicas']= replica_size
+        end
+
+        # UpdateConfig
+
+        def update_parallelism n
+          @context['UpdateConfig'] ||= {}
+          @context['UpdateConfig']['Parallelism']= n
+        end
+
+        def update_delay n
+          @context['UpdateConfig'] ||= {}
+          @context['UpdateConfig']['Delay']= n
+        end
+
+        # Networks
+
+        def network name
+          @context['Networks'] ||= []
+          @context['Networks'] << { 'Target' => "#{cluster_prefix}#{name}" }
+         end
+
+        private
+
+        def cluster_prefix
+          "#{@cluster['prefix']}-" if @cluster['prefix']
+        end
+
+      end
+
+      def service name, &block
+        raise 'should be called in cluster' unless @context
+        ctx = Service::Context.new(name, @context).tap do |ctx|
+          ctx.instance_eval(&block)
+        end
+        @context['services'] << ctx.context
+      end
+
+    end
+  end
+end

data/lib/algo/dsl.rb

@@ -0,0 +1,34 @@
+module Algo
+  class Dsl
+    require 'algo/dsl/service'
+    require 'algo/dsl/network'
+    require 'algo/dsl/cluster'
+
+    include Dsl::Cluster
+
+    attr_reader :options
+
+    CLUSTER_DEFAULT = {}
+
+    def result
+      @clusters
+    end
+
+    def self.load(options, path = nil)
+      dsl = new(options).tap do |dsl|
+        dsl._load_from(path)
+      end
+      dsl.result
+    end
+
+    def initialize(options)
+      @options = CLUSTER_DEFAULT.dup
+      @options.merge!(options)
+      @clusters = []
+    end
+
+    def _load_from(path)
+      instance_eval(File.read(path), path) if path
+    end
+  end
+end

data/lib/algo/version.rb

@@ -0,0 +1,3 @@
+module Algo
+  VERSION = "0.1.0"
+end

data/lib/algo.rb

@@ -0,0 +1,13 @@
+require 'excon'
+require 'thor'
+require 'json'
+require 'active_support'
+require 'active_support/core_ext'
+
+module Algo
+  require "algo/version"
+  require "algo/docker"
+  require "algo/dsl"
+  require "algo/cli"
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: algo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- yoshiso
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.51.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.51.0
+- !ruby/object:Gem::Dependency
+  name: thor
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: Docker container orchestration tool for swarm cluster.
+email:
+- nya060@gmail.com
+executables:
+- algo
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- algo.gemspec
+- bin/console
+- bin/setup
+- examples/awesome-cluster.rb
+- exe/algo
+- lib/algo.rb
+- lib/algo/cli.rb
+- lib/algo/docker.rb
+- lib/algo/docker/base.rb
+- lib/algo/docker/connection.rb
+- lib/algo/docker/error.rb
+- lib/algo/docker/network.rb
+- lib/algo/docker/service.rb
+- lib/algo/docker/version.rb
+- lib/algo/dsl.rb
+- lib/algo/dsl/cluster.rb
+- lib/algo/dsl/network.rb
+- lib/algo/dsl/service.rb
+- lib/algo/version.rb
+homepage: https://github.com/yoshiso/algo
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Docker container orchestration tool for swarm cluster.
+test_files: []