rollo 0.7.0 → 0.8.0.pre.1

data/lib/rollo/commands/main.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'thor'
 require_relative '../model'
 require_relative './hosts'
@@ -24,38 +26,44 @@ module Rollo
       end
 
       desc('roll REGION ASG_NAME ECS_CLUSTER_NAME',
-          'Rolls all hosts in the cluster')
+           'Rolls all hosts in the cluster')
       method_option(
-          :batch_size,
-          aliases: '-b',
-          type: :numeric,
-          default: 3,
-          desc:
-              'The number of hosts / service instances to add / remove at ' +
-                  'a time.')
+        :batch_size,
+        aliases: '-b',
+        type: :numeric,
+        default: 3,
+        desc:
+            'The number of hosts / service instances to add / remove at ' \
+                'a time.'
+      )
       method_option(
-          :maximum_service_instances,
-          aliases: '-mx',
-          type: :numeric,
-          desc: 'The maximum number of service instances to expand to.')
+        :maximum_service_instances,
+        aliases: '-mx',
+        type: :numeric,
+        desc: 'The maximum number of service instances to expand to.'
+      )
       method_option(
-          :minimum_service_instances,
-          aliases: '-mn',
-          type: :numeric,
-          desc: 'The minimum number of service instances to contract to.')
-
+        :minimum_service_instances,
+        aliases: '-mn',
+        type: :numeric,
+        desc: 'The minimum number of service instances to contract to.'
+      )
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize
       def roll(region, asg_name, ecs_cluster_name)
         host_cluster = Rollo::Model::HostCluster.new(asg_name, region)
         service_cluster = Rollo::Model::ServiceCluster
-            .new(ecs_cluster_name, region)
+                          .new(ecs_cluster_name, region)
 
         initial_hosts = host_cluster.hosts
 
         say(
-            "Rolling instances in host cluster #{host_cluster.name} for " +
-                "service cluster #{service_cluster.name}...")
+          "Rolling instances in host cluster #{host_cluster.name} for " \
+              "service cluster #{service_cluster.name}..."
+        )
+        # rubocop:disable Metrics/BlockLength
         with_padding do
-          unless host_cluster.has_desired_capacity?
+          unless host_cluster.desired_capacity?
             say('ERROR: Host cluster is not in stable state.')
             say('This may be due to scaling above or below the desired')
             say('capacity or because hosts are not in service or are ')
@@ -64,46 +72,53 @@ module Rollo
           end
 
           invoke(
-              "hosts:expand",
-              [
-                  region, asg_name, ecs_cluster_name,
-                  host_cluster
-              ])
+            'hosts:expand',
+            [
+              region, asg_name, ecs_cluster_name,
+              host_cluster
+            ]
+          )
 
           invoke(
-              "services:expand",
-              [
-                  region, asg_name, ecs_cluster_name,
-                  service_cluster
-              ],
-              maximum_instances: options[:maximum_service_instances])
+            'services:expand',
+            [
+              region, asg_name, ecs_cluster_name,
+              service_cluster
+            ],
+            maximum_instances: options[:maximum_service_instances]
+          )
 
           invoke(
-              "hosts:terminate",
-              [
-                  region, asg_name, ecs_cluster_name, initial_hosts.map(&:id),
-                  host_cluster, service_cluster
-              ])
+            'hosts:terminate',
+            [
+              region, asg_name, ecs_cluster_name, initial_hosts.map(&:id),
+              host_cluster, service_cluster
+            ]
+          )
 
           invoke(
-              "hosts:contract",
-              [
-                  region, asg_name, ecs_cluster_name,
-                  host_cluster, service_cluster
-              ])
+            'hosts:contract',
+            [
+              region, asg_name, ecs_cluster_name,
+              host_cluster, service_cluster
+            ]
+          )
 
           invoke(
-              "services:contract",
-              [
-                  region, asg_name, ecs_cluster_name,
-                  service_cluster
-              ],
-              minimum_instances: options[:minimum_service_instances])
+            'services:contract',
+            [
+              region, asg_name, ecs_cluster_name,
+              service_cluster
+            ],
+            minimum_instances: options[:minimum_service_instances]
+          )
         end
-
-        say("Instances in host cluster #{host_cluster.name} rolled " +
-            "successfully.")
+        # rubocop:enable Metrics/BlockLength
+        say("Instances in host cluster #{host_cluster.name} rolled " \
+            'successfully.')
       end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
     end
   end
-end
+end

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,128 +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.')
-
+        :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, maximum_instances: maximum_instances) do |on|
+                  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.')
-
+        :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/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,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'aws-sdk'
 require 'hollerback'
 require 'wait'
@@ -14,7 +16,7 @@ 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
 
@@ -34,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)
@@ -65,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
@@ -75,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
@@ -91,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