hako 2.2.0 → 2.3.0

data/lib/hako/schedulers/ecs.rb

@@ -13,6 +13,7 @@ require 'hako/schedulers/ecs_definition_comparator'
 require 'hako/schedulers/ecs_elb'
 require 'hako/schedulers/ecs_elb_v2'
 require 'hako/schedulers/ecs_service_comparator'
+require 'hako/schedulers/ecs_volume_comparator'
 
 module Hako
   module Schedulers
@@ -45,7 +46,7 @@ module Hako
         @dynamic_port_mapping = options.fetch('dynamic_port_mapping', @ecs_elb_options.nil?)
         @health_check_grace_period_seconds = options.fetch('health_check_grace_period_seconds', nil)
         if options.key?('autoscaling')
-          @autoscaling = EcsAutoscaling.new(options.fetch('autoscaling'), @region, dry_run: @dry_run)
+          @autoscaling = EcsAutoscaling.new(options.fetch('autoscaling'), @region, ecs_elb_client, dry_run: @dry_run)
         end
         @autoscaling_group_for_oneshot = options.fetch('autoscaling_group_for_oneshot', nil)
         @autoscaling_topic_for_oneshot = options.fetch('autoscaling_topic_for_oneshot', nil)
@@ -94,6 +95,9 @@ module Hako
         definitions = create_definitions(containers)
 
         if @dry_run
+          volumes_definition.each do |d|
+            print_volume_definition_in_cli_format(d)
+          end
           definitions.each do |d|
             print_definition_in_cli_format(d)
           end
@@ -176,6 +180,9 @@ module Hako
         end
 
         if @dry_run
+          volumes_definition.each do |d|
+            print_volume_definition_in_cli_format(d)
+          end
           definitions.each do |d|
             if d[:name] == 'app'
               d[:command] = commands
@@ -405,6 +412,10 @@ module Hako
           # Initial deployment
           return true
         end
+        actual_volume_definitions = {}
+        actual_definition.volumes.each do |v|
+          actual_volume_definitions[v.name] = v
+        end
         container_definitions = {}
         actual_definition.container_definitions.each do |c|
           container_definitions[c.name] = c
@@ -413,7 +424,10 @@ module Hako
         if actual_definition.task_role_arn != @task_role_arn
           return true
         end
-        if different_volumes?(actual_definition.volumes)
+        if volumes_definition.any? { |definition| different_volume?(definition, actual_volume_definitions.delete(definition[:name])) }
+          return true
+        end
+        unless actual_volume_definitions.empty?
           return true
         end
         if desired_definitions.any? { |definition| different_definition?(definition, container_definitions.delete(definition[:name])) }
@@ -441,23 +455,11 @@ module Hako
         false
       end
 
-      # @param [Hash<String, Hash<String, String>>] actual_volumes
+      # @param [Hash] expected_volume
+      # @param [Aws::ECS::Types::Volume] actual_volume
       # @return [Boolean]
-      def different_volumes?(actual_volumes)
-        if @volumes.size != actual_volumes.size
-          return true
-        end
-        actual_volumes.each do |actual_volume|
-          expected_volume = @volumes[actual_volume.name]
-          if expected_volume.nil?
-            return true
-          end
-          if expected_volume['source_path'] != actual_volume.host.source_path
-            return true
-          end
-        end
-
-        false
+      def different_volume?(expected_volume, actual_volume)
+        EcsVolumeComparator.new(expected_volume).different?(actual_volume)
       end
 
       # @param [Hash] expected_container
@@ -534,13 +536,28 @@ module Hako
         raise Error.new('Unable to register task definition for oneshot due to too many client errors')
       end
 
-      # @return [Hash]
+      # @return [Array<Hash>]
       def volumes_definition
-        @volumes.map do |name, volume|
-          {
-            name: name,
-            host: { source_path: volume['source_path'] },
-          }
+        @volumes_definition ||= @volumes.map do |name, volume|
+          definition = { name: name }
+          if volume.key?('docker_volume_configuration')
+            configuration = volume['docker_volume_configuration']
+            definition[:docker_volume_configuration] = {
+              autoprovision: configuration['autoprovision'],
+              driver: configuration['driver'],
+              # ECS API doesn't allow 'driver_opts' to be an empty hash.
+              driver_opts: configuration['driver_opts'],
+              # ECS API doesn't allow 'labels' to be an empty hash.
+              labels: configuration['labels'],
+              scope: configuration['scope'],
+            }
+          else
+            # When neither 'host' nor 'docker_volume_configuration' is
+            # specified, ECS API treats it as if 'host' is specified without
+            # 'source_path'.
+            definition[:host] = { source_path: volume['source_path'] }
+          end
+          definition
         end
       end
 
@@ -574,6 +591,7 @@ module Hako
           volumes_from: container.volumes_from,
           user: container.user,
           log_configuration: container.log_configuration,
+          health_check: container.health_check,
           ulimits: container.ulimits,
           extra_hosts: container.extra_hosts,
         }
@@ -1043,6 +1061,31 @@ module Hako
         end
       end
 
+      # @param [Hash] definition
+      # @return [nil]
+      def print_volume_definition_in_cli_format(definition)
+        return if definition.dig(:docker_volume_configuration, :autoprovision)
+        # From version 1.20.0 of ECS agent, a local volume is provisioned when
+        # 'host' is specified without 'source_path'.
+        return if definition.dig(:host, :source_path)
+
+        cmd = %w[docker volume create]
+        if (configuration = definition[:docker_volume_configuration])
+          if configuration[:driver]
+            cmd << '--driver' << configuration[:driver]
+          end
+          (configuration[:driver_opts] || {}).each do |k, v|
+            cmd << '--opt' << "#{k}=#{v}"
+          end
+          (configuration[:labels] || {}).each do |k, v|
+            cmd << '--label' << "#{k}=#{v}"
+          end
+        end
+        cmd << definition[:name]
+        puts cmd.join(' ')
+        nil
+      end
+
       # @param [Hash] definition
       # @param [Hash<String, String>] additional_env
       # @return [nil]
@@ -1069,12 +1112,13 @@ module Hako
         end
         definition.fetch(:mount_points).each do |mount_point|
           source_volume = mount_point.fetch(:source_volume)
-          v = @volumes[source_volume]
-          if v
-            cmd << '--volume' << "#{v.fetch('source_path')}:#{mount_point.fetch(:container_path)}#{mount_point[:read_only] ? ':ro' : ''}"
-          else
-            raise "Could not find volume #{source_volume}"
-          end
+          v = volumes_definition.find { |d| d[:name] == source_volume }
+          raise "Could not find volume #{source_volume}" unless v
+          source = v.dig(:host, :source_path) || source_volume
+          cmd << '--volume' << "#{source}:#{mount_point.fetch(:container_path)}#{mount_point[:read_only] ? ':ro' : ''}"
+        end
+        definition.fetch(:volumes_from).each do |volumes_from|
+          cmd << '--volumes-from' << "#{volumes_from.fetch(:source_container)}#{volumes_from[:read_only] ? ':ro' : ''}"
         end
         if definition[:privileged]
           cmd << '--privileged'
@@ -1103,9 +1147,18 @@ module Hako
             end
           end
 
-          if definition[:init_process_enabled]
+          if definition[:linux_parameters][:init_process_enabled]
             cmd << '--init'
           end
+
+          if definition[:linux_parameters][:shared_memory_size]
+            cmd << '--shm-size' << "#{definition[:linux_parameters][:shared_memory_size]}m"
+          end
+
+          definition[:linux_parameters].fetch(:tmpfs, []).each do |tmpfs|
+            options = ["size=#{tmpfs[:size]}m"].concat(tmpfs[:mount_options])
+            cmd << '--tmpfs' << "#{tmpfs[:container_path]}:#{options.join(',')}"
+          end
         end
         definition.fetch(:volumes_from).each do |volumes_from|
           p volumes_from

data/lib/hako/schedulers/ecs_autoscaling.rb

@@ -2,14 +2,16 @@
 
 require 'aws-sdk-applicationautoscaling'
 require 'aws-sdk-cloudwatch'
+require 'aws-sdk-elasticloadbalancingv2'
 require 'hako'
 require 'hako/error'
 
 module Hako
   module Schedulers
     class EcsAutoscaling
-      def initialize(options, region, dry_run:)
+      def initialize(options, region, ecs_elb_client, dry_run:)
         @region = region
+        @ecs_elb_client = ecs_elb_client
         @dry_run = dry_run
         @role_arn = required_option(options, 'role_arn')
         @min_capacity = required_option(options, 'min_capacity')
@@ -44,17 +46,21 @@ module Hako
         @policies.each do |policy|
           Hako.logger.info("Configuring scaling policy #{policy.name}")
           if @dry_run
-            policy.alarms.each do |alarm_name|
-              Hako.logger.info("Configuring #{alarm_name}'s alarm_action")
+            if policy.policy_type == 'StepScaling'
+              policy.alarms.each do |alarm_name|
+                Hako.logger.info("Configuring #{alarm_name}'s alarm_action")
+              end
             end
           else
-            policy_arn = autoscaling_client.put_scaling_policy(
+            policy_params = {
               policy_name: policy.name,
               service_namespace: service_namespace,
               resource_id: resource_id,
               scalable_dimension: scalable_dimension,
-              policy_type: 'StepScaling',
-              step_scaling_policy_configuration: {
+              policy_type: policy.policy_type,
+            }
+            if policy.policy_type == 'StepScaling'
+              policy_params[:step_scaling_policy_configuration] = {
                 adjustment_type: policy.adjustment_type,
                 step_adjustments: [
                   {
@@ -65,16 +71,40 @@ module Hako
                 ],
                 cooldown: policy.cooldown,
                 metric_aggregation_type: policy.metric_aggregation_type,
-              },
-            ).policy_arn
-
-            alarms = cw_client.describe_alarms(alarm_names: policy.alarms).flat_map(&:metric_alarms).map { |a| [a.alarm_name, a] }.to_h
-            policy.alarms.each do |alarm_name|
-              alarm = alarms.fetch(alarm_name) { raise Error.new("Alarm #{alarm_name} does not exist") }
-              Hako.logger.info("Updating #{alarm_name}'s alarm_actions from #{alarm.alarm_actions} to #{[policy_arn]}")
-              params = PUT_METRIC_ALARM_OPTIONS.map { |key| [key, alarm.public_send(key)] }.to_h
-              params[:alarm_actions] = [policy_arn]
-              cw_client.put_metric_alarm(params)
+              }
+            else
+              predefined_metric_specification = {
+                predefined_metric_type: policy.predefined_metric_type,
+              }
+              if policy.predefined_metric_type == 'ALBRequestCountPerTarget'
+                if service.load_balancers.empty? || service.load_balancers[0].target_group_arn.nil?
+                  raise Error.new('Target group must be attached to the ECS service for predefined metric type ALBRequestCountPerTarget')
+                end
+                resource_label = target_group_resource_label
+                unless resource_label.start_with?('app/')
+                  raise Error.new("Load balancer type must be 'application' for predefined metric type ALBRequestCountPerTarget")
+                end
+                predefined_metric_specification[:resource_label] = resource_label
+              end
+              policy_params[:target_tracking_scaling_policy_configuration] = {
+                target_value: policy.target_value,
+                predefined_metric_specification: predefined_metric_specification,
+                scale_out_cooldown: policy.scale_out_cooldown,
+                scale_in_cooldown: policy.scale_in_cooldown,
+                disable_scale_in: policy.disable_scale_in,
+              }
+            end
+            policy_arn = autoscaling_client.put_scaling_policy(policy_params).policy_arn
+
+            if policy.policy_type == 'StepScaling'
+              alarms = cw_client.describe_alarms(alarm_names: policy.alarms).flat_map(&:metric_alarms).map { |a| [a.alarm_name, a] }.to_h
+              policy.alarms.each do |alarm_name|
+                alarm = alarms.fetch(alarm_name) { raise Error.new("Alarm #{alarm_name} does not exist") }
+                Hako.logger.info("Updating #{alarm_name}'s alarm_actions from #{alarm.alarm_actions} to #{[policy_arn]}")
+                params = PUT_METRIC_ALARM_OPTIONS.map { |key| [key, alarm.public_send(key)] }.to_h
+                params[:alarm_actions] = [policy_arn]
+                cw_client.put_metric_alarm(params)
+              end
             end
           end
         end
@@ -139,23 +169,50 @@ module Hako
         "service/#{service.cluster_arn.slice(%r{[^/]+\z}, 0)}/#{service.service_name}"
       end
 
+      # @return [String]
+      def target_group_resource_label
+        target_group = @ecs_elb_client.describe_target_group
+        load_balancer_arn = target_group.load_balancer_arns[0]
+        target_group_arn = target_group.target_group_arn
+        "#{load_balancer_arn.slice(%r{:loadbalancer/(.+)\z}, 1)}/#{target_group_arn.slice(/[^:]+\z/)}"
+      end
+
       class Policy
+        attr_reader :policy_type
         attr_reader :alarms, :cooldown, :adjustment_type, :scaling_adjustment, :metric_interval_lower_bound, :metric_interval_upper_bound, :metric_aggregation_type
+        attr_reader :target_value, :predefined_metric_type, :scale_out_cooldown, :scale_in_cooldown, :disable_scale_in
 
         # @param [Hash] options
         def initialize(options)
-          @alarms = required_option(options, 'alarms')
-          @cooldown = required_option(options, 'cooldown')
-          @adjustment_type = required_option(options, 'adjustment_type')
-          @scaling_adjustment = required_option(options, 'scaling_adjustment')
-          @metric_interval_lower_bound = options.fetch('metric_interval_lower_bound', nil)
-          @metric_interval_upper_bound = options.fetch('metric_interval_upper_bound', nil)
-          @metric_aggregation_type = required_option(options, 'metric_aggregation_type')
+          @policy_type = options.fetch('policy_type', 'StepScaling')
+          case @policy_type
+          when 'StepScaling'
+            @alarms = required_option(options, 'alarms')
+            @cooldown = required_option(options, 'cooldown')
+            @adjustment_type = required_option(options, 'adjustment_type')
+            @scaling_adjustment = required_option(options, 'scaling_adjustment')
+            @metric_interval_lower_bound = options.fetch('metric_interval_lower_bound', nil)
+            @metric_interval_upper_bound = options.fetch('metric_interval_upper_bound', nil)
+            @metric_aggregation_type = required_option(options, 'metric_aggregation_type')
+          when 'TargetTrackingScaling'
+            @name = required_option(options, 'name')
+            @target_value = required_option(options, 'target_value')
+            @predefined_metric_type = required_option(options, 'predefined_metric_type')
+            @scale_out_cooldown = options.fetch('scale_out_cooldown', nil)
+            @scale_in_cooldown = options.fetch('scale_in_cooldown', nil)
+            @disable_scale_in = options.fetch('disable_scale_in', nil)
+          else
+            raise Error.new("scheduler.autoscaling.policies.#{policy_type} must be either 'StepScaling' or 'TargetTrackingScaling'")
+          end
         end
 
         # @return [String]
         def name
-          alarms.join('-and-')
+          if policy_type == 'StepScaling'
+            alarms.join('-and-')
+          else
+            @name
+          end
         end
 
         private

data/lib/hako/schedulers/ecs_definition_comparator.rb

@@ -35,6 +35,7 @@ module Hako
           struct.member(:user, Schema::Nullable.new(Schema::String.new))
           struct.member(:privileged, Schema::Boolean.new)
           struct.member(:log_configuration, Schema::Nullable.new(log_configuration_schema))
+          struct.member(:health_check, Schema::Nullable.new(health_check_schema))
           struct.member(:ulimits, Schema::Nullable.new(ulimits_schema))
           struct.member(:extra_hosts, Schema::Nullable.new(extra_hosts_schema))
           struct.member(:linux_parameters, Schema::Nullable.new(linux_parameters_schema))
@@ -78,6 +79,16 @@ module Hako
         end
       end
 
+      def health_check_schema
+        Schema::Structure.new.tap do |struct|
+          struct.member(:command, Schema::OrderedArray.new(Schema::String.new))
+          struct.member(:interval, Schema::Integer.new)
+          struct.member(:timeout, Schema::Integer.new)
+          struct.member(:retries, Schema::Integer.new)
+          struct.member(:start_period, Schema::Integer.new)
+        end
+      end
+
       def ulimits_schema
         Schema::UnorderedArray.new(ulimit_schema)
       end
@@ -95,6 +106,8 @@ module Hako
           struct.member(:capabilities, Schema::Nullable.new(capabilities_schema))
           struct.member(:devices, Schema::Nullable.new(devices_schema))
           struct.member(:init_process_enabled, Schema::Nullable.new(Schema::Boolean.new))
+          struct.member(:shared_memory_size, Schema::Nullable.new(Schema::Integer.new))
+          struct.member(:tmpfs, Schema::Nullable.new(tmpfs_schema))
         end
       end
 
@@ -117,6 +130,16 @@ module Hako
         end
       end
 
+      def tmpfs_schema
+        Schema::UnorderedArray.new(
+          Schema::Structure.new.tap do |struct|
+            struct.member(:container_path, Schema::String.new)
+            struct.member(:mount_options, Schema::UnorderedArray.new(Schema::String.new))
+            struct.member(:size, Schema::Integer.new)
+          end
+        )
+      end
+
       def extra_hosts_schema
         Schema::UnorderedArray.new(extra_host_schema)
       end

data/lib/hako/schedulers/ecs_volume_comparator.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'hako/schema'
+
+module Hako
+  module Schedulers
+    class EcsVolumeComparator
+      # @param [Hash] expected_volume
+      def initialize(expected_volume)
+        @expected_volume = expected_volume
+        @schema = volume_schema
+      end
+
+      # @param [Aws::ECS::Types::Volume] actual_volume
+      # @return [Boolean]
+      def different?(actual_volume)
+        !@schema.same?(actual_volume.to_h, @expected_volume)
+      end
+
+      private
+
+      def volume_schema
+        Schema::Structure.new.tap do |struct|
+          struct.member(:docker_volume_configuration, Schema::Nullable.new(docker_volume_configuration_schema))
+          struct.member(:host, Schema::Nullable.new(host_schema))
+          struct.member(:name, Schema::String.new)
+        end
+      end
+
+      def docker_volume_configuration_schema
+        Schema::Structure.new.tap do |struct|
+          struct.member(:autoprovision, Schema::Nullable.new(Schema::Boolean.new))
+          struct.member(:driver, Schema::WithDefault.new(Schema::String.new, 'local'))
+          struct.member(:driver_opts, Schema::Nullable.new(Schema::Table.new(Schema::String.new, Schema::String.new)))
+          struct.member(:labels, Schema::Nullable.new(Schema::Table.new(Schema::String.new, Schema::String.new)))
+          struct.member(:scope, Schema::WithDefault.new(Schema::String.new, 'task'))
+        end
+      end
+
+      def host_schema
+        Schema::Structure.new.tap do |struct|
+          struct.member(:source_path, Schema::Nullable.new(Schema::String.new))
+        end
+      end
+    end
+  end
+end

data/lib/hako/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hako
-  VERSION = '2.2.0'
+  VERSION = '2.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hako
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Kohei Suzuki
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-29 00:00:00.000000000 Z
+date: 2018-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-applicationautoscaling
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.7.0
 - !ruby/object:Gem::Dependency
   name: aws-sdk-elasticloadbalancing
   requirement: !ruby/object:Gem::Requirement
@@ -287,7 +287,6 @@ files:
 - docs/jsonnet.md
 - examples/create_aws_cloud_watch_logs_log_group.libsonnet
 - examples/front.libsonnet
-- examples/front.yml
 - examples/hello-autoscaling-group.jsonnet
 - examples/hello-autoscaling.jsonnet
 - examples/hello-awslogs-driver.jsonnet
@@ -328,6 +327,7 @@ files:
 - lib/hako/schedulers/ecs_elb.rb
 - lib/hako/schedulers/ecs_elb_v2.rb
 - lib/hako/schedulers/ecs_service_comparator.rb
+- lib/hako/schedulers/ecs_volume_comparator.rb
 - lib/hako/schema.rb
 - lib/hako/schema/boolean.rb
 - lib/hako/schema/integer.rb

data/examples/front.yml

@@ -1,5 +0,0 @@
-type: nginx_front
-s3:
-  region: ap-northeast-1
-  bucket: nanika
-  prefix: hako/front_config