rollo 0.5.0 → 0.8.0.pre.2

data/lib/rollo/commands/services.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require 'thor'
 require_relative '../model'
 
 module Rollo
   module Commands
+    # rubocop:disable Metrics/ClassLength
     class Services < Thor
       namespace :services
 
@@ -11,116 +14,160 @@ module Rollo
       end
 
       desc(
-          'expand REGION ASG_NAME ECS_CLUSTER_NAME',
-          'Expands the service cluster by one batch.')
+        '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.')
+        :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.')
-
+        :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)
+        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 = service_cluster ||
-            Rollo::Model::ServiceCluster.new(ecs_cluster_name, region)
+        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 ")}]")
+                '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}")
+                "Increasing instance count by #{batch_size} " \
+                "for #{service.name}"
+              )
+              # rubocop:disable Lint/ShadowingOuterLocalVariable
               with_padding do
-                service.increase_instance_count_by(batch_size) do |on|
+                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}...")
+                      "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})...")
+                      '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...')
+          "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...')
+            "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.')
+        '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.')
-
+        :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)
+        region, _, ecs_cluster_name,
+        service_cluster = nil
+      )
         batch_size = options[:batch_size]
 
-        service_cluster = service_cluster ||
-            Rollo::Model::ServiceCluster.new(ecs_cluster_name, region)
+        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}")
+                "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}...")
+                      "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})...")
+                      '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...")
+        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/commands.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require_relative 'commands/main'

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)

data/lib/rollo/model/service_cluster.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aws-sdk'
 require 'hollerback'
 
@@ -10,7 +12,7 @@ module Rollo
         @region = region
         @ecs_cluster_name = ecs_cluster_name
         @ecs_resource = ecs_resource || Aws::ECS::Resource.new(region: region)
-        @ecs_cluster = get_ecs_cluster
+        @ecs_cluster = ecs_cluster
       end
 
       def name
@@ -18,9 +20,9 @@ module Rollo
       end
 
       def replica_services
-        get_ecs_service_arns
-            .collect {|arn| Service.new(@ecs_cluster_name, arn, @region)}
-            .select(&:is_replica?)
+        ecs_service_arns
+          .collect { |arn| Service.new(@ecs_cluster_name, arn, @region) }
+          .select(&:replica?)
       end
 
       def with_replica_services(&block)
@@ -28,7 +30,8 @@ module Rollo
 
         callbacks = Hollerback::Callbacks.new(block)
         callbacks.try_respond_with(
-            :start, all_replica_services)
+          :start, all_replica_services
+        )
 
         all_replica_services.each do |service|
           callbacks.try_respond_with(:each_service, service)
@@ -37,17 +40,19 @@ module Rollo
 
       private
 
-      def get_ecs_cluster
-        @ecs_resource.client
-            .describe_clusters(clusters: [@ecs_cluster_name])
-            .clusters[0]
+      def ecs_cluster
+        @ecs_resource
+          .client
+          .describe_clusters(clusters: [@ecs_cluster_name])
+          .clusters[0]
       end
 
-      def get_ecs_service_arns
-        @ecs_resource.client
-            .list_services(cluster: @ecs_cluster.cluster_name)
-            .inject([]) {|arns, response| arns + response.service_arns}
+      def ecs_service_arns
+        @ecs_resource
+          .client
+          .list_services(cluster: @ecs_cluster.cluster_name)
+          .inject([]) { |arns, response| arns + response.service_arns }
       end
     end
   end
-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/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rollo
-  VERSION = "0.5.0"
+  VERSION = '0.8.0.pre.2'
 end

data/lib/rollo.rb

@@ -1,4 +1,6 @@
-require_relative "rollo/version"
+# frozen_string_literal: true
+
+require_relative 'rollo/version'
 require_relative 'rollo/commands'
 
 module Rollo