hako 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b7b7ad2ffbeb17c94a9e690bf278bb4019852b3e
+  data.tar.gz: 27024dcecc995a1acc893e3072029cd693fd8e0a
+SHA512:
+  metadata.gz: 874b5c28b65dd52d728c83a441f23d057807d1f445fe9edc5a5b44200eeb9b8fbcfd9770568a86f2ecee30686dcc389e713a2baed9dfef4e7ade3c05633905f1
+  data.tar.gz: 3218b993bcc4d924f0e6aaaf72a74dc84e2d97f07babcea01295c25625e5fcd13bcb9fad70ea254d30518e42778a14afc17d5df95cec657ddbd7d49f5909748c

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/Gemfile

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

data/README.md

@@ -0,0 +1,64 @@
+# Hako
+Deploy Docker container.
+
+## Status
+Under development
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hako'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hako
+
+## Usage
+
+```
+% hako deploy examples/hello.yml
+I, [2015-10-02T12:51:24.530274 #7988]  INFO -- : Registered task-definition: arn:aws:ecs:ap-northeast-1:XXXXXXXXXXXX:task-definition/hello:29
+I, [2015-10-02T12:51:24.750501 #7988]  INFO -- : Uploaded front configuration to s3://nanika/hako/front_config/hello.conf
+I, [2015-10-02T12:51:24.877409 #7988]  INFO -- : Updated service: arn:aws:ecs:ap-northeast-1:XXXXXXXXXXXX:service/hello
+I, [2015-10-02T12:56:07.284874 #7988]  INFO -- : Deployment completed
+
+% hako deploy examples/hello.yml
+I, [2015-10-02T12:56:12.262760 #8141]  INFO -- : Deployment isn't needed
+
+% hako status examples/hello.yml
+Load balancer:
+  hako-hello-XXXXXXXXXX.ap-northeast-1.elb.amazonaws.com:80 -> front:80
+Deployments:
+  [PRIMARY] desired_count=2, pending_count=0, running_count=2
+Tasks:
+  [RUNNING]: i-XXXXXXXX (ecs-001)
+  [RUNNING]: i-YYYYYYYY (ecs-002)
+Events:
+  2015-10-05 13:35:53 +0900: (service hello) has reached a steady state.
+  2015-10-05 13:35:14 +0900: (service hello) stopped 1 running tasks.
+
+```
+
+## Front image
+The front container receives these environment variables.
+
+- `S3_CONFIG_BUCKET` and `S3_CONFIG_KEY`
+    - The front container should download configuration file from S3.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also 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`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/eagletmt/hako.
+

data/Rakefile

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

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "hako"
+
+# 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
+
+require "irb"
+IRB.start

data/bin/setup

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

data/examples/hello-lb.yml

@@ -0,0 +1,31 @@
+image: ryotarai/hello-sinatra
+env:
+  $providers:
+    - type: file
+      path: examples/hello.env
+  PORT: 3000
+  MESSAGE: '#{username}-san'
+port: 3000
+scheduler:
+  type: ecs
+  region: ap-northeast-1
+  memory: 100
+  cpu: 100
+  cluster: eagletmt
+  desired_count: 2
+  role: ecsServiceRole
+  elb:
+    listeners:
+      - load_balancer_port: 80
+    subnets:
+      - subnet-XXXXXXXX
+      - subnet-YYYYYYYY
+    security_groups:
+      - sg-ZZZZZZZZ
+front:
+  type: nginx
+  image_tag: hako-nginx
+  s3:
+    region: ap-northeast-1
+    bucket: nanika
+    prefix: hako/front_config

data/examples/hello.env

@@ -0,0 +1 @@
+username=eagletmt

data/examples/hello.yml

@@ -0,0 +1,22 @@
+image: ryotarai/hello-sinatra
+env:
+  $providers:
+    - type: file
+      path: examples/hello.env
+  PORT: 3000
+  MESSAGE: '#{username}-san'
+port: 3000
+scheduler:
+  type: ecs
+  region: ap-northeast-1
+  memory: 100
+  cpu: 100
+  cluster: eagletmt
+  desired_count: 2
+front:
+  type: nginx
+  image_tag: hako-nginx
+  s3:
+    region: ap-northeast-1
+    bucket: nanika
+    prefix: hako/front_config

data/exe/hako

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'hako/cli'
+
+Hako::CLI.start

data/hako.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hako/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hako"
+  spec.version       = Hako::VERSION
+  spec.authors       = ["Kohei Suzuki"]
+  spec.email         = ["eagletmt@gmail.com"]
+
+  spec.summary       = %q{Deploy Docker container}
+  spec.description   = %q{Deploy Docker container}
+  spec.homepage      = "https://github.com/eagletmt/hako"
+
+  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 "aws-sdk", "~> 2.1.0"
+  spec.add_dependency "thor"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/hako.rb

@@ -0,0 +1,8 @@
+require 'logger'
+require "hako/version"
+
+module Hako
+  def self.logger
+    @logger ||= Logger.new($stdout)
+  end
+end

data/lib/hako/cli.rb

@@ -0,0 +1,18 @@
+require 'thor'
+
+module Hako
+  class CLI < Thor
+    desc 'deploy FILE', 'Run deployment'
+    option :force, aliases: %w[-f], type: :boolean, default: false, desc: 'Run deployment even if nothing is changed'
+    def deploy(yaml_path)
+      require 'hako/commander'
+      Commander.new(yaml_path).deploy(force: options[:force])
+    end
+
+    desc 'status FILE', 'Show deployment status'
+    def status(yaml_path)
+      require 'hako/commander'
+      Commander.new(yaml_path).status
+    end
+  end
+end

data/lib/hako/commander.rb

@@ -0,0 +1,66 @@
+require 'yaml'
+require 'hako/env_expander'
+require 'hako/error'
+require 'hako/front_config'
+require 'hako/fronts'
+require 'hako/schedulers'
+
+module Hako
+  class Commander
+    PROVIDERS_KEY = '$providers'
+
+    def initialize(yaml_path)
+      @app_id = Pathname.new(yaml_path).basename.sub_ext('').to_s
+      @yaml = YAML.load_file(yaml_path)
+    end
+
+    def deploy(force: false)
+      env = @yaml['env'].dup
+      providers = load_providers(env.delete(PROVIDERS_KEY) || [])
+      env = EnvExpander.new(providers).expand(env)
+
+      front = load_front(@yaml['front'])
+
+      scheduler = load_scheduler(@yaml['scheduler'])
+      app_port = @yaml.fetch('port', nil)
+      image_tag = @yaml['image']  # TODO: Append revision
+      scheduler.deploy(image_tag, env, app_port, front, force: force)
+    end
+
+    def status
+      load_scheduler(@yaml['scheduler']).status
+    end
+
+    private
+
+    def load_providers(provider_configs)
+      provider_configs.map do |config|
+        type = config['type']
+        unless type
+          raise Error.new("type must be set in each #{PROVIDERS_KEY} element")
+        end
+        require "hako/env_providers/#{type}"
+        Hako::EnvProviders.const_get(camelize(type)).new(config)
+      end
+    end
+
+    def load_scheduler(scheduler_config)
+      type = scheduler_config['type']
+      unless type
+        raise Error.new('type must be set in scheduler')
+      end
+      require "hako/schedulers/#{type}"
+      Hako::Schedulers.const_get(camelize(type)).new(@app_id, scheduler_config)
+    end
+
+    def load_front(yaml)
+      front_config = FrontConfig.new(yaml)
+      require "hako/fronts/#{front_config.type}"
+      Hako::Fronts.const_get(camelize(front_config.type)).new(front_config)
+    end
+
+    def camelize(name)
+      name.split('_').map(&:capitalize).join('')
+    end
+  end
+end

data/lib/hako/env_expander.rb

@@ -0,0 +1,91 @@
+require 'set'
+require 'strscan'
+require 'hako/env_providers'
+require 'hako/error'
+
+module Hako
+  class EnvExpander
+    class ExpansionError < Error
+    end
+
+    class Literal < Struct.new(:literal)
+    end
+
+    class Variable < Struct.new(:name)
+    end
+
+    def initialize(providers)
+      @providers = providers
+    end
+
+    def expand(env)
+      parsed_env = {}
+      variables = Set.new
+      env.each do |key, val|
+        tokens = parse(val.to_s)
+        tokens.each do |t|
+          if t.is_a?(Variable)
+            variables << t.name
+          end
+        end
+        parsed_env[key] = tokens
+      end
+
+      values = {}
+      @providers.each do |provider|
+        if variables.empty?
+          break
+        end
+        provider.ask(variables.to_a).each do |var, val|
+          values[var] = val
+          variables.delete(var)
+        end
+      end
+      unless variables.empty?
+        raise ExpansionError.new("Unresolvable variables: #{variables.to_a}")
+      end
+
+      expanded_env = {}
+      parsed_env.each do |key, tokens|
+        expanded_env[key] = tokens.map { |t| expand_value(values, t) }.join('')
+      end
+      expanded_env
+    end
+
+    private
+
+    def parse(value)
+      s = StringScanner.new(value)
+      tokens = []
+      pos = 0
+      while s.scan_until(/#\{(.*?)\}/)
+        pre = s.string.byteslice(pos ... (s.pos - s.matched.size))
+        var = s[1]
+        unless pre.empty?
+          tokens << Literal.new(pre)
+        end
+        if var.empty?
+          raise ExpansionError.new("Empty interpolation is not allowed")
+        else
+          tokens << Variable.new(var)
+        end
+        pos = s.pos
+      end
+      unless s.rest.empty?
+        tokens << Literal.new(s.rest)
+      end
+      tokens
+    end
+
+    def expand_value(values, token)
+      case token
+      when Literal
+        token.literal
+      when Variable
+        values.fetch(token.name)
+      else
+        raise ExpansionError.new("Unknown token type: #{token.class}")
+      end
+    end
+  end
+end

data/lib/hako/env_provider.rb

@@ -0,0 +1,22 @@
+require 'hako/error'
+
+module Hako
+  class EnvProvider
+    class ValidationError < Error
+    end
+
+    def initialize(_options)
+      raise NotImplementedError
+    end
+
+    def ask(_variables)
+      raise NotImplementedError
+    end
+
+    private
+
+    def validation_error!(message)
+      raise ValidationError.new(message)
+    end
+  end
+end

data/lib/hako/env_providers.rb

@@ -0,0 +1,4 @@
+module Hako
+  module EnvProviders
+  end
+end

data/lib/hako/env_providers/file.rb

@@ -0,0 +1,43 @@
+require 'hako/env_provider'
+
+module Hako
+  module EnvProviders
+    class File < EnvProvider
+      def initialize(options)
+        unless options['path']
+          validation_error!("path must be set")
+        end
+        @path = options['path']
+      end
+
+      def ask(variables)
+        env = {}
+        read_from_file do |key, val|
+          if variables.include?(key)
+            env[key] = val
+          end
+        end
+        env
+      end
+
+      private
+
+      def read_from_file(&block)
+        ::File.open(@path) do |f|
+          f.each_line do |line|
+            line.chomp!
+            line.lstrip!
+            if line[0] == '#'
+              # line comment
+              next
+            end
+            key, val = line.split('=', 2)
+            if val
+              block.call(key, val)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hako/error.rb

@@ -0,0 +1,4 @@
+module Hako
+  class Error < StandardError
+  end
+end

data/lib/hako/front.rb

@@ -0,0 +1,13 @@
+module Hako
+  class Front
+    attr_reader :config
+
+    def initialize(front_config)
+      @config = front_config
+    end
+
+    def generate_config(_app_port)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/hako/front_config.rb

@@ -0,0 +1,27 @@
+require 'erb'
+
+module Hako
+  class FrontConfig < Struct.new(:type, :image_tag, :s3)
+    class S3Config < Struct.new(:region, :bucket, :prefix)
+      def initialize(options)
+        self.region = options.fetch('region')
+        self.bucket = options.fetch('bucket')
+        self.prefix = options.fetch('prefix', nil)
+      end
+
+      def key(app_id)
+        if prefix
+          "#{prefix}/#{app_id}.conf"
+        else
+          "#{app_id}.conf"
+        end
+      end
+    end
+
+    def initialize(options)
+      self.type = options.fetch('type')
+      self.image_tag = options.fetch('image_tag')
+      self.s3 = S3Config.new(options.fetch('s3'))
+    end
+  end
+end

data/lib/hako/fronts.rb

@@ -0,0 +1,4 @@
+module Hako
+  module Fronts
+  end
+end

data/lib/hako/fronts/nginx.rb

@@ -0,0 +1,19 @@
+require 'erb'
+require 'hako/front'
+
+module Hako
+  module Fronts
+    class Nginx < Front
+      def generate_config(app_port)
+        listen_spec = "app:#{app_port}"
+        ERB.new(File.read(nginx_conf_erb), nil, '-').result(binding)
+      end
+
+      private
+
+      def nginx_conf_erb
+        File.expand_path('../../templates/nginx.conf.erb', __FILE__)
+      end
+    end
+  end
+end

data/lib/hako/scheduler.rb

@@ -0,0 +1,36 @@
+require 'aws-sdk'
+
+module Hako
+  class Scheduler
+    class ValidationError < Error
+    end
+
+    def initialize(_app_id, _options)
+    end
+
+    def deploy(_image_tag, _env, _app_port, _front_config, _options)
+      raise NotImplementedError
+    end
+
+    def status
+      raise NotImplementedError
+    end
+
+    def upload_front_config(app_id, front, app_port)
+      front_conf = front.generate_config(app_port)
+      s3_config = front.config.s3
+      s3 = Aws::S3::Client.new(region: s3_config.region)
+      s3.put_object(
+        body: front_conf,
+        bucket: s3_config.bucket,
+        key: s3_config.key(app_id),
+      )
+    end
+
+    private
+
+    def validation_error!(message)
+      raise ValidationError.new(message)
+    end
+  end
+end

data/lib/hako/schedulers.rb

@@ -0,0 +1,4 @@
+module Hako
+  module Schedulers
+  end
+end

data/lib/hako/schedulers/ecs.rb

@@ -0,0 +1,310 @@
+require 'aws-sdk'
+require 'hako'
+require 'hako/error'
+require 'hako/scheduler'
+require 'hako/schedulers/ecs_definition_comparator'
+
+module Hako
+  module Schedulers
+    class Ecs < Scheduler
+      DEFAULT_CLUSTER = 'default'
+      DEFAULT_FRONT_PORT = 10000
+
+      def initialize(app_id, options)
+        @app_id = app_id
+        @cluster = options.fetch('cluster', DEFAULT_CLUSTER)
+        @desired_count = options.fetch('desired_count') { validation_error!('desired_count must be set') }
+        @cpu = options.fetch('cpu') { validation_error!('cpu must be set') }
+        @memory = options.fetch('memory') { validation_error!('memory must be set') }
+        region = options.fetch('region') { validation_error!('region must be set') }
+        @role = options.fetch('role', nil)
+        @ecs = Aws::ECS::Client.new(region: region)
+        @elb = Aws::ElasticLoadBalancing::Client.new(region: region)
+        @ec2 = Aws::EC2::Client.new(region: region)
+        @elb_config = options.fetch('elb', nil)
+      end
+
+      def deploy(image_tag, env, app_port, front, force: false)
+        @force_mode = force
+        front_env = {
+          'AWS_DEFAULT_REGION' => front.config.s3.region,
+          'S3_CONFIG_BUCKET' => front.config.s3.bucket,
+          'S3_CONFIG_KEY' => front.config.s3.key(@app_id),
+        }
+        front_port = determine_front_port(front)
+        task_definition = register_task_definition(image_tag, env, front.config, front_env, front_port)
+        if task_definition == :noop
+          Hako.logger.info "Task definition isn't changed"
+          task_definition = @ecs.describe_task_definition(task_definition: @app_id).task_definition
+        else
+          Hako.logger.info "Registered task definition: #{task_definition.task_definition_arn}"
+          upload_front_config(@app_id, front, app_port)
+          Hako.logger.info "Uploaded front configuration to s3://#{front.config.s3.bucket}/#{front.config.s3.key(@app_id)}"
+        end
+        service = create_or_update_service(task_definition.task_definition_arn, front_port)
+        if service == :noop
+          Hako.logger.info "Service isn't changed"
+        else
+          Hako.logger.info "Updated service: #{service.service_arn}"
+          wait_for_ready(service)
+        end
+        Hako.logger.info "Deployment completed"
+      end
+
+      def status
+        service = @ecs.describe_services(cluster: @cluster, services: [@app_id]).services[0]
+        unless service
+          puts 'Unavailable'
+          exit 1
+        end
+
+        unless service.load_balancers.empty?
+          lb = service.load_balancers[0]
+          lb_detail = @elb.describe_load_balancers(load_balancer_names: [lb.load_balancer_name]).load_balancer_descriptions[0]
+          puts 'Load balancer:'
+          lb_detail.listener_descriptions.each do |ld|
+            l = ld.listener
+            puts "  #{lb_detail.dns_name}:#{l.load_balancer_port} -> #{lb.container_name}:#{lb.container_port}"
+          end
+        end
+
+        puts 'Deployments:'
+        service.deployments.each do |d|
+          puts "  [#{d.status}] desired_count=#{d.desired_count}, pending_count=#{d.pending_count}, running_count=#{d.running_count}"
+        end
+
+        puts 'Tasks:'
+        @ecs.list_tasks(cluster: @cluster, service_name: @app_id).each do |page|
+          unless page.task_arns.empty?
+            tasks = @ecs.describe_tasks(cluster: @cluster, tasks: page.task_arns).tasks
+            container_instances = {}
+            @ecs.describe_container_instances(cluster: @cluster, container_instances: tasks.map(&:container_instance_arn)).container_instances.each do |ci|
+              container_instances[ci.container_instance_arn] = ci
+            end
+            ec2_instances = {}
+            @ec2.describe_instances(instance_ids: container_instances.values.map(&:ec2_instance_id)).reservations.each do |r|
+              r.instances.each do |i|
+                ec2_instances[i.instance_id] = i
+              end
+            end
+            tasks.each do |task|
+              ci = container_instances[task.container_instance_arn]
+              instance = ec2_instances[ci.ec2_instance_id]
+              print "  [#{task.last_status}]: #{ci.ec2_instance_id}"
+              if instance
+                name_tag = instance.tags.find { |t| t.key == 'Name' }
+                if name_tag
+                  print " (#{name_tag.value})"
+                end
+              end
+              puts
+            end
+          end
+        end
+
+        puts 'Events:'
+        service.events.first(10).each do |e|
+          puts "  #{e.created_at}: #{e.message}"
+        end
+      end
+
+      private
+
+      def determine_front_port(front)
+        service = @ecs.describe_services(cluster: @cluster, services: [@app_id]).services[0]
+        if service
+          find_front_port(service)
+        else
+          max_port = -1
+          @ecs.list_services(cluster: @cluster).each do |page|
+            unless page.service_arns.empty?
+              @ecs.describe_services(cluster: @cluster, services: page.service_arns).services.each do |service|
+                max_port = [max_port, find_front_port(service)].max
+              end
+            end
+          end
+          if max_port == -1
+            DEFAULT_FRONT_PORT
+          else
+            max_port+1
+          end
+        end
+      end
+
+      def find_front_port(service)
+        task_definition = @ecs.describe_task_definition(task_definition: service.task_definition).task_definition
+        container_definitions = {}
+        task_definition.container_definitions.each do |c|
+          container_definitions[c.name] = c
+        end
+        container_definitions['front'].port_mappings[0].host_port
+      end
+
+      def task_definition_changed?(front, app)
+        if @force_mode
+          return true
+        end
+        task_definition = @ecs.describe_task_definition(task_definition: @app_id).task_definition
+        container_definitions = {}
+        task_definition.container_definitions.each do |c|
+          container_definitions[c.name] = c
+        end
+        different_definition?(front, container_definitions['front']) || different_definition?(app, container_definitions['app'])
+      rescue Aws::ECS::Errors::ClientException
+        # Task definition does not exist
+        true
+      end
+
+      def different_definition?(expected_container, actual_container)
+        EcsDefinitionComparator.new(expected_container).different?(actual_container)
+      end
+
+      def register_task_definition(image_tag, env, front_config, front_env, front_port)
+        front = front_container(front_config, front_env, front_port)
+        app = app_container(image_tag, env)
+        if task_definition_changed?(front, app)
+          @ecs.register_task_definition(
+            family: @app_id,
+            container_definitions: [front, app],
+          ).task_definition
+        else
+          :noop
+        end
+      end
+
+      def front_container(front_config, env, front_port)
+        environment = env.map { |k, v| { name: k, value: v } }
+        {
+          name: 'front',
+          image: front_config.image_tag,
+          cpu: 100,
+          memory: 100,
+          links: ['app:app'],
+          port_mappings: [{container_port: 80, host_port: front_port, protocol: 'tcp'}],
+          essential: true,
+          environment: environment,
+        }
+      end
+
+      def app_container(image_tag, env)
+        environment = env.map { |k, v| { name: k, value: v } }
+        {
+          name: 'app',
+          image: image_tag,
+          cpu: @cpu,
+          memory: @memory,
+          links: [],
+          port_mappings: [],
+          essential: true,
+          environment: environment,
+        }
+      end
+
+      def create_or_update_service(task_definition_arn, front_port)
+        services = @ecs.describe_services(cluster: @cluster, services: [@app_id]).services
+        if services.empty?
+          params = {
+            cluster: @cluster,
+            service_name: @app_id,
+            task_definition: task_definition_arn,
+            desired_count: @desired_count,
+            role: @role,
+          }
+          if @elb_config
+            name = find_or_create_load_balancer(front_port)
+            params.merge!(
+              load_balancers: [
+                {
+                  load_balancer_name: name,
+                  container_name: 'front',
+                  container_port: 80,
+                },
+              ],
+            )
+          end
+          @ecs.create_service(params).service
+        else
+          service = services[0]
+          if service.status != 'ACTIVE'
+            raise Error.new("Service #{service.service_arn} is already exist but the status is #{service.status}")
+          end
+          params = {
+            cluster: @cluster,
+            service: @app_id,
+            desired_count: @desired_count,
+            task_definition: task_definition_arn,
+          }
+          if service_changed?(service, params)
+            @ecs.update_service(params).service
+          else
+            :noop
+          end
+        end
+      end
+
+      SERVICE_KEYS = %i[desired_count task_definition]
+
+      def service_changed?(service, params)
+        SERVICE_KEYS.each do |key|
+          if service.public_send(key) != params[key]
+            return true
+          end
+        end
+        false
+      end
+
+      def wait_for_ready(service)
+        latest_event_id = service.events[0].id
+        loop do
+          s = @ecs.describe_services(cluster: service.cluster_arn, services: [service.service_arn]).services[0]
+          s.events.each do |e|
+            if e.id == latest_event_id
+              break
+            end
+            Hako.logger.info "#{e.created_at}: #{e.message}"
+          end
+          latest_event_id = s.events[0].id
+          finished = s.deployments.all? { |d| d.status != 'ACTIVE' }
+          if finished
+            return
+          else
+            sleep 1
+          end
+        end
+      end
+
+      def find_or_create_load_balancer(front_port)
+        unless load_balancer_exist?(elb_name)
+          listeners = @elb_config.fetch('listeners').map do |l|
+            {
+              protocol: 'tcp',
+              load_balancer_port: l.fetch('load_balancer_port'),
+              instance_port: front_port,
+              ssl_certificate_id: l.fetch('ssl_certificate_id', nil),
+            }
+          end
+          lb = @elb.create_load_balancer(
+            load_balancer_name: elb_name,
+            listeners: listeners,
+            subnets: @elb_config.fetch('subnets'),
+            security_groups: @elb_config.fetch('security_groups'),
+            tags: @elb_config.fetch('tags', {}).map { |k, v| { key: k, value: v.to_s } },
+          )
+          Hako.logger.info "Created ELB #{lb.dns_name} with instance_port=#{front_port}"
+        end
+        elb_name
+      end
+
+      def load_balancer_exist?(name)
+        @elb.describe_load_balancers(load_balancer_names: [elb_name])
+        true
+      rescue Aws::ElasticLoadBalancing::Errors::LoadBalancerNotFound
+        false
+      end
+
+      def elb_name
+        "hako-#{@app_id}"
+      end
+    end
+  end
+end

data/lib/hako/schedulers/ecs_definition_comparator.rb

@@ -0,0 +1,51 @@
+module Hako
+  module Schedulers
+    class EcsDefinitionComparator
+      def initialize(expected_container)
+        @expected_container = expected_container
+      end
+
+      CONTAINER_KEYS = %i[image cpu memory links]
+      PORT_MAPPING_KEYS = %i[container_port host_port protocol]
+      ENVIRONMENT_KEYS = %i[name value]
+
+      def different?(actual_container)
+        unless actual_container
+          return true
+        end
+        if different_members?(@expected_container, actual_container, CONTAINER_KEYS)
+          return true
+        end
+        if @expected_container[:port_mappings].size != actual_container.port_mappings.size
+          return true
+        end
+        @expected_container[:port_mappings].zip(actual_container.port_mappings) do |e, a|
+          if different_members?(e, a, PORT_MAPPING_KEYS)
+            return true
+          end
+        end
+        if @expected_container[:environment].size != actual_container.environment.size
+          return true
+        end
+        @expected_container[:environment].zip(actual_container.environment) do |e, a|
+          if different_members?(e, a, ENVIRONMENT_KEYS)
+            return true
+          end
+        end
+
+        false
+      end
+
+      private
+
+      def different_members?(expected, actual, keys)
+        keys.each do |key|
+          if actual.public_send(key) != expected[key]
+            return true
+          end
+        end
+        false
+      end
+    end
+  end
+end

data/lib/hako/templates/nginx.conf.erb

@@ -0,0 +1,13 @@
+server {
+  listen 80;
+
+  location / {
+    proxy_pass http://<%= listen_spec %>;
+    proxy_set_header Host $host;
+    proxy_set_header Connection ""; # for upstream keepalive
+    proxy_http_version 1.1;         # for upstream keepalive
+    proxy_connect_timeout 5s;
+    proxy_send_timeout 20s;
+    proxy_read_timeout 20s;
+  }
+}

data/lib/hako/version.rb

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

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: hako
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kohei Suzuki
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-10-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Deploy Docker container
+email:
+- eagletmt@gmail.com
+executables:
+- hako
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/hello-lb.yml
+- examples/hello.env
+- examples/hello.yml
+- exe/hako
+- hako.gemspec
+- lib/hako.rb
+- lib/hako/cli.rb
+- lib/hako/commander.rb
+- lib/hako/env_expander.rb
+- lib/hako/env_provider.rb
+- lib/hako/env_providers.rb
+- lib/hako/env_providers/file.rb
+- lib/hako/error.rb
+- lib/hako/front.rb
+- lib/hako/front_config.rb
+- lib/hako/fronts.rb
+- lib/hako/fronts/nginx.rb
+- lib/hako/scheduler.rb
+- lib/hako/schedulers.rb
+- lib/hako/schedulers/ecs.rb
+- lib/hako/schedulers/ecs_definition_comparator.rb
+- lib/hako/templates/nginx.conf.erb
+- lib/hako/version.rb
+homepage: https://github.com/eagletmt/hako
+licenses: []
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Deploy Docker container
+test_files: []