rollo 0.5.0 → 0.8.0.pre.2

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018 Toby Clemson
+Copyright (c) 2021 InfraBlocks Maintainers
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/Rakefile

@@ -1,24 +1,148 @@
-require "rspec/core/rake_task"
+# frozen_string_literal: true
 
-RSpec::Core::RakeTask.new(:spec)
+require 'yaml'
+require 'rake_circle_ci'
+require 'rake_github'
+require 'rake_ssh'
+require 'rake_gpg'
+require 'securerandom'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 
-task :default => :spec
+task default: %i[
+  library:fix
+  test:unit
+]
+
+namespace :encryption do
+  namespace :directory do
+    desc 'Ensure CI secrets directory exists.'
+    task :ensure do
+      FileUtils.mkdir_p('config/secrets/ci')
+    end
+  end
+
+  namespace :passphrase do
+    desc 'Generate encryption passphrase used by CI.'
+    task generate: ['directory:ensure'] do
+      File.open('config/secrets/ci/encryption.passphrase', 'w') do |f|
+        f.write(SecureRandom.base64(36))
+      end
+    end
+  end
+end
+
+namespace :keys do
+  namespace :deploy do
+    RakeSSH.define_key_tasks(
+      path: 'config/secrets/ci/',
+      comment: 'maintainers@infrablocks.io'
+    )
+  end
+
+  namespace :secrets do
+    namespace :gpg do
+      RakeGPG.define_generate_key_task(
+        output_directory: 'config/secrets/ci',
+        name_prefix: 'gpg',
+        owner_name: 'InfraBlocks Maintainers',
+        owner_email: 'maintainers@infrablocks.io',
+        owner_comment: 'rollo CI Key'
+      )
+    end
+
+    desc 'Generate key used by CI to access secrets.'
+    task generate: [:'gpg:generate']
+  end
+end
+
+namespace :secrets do
+  desc 'Regenerate all generatable secrets.'
+  task regenerate: %w[
+    encryption:passphrase:generate
+    keys:deploy:generate
+    keys:secrets:generate
+  ]
+end
+
+RuboCop::RakeTask.new
+
+namespace :library do
+  desc 'Run all checks of the library'
+  task check: [:rubocop]
+
+  desc 'Attempt to automatically fix issues with the library'
+  task fix: [:'rubocop:auto_correct']
+end
+
+namespace :test do
+  RSpec::Core::RakeTask.new(:unit)
+end
+
+RakeCircleCI.define_project_tasks(
+  namespace: :circle_ci,
+  project_slug: 'github/infrablocks/rollo'
+) do |t|
+  circle_ci_config =
+    YAML.load_file('config/secrets/circle_ci/config.yaml')
+
+  t.api_token = circle_ci_config['circle_ci_api_token']
+  t.environment_variables = {
+    ENCRYPTION_PASSPHRASE:
+      File.read('config/secrets/ci/encryption.passphrase')
+          .chomp
+  }
+  t.checkout_keys = []
+  t.ssh_keys = [
+    {
+      hostname: 'github.com',
+      private_key: File.read('config/secrets/ci/ssh.private')
+    }
+  ]
+end
+
+RakeGithub.define_repository_tasks(
+  namespace: :github,
+  repository: 'infrablocks/rollo'
+) do |t|
+  github_config =
+    YAML.load_file('config/secrets/github/config.yaml')
+
+  t.access_token = github_config['github_personal_access_token']
+  t.deploy_keys = [
+    {
+      title: 'CircleCI',
+      public_key: File.read('config/secrets/ci/ssh.public')
+    }
+  ]
+end
+
+namespace :pipeline do
+  desc 'Prepare CircleCI Pipeline'
+  task prepare: %i[
+    circle_ci:project:follow
+    circle_ci:env_vars:ensure
+    circle_ci:checkout_keys:ensure
+    circle_ci:ssh_keys:ensure
+    github:deploy_keys:ensure
+  ]
+end
 
 namespace :version do
-  desc "Bump version for specified type (pre, major, minor patch)"
+  desc 'Bump version for specified type (pre, major, minor, patch)'
   task :bump, [:type] do |_, args|
     bump_version_for(args.type)
   end
 end
 
-desc "Release gem"
+desc 'Release gem'
 task :release do
-  sh "gem release --tag --push"
+  sh 'gem release --tag --push'
 end
 
 def bump_version_for(version_type)
-  sh "gem bump --version #{version_type} " +
-      "&& bundle install " +
-      "&& export LAST_MESSAGE=\"$(git log -1 --pretty=%B)\" " +
-      "&& git commit -a --amend -m \"${LAST_MESSAGE} [ci skip]\""
+  sh "gem bump --version #{version_type} " \
+     '&& bundle install ' \
+     '&& export LAST_MESSAGE="$(git log -1 --pretty=%B)" ' \
+     '&& git commit -a --amend -m "${LAST_MESSAGE} [ci skip]"'
 end

data/bin/console

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "bundler/setup"
-require "rollo"
+require 'bundler/setup'
+require 'rollo'
 
 # 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.
@@ -10,5 +11,5 @@ require "rollo"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start(__FILE__)

data/lib/rollo/commands/hosts.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require 'thor'
 require_relative '../model'
 
 module Rollo
   module Commands
+    # rubocop:disable Metrics/ClassLength
     class Hosts < Thor
       namespace :hosts
 
@@ -11,176 +14,219 @@ module Rollo
       end
 
       desc(
-          'expand REGION ASG_NAME ECS_CLUSTER_NAME',
-          'Expands the host cluster by one batch.')
+        'expand REGION ASG_NAME ECS_CLUSTER_NAME',
+        'Expands the host cluster by one batch.'
+      )
       method_option(
-          :batch_size,
-          aliases: '-b',
-          type: :numeric,
-          default: 3,
-          desc: 'The number of hosts to add at a time.')
+        :batch_size,
+        aliases: '-b',
+        type: :numeric,
+        default: 3,
+        desc: 'The number of hosts to add at a time.'
+      )
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
       def expand(
-          region, asg_name, _,
-              host_cluster = nil)
+        region, asg_name, _,
+        host_cluster = nil
+      )
         batch_size = options[:batch_size]
 
-        host_cluster = host_cluster ||
-            Rollo::Model::HostCluster.new(asg_name, region)
+        host_cluster ||= Rollo::Model::HostCluster.new(asg_name, region)
 
         say("Increasing host cluster desired capacity by #{batch_size}...")
         with_padding do
           host_cluster.increase_capacity_by(batch_size) do |on|
             on.prepare do |current, target|
               say(
-                  "Changing desired capacity from #{current} to " +
-                      "#{target}...")
+                "Changing desired capacity from #{current} to " \
+                "#{target}..."
+              )
             end
             on.waiting_for_start do |attempt|
               say(
-                  'Waiting for capacity change to start ' +
-                      "(attempt #{attempt})...")
+                'Waiting for capacity change to start ' \
+                "(attempt #{attempt})..."
+              )
             end
             on.waiting_for_end do |attempt|
               say(
-                  'Waiting for capacity change to complete ' +
-                      "(attempt #{attempt})...")
+                'Waiting for capacity change to complete ' \
+                "(attempt #{attempt})..."
+              )
             end
             on.waiting_for_health do |attempt|
               say("Waiting for a healthy state (attempt #{attempt})")
             end
           end
         end
-        say "Host cluster desired capacity increased, continuing..."
+        say 'Host cluster desired capacity increased, continuing...'
       end
 
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+
       desc(
-          'contract REGION ASG_NAME ECS_CLUSTER_NAME',
-          'Contracts the host cluster by one batch')
+        'contract REGION ASG_NAME ECS_CLUSTER_NAME',
+        'Contracts the host cluster by one batch'
+      )
       method_option(
-          :batch_size,
-          aliases: '-b',
-          type: :numeric,
-          default: 3,
-          desc: 'The number of hosts to remove at a time.')
+        :batch_size,
+        aliases: '-b',
+        type: :numeric,
+        default: 3,
+        desc: 'The number of hosts to remove at a time.'
+      )
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
       def contract(
-          region, asg_name, ecs_cluster_name,
-              host_cluster = nil, service_cluster = nil)
+        region, asg_name, ecs_cluster_name,
+        host_cluster = nil, service_cluster = nil
+      )
         batch_size = options[:batch_size]
 
-        host_cluster = host_cluster ||
-            Rollo::Model::HostCluster.new(asg_name, region)
-        service_cluster = service_cluster ||
-            Rollo::Model::ServiceCluster.new(ecs_cluster_name, region)
+        host_cluster ||= Rollo::Model::HostCluster.new(asg_name, region)
+        service_cluster ||= Rollo::Model::ServiceCluster.new(
+          ecs_cluster_name, region
+        )
 
         say("Decreasing host cluster desired capacity by #{batch_size}...")
+        # rubocop:disable Metrics/BlockLength
         with_padding do
           host_cluster.decrease_capacity_by(batch_size) do |on|
             on.prepare do |current, target|
               say(
-                  "Changing desired capacity from #{current} to " +
-                      "#{target}...")
+                "Changing desired capacity from #{current} to " \
+                "#{target}..."
+              )
             end
             on.waiting_for_start do |attempt|
               say(
-                  "Waiting for capacity change to start " +
-                      "(attempt #{attempt})...")
+                'Waiting for capacity change to start ' \
+                "(attempt #{attempt})..."
+              )
             end
             on.waiting_for_end do |attempt|
               say(
-                  "Waiting for capacity change to complete " +
-                      "(attempt #{attempt})...")
+                'Waiting for capacity change to complete ' \
+                "(attempt #{attempt})..."
+              )
             end
             on.waiting_for_health do |attempt|
               say(
-                  "Waiting for host cluster to reach healthy state " +
-                      "(attempt #{attempt})...")
+                'Waiting for host cluster to reach healthy state ' \
+                "(attempt #{attempt})..."
+              )
             end
           end
-          service_cluster.with_replica_services do |on|
-            on.each_service do |service|
+          service_cluster.with_replica_services do |services|
+            services.each_service do |service|
               service.wait_for_service_health do |on|
                 on.waiting_for_health do |attempt|
                   say(
-                      "Waiting for service #{service.name} to reach a " +
-                          "steady state (attempt #{attempt})...")
+                    "Waiting for service #{service.name} to reach a " \
+                    "steady state (attempt #{attempt})..."
+                  )
                 end
               end
             end
           end
         end
-        say "Host cluster desired capacity decreased, continuing..."
+        # rubocop:enable Metrics/BlockLength
+        say 'Host cluster desired capacity decreased, continuing...'
       end
 
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+
       desc(
-          'terminate REGION ASG_NAME ECS_CLUSTER_NAME INSTANCE_IDS*',
-          'Terminates the specified hosts within the cluster.')
+        'terminate REGION ASG_NAME ECS_CLUSTER_NAME INSTANCE_IDS*',
+        'Terminates the specified hosts within the cluster.'
+      )
       method_option(
-          :batch_size,
-          aliases: '-b',
-          type: :numeric,
-          default: 3,
-          desc: 'The number of hosts to add at a time.')
+        :batch_size,
+        aliases: '-b',
+        type: :numeric,
+        default: 3,
+        desc: 'The number of hosts 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.'
+      )
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/ParameterLists
       def terminate(
-          region, asg_name, ecs_cluster_name, instance_ids,
-              host_cluster = nil, service_cluster = nil)
+        region, asg_name, ecs_cluster_name, instance_ids,
+        host_cluster = nil, service_cluster = nil
+      )
         batch_size = options[:batch_size]
 
         service_start_wait_minutes = options[:startup_time]
         service_start_wait_seconds = 60 * service_start_wait_minutes
 
-        host_cluster = host_cluster ||
-            Rollo::Model::HostCluster.new(asg_name, region)
-        service_cluster = service_cluster ||
-            Rollo::Model::ServiceCluster.new(ecs_cluster_name, region)
+        host_cluster ||= Rollo::Model::HostCluster.new(asg_name, region)
+        service_cluster ||= Rollo::Model::ServiceCluster.new(ecs_cluster_name,
+                                                             region)
 
-        hosts = host_cluster.hosts.select {|h| instance_ids.include?(h.id) }
+        hosts = host_cluster.hosts.select { |h| instance_ids.include?(h.id) }
         host_batches = hosts.each_slice(batch_size).to_a
 
         say(
-            'Terminating old hosts in host cluster in batches of ' +
-                "#{batch_size}...")
+          'Terminating old hosts in host cluster in batches of ' \
+          "#{batch_size}..."
+        )
+        # rubocop:disable Metrics/BlockLength
         with_padding do
           host_batches.each_with_index do |host_batch, index|
             say(
-                "Batch #{index + 1} contains hosts: " +
-                    "\n\t\t[#{host_batch.map(&:id).join(",\n\t\t ")}]\n" +
-                    'Terminating...')
+              "Batch #{index + 1} contains hosts: " \
+              "\n\t\t[#{host_batch.map(&:id).join(",\n\t\t ")}]\n" \
+              'Terminating...'
+            )
             host_batch.each(&:terminate)
             host_cluster.wait_for_capacity_health do |on|
               on.waiting_for_health do |attempt|
                 say(
-                    'Waiting for host cluster to reach healthy state ' +
-                        "(attempt #{attempt})")
+                  'Waiting for host cluster to reach healthy state ' \
+                  "(attempt #{attempt})"
+                )
               end
             end
-            service_cluster.with_replica_services do |on|
-              on.each_service do |service|
+            service_cluster.with_replica_services do |services|
+              services.each_service do |service|
                 service.wait_for_service_health do |on|
                   on.waiting_for_health do |attempt|
                     say(
-                        "Waiting for service #{service.name} to reach a " +
-                            "steady state (attempt #{attempt})...")
+                      "Waiting for service #{service.name} to reach a " \
+                      "steady state (attempt #{attempt})..."
+                    )
                   end
                 end
               end
             end
             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...'
+            )
             sleep(service_start_wait_seconds)
             say(
-                "Waited #{service_start_wait_minutes} minute(s). " +
-                    'Continuing...')
+              "Waited #{service_start_wait_minutes} minute(s). " \
+              'Continuing...'
+            )
           end
         end
-
+        # rubocop:enable Metrics/BlockLength
       end
+      # rubocop:enable Metrics/ParameterLists
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
     end
+
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/rollo/commands/main.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'thor'
 require_relative '../model'
 require_relative './hosts'
@@ -24,27 +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.'
+      )
       method_option(
-          :batch_size,
-          aliases: '-b',
-          type: :numeric,
-          default: 3,
-          desc:
-              'The number of hosts / service instances to add / remove at ' +
-                  'a time.')
+        :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.'
+      )
+      # 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 ')
@@ -53,44 +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
-              ])
+            '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
-              ])
+            '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