rollo 0.3.0 → 0.8.0.pre.1

data/lib/rollo/commands/services.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative '../model'
+
+module Rollo
+  module Commands
+    # rubocop:disable Metrics/ClassLength
+    class Services < Thor
+      namespace :services
+
+      def self.exit_on_failure?
+        true
+      end
+
+      desc(
+        'expand REGION ASG_NAME ECS_CLUSTER_NAME',
+        'Expands the service cluster by one batch.'
+      )
+      method_option(
+        :batch_size,
+        aliases: '-b',
+        type: :numeric,
+        default: 3,
+        desc: 'The number of service instances to add at a time.'
+      )
+      method_option(
+        :startup_time,
+        aliases: '-t',
+        type: :numeric,
+        default: 2,
+        desc: 'The number of minutes to wait for services to start up.'
+      )
+      method_option(
+        :maximum_instances,
+        aliases: '-mx',
+        type: :numeric,
+        desc: 'The maximum number of service instances to expand to.'
+      )
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      def expand(
+        region, _, ecs_cluster_name,
+        service_cluster = nil
+      )
+        batch_size = options[:batch_size]
+        maximum_instances = options[:maximum_instances]
+        service_start_wait_minutes = options[:startup_time]
+        service_start_wait_seconds = 60 * service_start_wait_minutes
+
+        service_cluster ||= Rollo::Model::ServiceCluster.new(ecs_cluster_name,
+                                                             region)
+
+        say("Increasing service instance counts by #{batch_size}...")
+        # rubocop:disable Metrics/BlockLength
+        with_padding do
+          service_cluster.with_replica_services do |on|
+            on.start do |services|
+              say(
+                'Service cluster contains services:' \
+                    "\n\t\t[#{services.map(&:name).join(",\n\t\t ")}]"
+              )
+            end
+            on.each_service do |service|
+              say(
+                "Increasing instance count by #{batch_size} " \
+                    "for #{service.name}"
+              )
+              # rubocop:disable Lint/ShadowingOuterLocalVariable
+              with_padding do
+                service.increase_instance_count_by(
+                  batch_size, maximum_instances: maximum_instances
+                ) do |on|
+                  on.prepare do |current, target|
+                    say(
+                      "Changing instance count from #{current} " \
+                          "to #{target}..."
+                    )
+                  end
+                  on.waiting_for_health do |attempt|
+                    say(
+                      'Waiting for service to reach a steady state ' \
+                          "(attempt #{attempt})..."
+                    )
+                  end
+                end
+              end
+              # rubocop:enable Lint/ShadowingOuterLocalVariable
+            end
+          end
+        end
+        # rubocop:enable Metrics/BlockLength
+        say(
+          "Waiting #{service_start_wait_minutes} minute(s) for " \
+              'services to finish starting...'
+        )
+        with_padding do
+          sleep(service_start_wait_seconds)
+          say(
+            "Waited #{service_start_wait_minutes} minute(s). " \
+                'Continuing...'
+          )
+        end
+        say('Service instance counts increased, continuing...')
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+
+      desc(
+        'contract REGION ASG_NAME ECS_CLUSTER_NAME',
+        'Contracts the service cluster by one batch.'
+      )
+      method_option(
+        :batch_size,
+        aliases: '-b',
+        type: :numeric,
+        default: 3,
+        desc: 'The number of service instances to remove at a time.'
+      )
+      method_option(
+        :minimum_instances,
+        aliases: '-mn',
+        type: :numeric,
+        desc: 'The minimum number of service instances to contract to.'
+      )
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      def contract(
+        region, _, ecs_cluster_name,
+        service_cluster = nil
+      )
+        batch_size = options[:batch_size]
+
+        service_cluster ||= Rollo::Model::ServiceCluster.new(ecs_cluster_name,
+                                                             region)
+
+        say("Decreasing service instance counts by #{batch_size}...")
+        with_padding do
+          service_cluster.with_replica_services do |on|
+            on.each_service do |service|
+              say(
+                "Decreasing instance count by #{batch_size} " \
+                    "for #{service.name}"
+              )
+              # rubocop:disable Lint/ShadowingOuterLocalVariable
+              with_padding do
+                service.decrease_instance_count_by(batch_size) do |on|
+                  on.prepare do |current, target|
+                    say(
+                      "Changing instance count from #{current} " \
+                          "to #{target}..."
+                    )
+                  end
+                  on.waiting_for_health do |attempt|
+                    say(
+                      'Waiting for service to reach a steady state ' \
+                          "(attempt #{attempt})..."
+                    )
+                  end
+                end
+              end
+              # rubocop:enable Lint/ShadowingOuterLocalVariable
+            end
+          end
+        end
+        say('Service instance counts decreased, continuing...')
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/rollo/model.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require_relative 'model/host_cluster'
 require_relative 'model/service_cluster'

data/lib/rollo/model/host.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rollo
   module Model
     class Host
@@ -13,11 +15,11 @@ module Rollo
         @instance.terminate(should_decrement_desired_capacity: false)
       end
 
-      def is_in_service?
+      def in_service?
         @instance.lifecycle_state == 'InService'
       end
 
-      def is_healthy?
+      def healthy?
         @instance.health_status == 'Healthy'
       end
     end

data/lib/rollo/model/host_cluster.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'aws-sdk'
 require 'hollerback'
+require 'wait'
 
 require_relative './scaling_activity'
 require_relative './host'
@@ -13,11 +16,11 @@ module Rollo
         @region = region
         @asg_name = asg_name
         @asg_resource = asg_resource ||
-            Aws::AutoScaling::Resource.new(region: region)
+                        Aws::AutoScaling::Resource.new(region: region)
         @asg = @asg_resource.group(@asg_name)
         record_latest_scaling_activity
 
-        @waiter = waiter || Wait.new(attempts: 300, timeout: 30, delay: 5)
+        @waiter = waiter || Wait.new(attempts: 720, timeout: 30, delay: 5)
       end
 
       def reload
@@ -33,30 +36,30 @@ module Rollo
       end
 
       def desired_capacity=(capacity)
-        @asg.set_desired_capacity({desired_capacity: capacity})
+        @asg.set_desired_capacity({ desired_capacity: capacity })
       end
 
-      def has_desired_capacity?
+      def desired_capacity?
         hosts.size == desired_capacity &&
-            hosts.all? {|h| h.is_in_service? && h.is_healthy?}
+          hosts.all? { |h| h.in_service? && h.healthy? }
       end
 
       def scaling_activities
-        @asg.activities.collect {|a| ScalingActivity.new(a)}
+        @asg.activities.collect { |a| ScalingActivity.new(a) }
       end
 
-      def has_started_changing_capacity?
+      def started_changing_capacity?
         scaling_activities
-            .select {|a| a.started_after_completion_of?(@last_scaling_activity)}
-            .size > 0
+          .select { |a| a.started_after_completion_of?(@last_scaling_activity) }
+          .size.positive?
       end
 
-      def has_completed_changing_capacity?
-        scaling_activities.all?(&:is_complete?)
+      def completed_changing_capacity?
+        scaling_activities.all?(&:complete?)
       end
 
       def hosts
-        @asg.instances.collect {|h| Host.new(h)}
+        @asg.instances.collect { |h| Host.new(h) }
       end
 
       def increase_capacity_by(capacity_delta, &block)
@@ -64,7 +67,8 @@ module Rollo
         increased = initial + capacity_delta
 
         callbacks_for(block).try_respond_with(
-            :prepare, initial, increased)
+          :prepare, initial, increased
+        )
 
         ensure_capacity_changed_to(increased, &block)
       end
@@ -74,7 +78,8 @@ module Rollo
         decreased = initial - capacity_delta
 
         callbacks_for(block).try_respond_with(
-            :prepare, initial, decreased)
+          :prepare, initial, decreased
+        )
 
         ensure_capacity_changed_to(decreased, &block)
       end
@@ -90,27 +95,33 @@ module Rollo
       def wait_for_capacity_change_start(&block)
         @waiter.until do |attempt|
           reload
-          callbacks_for(block)
-              .try_respond_with(:waiting_for_start, attempt) if block
-          has_started_changing_capacity?
+          if block
+            callbacks_for(block)
+              .try_respond_with(:waiting_for_start, attempt)
+          end
+          started_changing_capacity?
         end
       end
 
       def wait_for_capacity_change_end(&block)
         @waiter.until do |attempt|
           reload
-          callbacks_for(block)
-              .try_respond_with(:waiting_for_end, attempt) if block
-          has_completed_changing_capacity?
+          if block
+            callbacks_for(block)
+              .try_respond_with(:waiting_for_end, attempt)
+          end
+          completed_changing_capacity?
         end
       end
 
       def wait_for_capacity_health(&block)
         @waiter.until do |attempt|
           reload
-          callbacks_for(block)
-              .try_respond_with(:waiting_for_health, attempt) if block
-          has_desired_capacity?
+          if block
+            callbacks_for(block)
+              .try_respond_with(:waiting_for_health, attempt)
+          end
+          desired_capacity?
         end
       end
 

data/lib/rollo/model/scaling_activity.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rollo
   module Model
     class ScalingActivity
@@ -18,14 +20,14 @@ module Rollo
       end
 
       def started_after_completion_of?(other)
-        self.id != other.id &&
-            !self.start_time.nil? &&
-            !other.end_time.nil? &&
-            self.start_time > other.end_time
+        id != other.id &&
+          !start_time.nil? &&
+          !other.end_time.nil? &&
+          start_time > other.end_time
       end
 
-      def is_complete?
-        %w(Successful Failed Cancelled).include?(@activity.status_code)
+      def complete?
+        %w[Successful Failed Cancelled].include?(@activity.status_code)
       end
     end
   end

data/lib/rollo/model/service.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aws-sdk'
 require 'wait'
 require 'hollerback'
@@ -6,14 +8,15 @@ module Rollo
   module Model
     class Service
       def initialize(
-          ecs_cluster_name, ecs_service_arn, region,
-              ecs_resource = nil, waiter = nil)
+        ecs_cluster_name, ecs_service_arn, region,
+        ecs_resource = nil, waiter = nil
+      )
         @ecs_cluster_name = ecs_cluster_name
         @ecs_service_arn = ecs_service_arn
         @ecs_resource = ecs_resource || Aws::ECS::Resource.new(region: region)
         reload
 
-        @waiter = waiter || Wait.new(attempts: 300, timeout: 30, delay: 5)
+        @waiter = waiter || Wait.new(attempts: 720, timeout: 30, delay: 5)
       end
 
       def name
@@ -25,10 +28,10 @@ module Rollo
       end
 
       def reload
-        @ecs_service = get_ecs_service
+        @ecs_service = ecs_service
       end
 
-      def is_replica?
+      def replica?
         @ecs_service.scheduling_strategy == 'REPLICA'
       end
 
@@ -42,34 +45,41 @@ module Rollo
 
       def desired_count=(count)
         @ecs_resource.client
-            .update_service(
-                cluster: @ecs_cluster_name,
-                service: @ecs_service_arn,
-                desired_count: count)
+                     .update_service(
+                       cluster: @ecs_cluster_name,
+                       service: @ecs_service_arn,
+                       desired_count: count
+                     )
       end
 
-      def has_desired_count?
+      def desired_count_met?
         running_count == desired_count
       end
 
-      def increase_instance_count_by(count_delta, &block)
+      def increase_instance_count_by(count_delta, options = {}, &block)
+        maximum = options[:maximum_instance_count] || Float::INFINITY
         initial = desired_count
         increased = initial + count_delta
+        target = [increased, maximum].min
 
         callbacks_for(block).try_respond_with(
-            :prepare, initial, increased)
+          :prepare, initial, target
+        )
 
-        ensure_instance_count(increased, &block)
+        ensure_instance_count(target, &block)
       end
 
-      def decrease_instance_count_by(count_delta, &block)
+      def decrease_instance_count_by(count_delta, options = {}, &block)
+        minimum = options[:minimum_instance_count] || 0
         initial = desired_count
         decreased = initial - count_delta
+        target = [decreased, minimum].max
 
         callbacks_for(block).try_respond_with(
-            :prepare, initial, decreased)
+          :prepare, initial, target
+        )
 
-        ensure_instance_count(decreased, &block)
+        ensure_instance_count(target, &block)
       end
 
       def ensure_instance_count(count, &block)
@@ -80,20 +90,23 @@ module Rollo
       def wait_for_service_health(&block)
         @waiter.until do |attempt|
           reload
-          callbacks_for(block)
-              .try_respond_with(:waiting_for_health, attempt) if block
-          has_desired_count?
+          if block
+            callbacks_for(block)
+              .try_respond_with(:waiting_for_health, attempt)
+          end
+          desired_count_met?
         end
       end
 
       private
 
-      def get_ecs_service
+      def ecs_service
         @ecs_resource.client
-            .describe_services(
-                cluster: @ecs_cluster_name,
-                services: [@ecs_service_arn])
-            .services[0]
+                     .describe_services(
+                       cluster: @ecs_cluster_name,
+                       services: [@ecs_service_arn]
+                     )
+                     .services[0]
       end
 
       def callbacks_for(block)