rollo 0.1.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Toby Clemson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,58 @@
+# Rollo
+
+Welcome to your new gem! In this directory, you'll find the files you need to 
+be able to package up your Ruby library into a gem. Put your Ruby code in the 
+file `lib/rollo`. To experiment with that code, run `bin/console` for an 
+interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rollo'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rollo
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run 
+`rake spec` to run the tests. You can also run `bin/console` for an interactive 
+prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To 
+release a new version, update the version number in `version.rb`, and then run 
+`bundle exec rake release`, which will create a git tag for the version, push 
+git commits and tags, and push the `.gem` file to 
+[rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at 
+https://github.com/infrablocks/rollo. This project is intended to be a safe, 
+welcoming space for collaboration, and contributors are expected to adhere to 
+the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the 
+[MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Rollo project’s codebases, issue trackers, chat 
+rooms and mailing lists is expected to follow the [code of conduct](
+https://github.com/[USERNAME]/rollo/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,24 @@
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+namespace :version do
+  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"
+task :release do
+  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]\""
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+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.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/rollo

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'thor'
+require 'rollo'
+
+Rollo::Commands::Main.start

data/go

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+
+[ -n "$GO_DEBUG" ] && set -x
+set -e
+
+project_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+verbose="no"
+skip_checks="no"
+offline="no"
+
+missing_dependency="no"
+
+[ -n "$GO_DEBUG" ] && verbose="yes"
+[ -n "$GO_SKIP_CHECKS" ] && skip_checks="yes"
+[ -n "$GO_OFFLINE" ] && offline="yes"
+
+
+if [[ "$skip_checks" = "no" ]]; then
+    echo "Checking for system dependencies."
+    ruby_version="$(cat "$project_dir"/.ruby-version)"
+    if ! type ruby >/dev/null 2>&1 || ! ruby -v | grep -q "$ruby_version"; then
+        echo "This codebase requires Ruby $ruby_version."
+        missing_dependency="yes"
+    fi
+
+    if ! type bundler >/dev/null 2>&1; then
+        echo "This codebase requires Bundler."
+        missing_dependency="yes"
+    fi
+
+    if [[ "$missing_dependency" = "yes" ]]; then
+        echo "Please install missing dependencies to continue."
+        exit 1
+    fi
+
+    echo "All system dependencies present. Continuing."
+fi
+
+if [[ "$offline" = "no" ]]; then
+    echo "Installing bundler."
+    if [[ "$verbose" = "yes" ]]; then
+        gem install --no-document bundler
+    else
+        gem install --no-document bundler > /dev/null
+    fi
+
+    echo "Installing ruby dependencies."
+    if [[ "$verbose" = "yes" ]]; then
+        bundle install
+    else
+        bundle install > /dev/null
+    fi
+fi
+
+echo "Starting rake."
+if [[ "$verbose" = "yes" ]]; then
+    time bundle exec rake --verbose "$@"
+else
+    time bundle exec rake "$@"
+fi

data/lib/rollo/commands/host_cluster.rb

@@ -0,0 +1,184 @@
+require 'thor'
+require_relative '../model'
+
+module Rollo
+  module Commands
+    class HostCluster < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      desc(
+          'expand REGION ASG_NAME ECS_CLUSTER_NAME',
+          '')
+      method_option(
+          :batch_size,
+          aliases: '-b',
+          type: :numeric,
+          default: 3,
+          desc: 'The number of hosts to add at a time.')
+      def expand(
+          region, asg_name, _,
+              host_cluster = nil)
+        batch_size = options[:batch_size]
+
+        host_cluster = host_cluster ||
+            Rollo::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}...")
+            end
+            on.waiting_for_start do |attempt|
+              say(
+                  'Waiting for capacity change to start ' +
+                      "(attempt #{attempt})...")
+            end
+            on.waiting_for_end do |attempt|
+              say(
+                  '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..."
+      end
+
+      desc(
+          'contract REGION ASG_NAME ECS_CLUSTER_NAME',
+          '')
+      method_option(
+          :batch_size,
+          aliases: '-b',
+          type: :numeric,
+          default: 3,
+          desc: 'The number of hosts to remove at a time.')
+      def contract(
+          region, asg_name, ecs_cluster_name,
+              host_cluster = nil, service_cluster = nil)
+        batch_size = options[:batch_size]
+
+        host_cluster = host_cluster ||
+            Rollo::HostCluster.new(asg_name, region)
+        service_cluster = service_cluster ||
+            Rollo::ServiceCluster.new(ecs_cluster_name, region)
+
+        say("Decreasing host cluster desired capacity by #{batch_size}...")
+        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}...")
+            end
+            on.waiting_for_start do |attempt|
+              say(
+                  "Waiting for capacity change to start " +
+                      "(attempt #{attempt})...")
+            end
+            on.waiting_for_end do |attempt|
+              say(
+                  "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})...")
+            end
+          end
+          service_cluster.with_replica_services do |on|
+            on.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})...")
+                end
+              end
+            end
+          end
+        end
+        say "Host cluster desired capacity decreased, continuing..."
+      end
+
+      desc(
+          'terminate REGION ASG_NAME ECS_CLUSTER_NAME INSTANCE_IDS*',
+          '')
+      method_option(
+          :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.')
+      def terminate(
+          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::HostCluster.new(asg_name, region)
+        service_cluster = service_cluster ||
+            Rollo::ServiceCluster.new(ecs_cluster_name, region)
+
+        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}...")
+        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...')
+            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})")
+              end
+            end
+            service_cluster.with_replica_services do |on|
+              on.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})...")
+                  end
+                end
+              end
+            end
+            say(
+                "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...')
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/rollo/commands/main.rb

@@ -0,0 +1,93 @@
+require 'thor'
+require_relative '../model'
+require_relative './host_cluster'
+require_relative './service_cluster'
+
+module Rollo
+  module Commands
+    class Main < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      desc('host-cluster', 'manages the host cluster')
+      subcommand "host-cluster", HostCluster
+
+      desc('service-cluster', 'manages the service cluster')
+      subcommand "service-cluster", ServiceCluster
+
+      desc('version', 'prints the version number of rollo')
+      def version
+        say Rollo::VERSION
+      end
+
+      desc('roll REGION ASG_NAME ECS_CLUSTER_NAME',
+          'rolls all instances in an ECS cluster')
+      method_option(
+          :batch_size,
+          aliases: '-b',
+          type: :numeric,
+          default: 3,
+          desc:
+              'The number of hosts / service instances to add / remove at ' +
+                  'a time.')
+      def roll(region, asg_name, ecs_cluster_name)
+        host_cluster = Rollo::HostCluster.new(asg_name, region)
+        service_cluster = Rollo::ServiceCluster.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}...")
+        with_padding do
+          unless host_cluster.has_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 ')
+            say('unhealthy. Cowardly refusing to roll instances.')
+            exit 1
+          end
+
+          invoke(
+              "host-cluster:expand",
+              [
+                  region, asg_name, ecs_cluster_name,
+                  host_cluster
+              ])
+
+          invoke(
+              "service-cluster:expand",
+              [
+                  region, asg_name, ecs_cluster_name,
+                  service_cluster
+              ])
+
+          invoke(
+              "host-cluster:terminate",
+              [
+                  region, asg_name, ecs_cluster_name, initial_hosts.map(&:id),
+                  host_cluster, service_cluster
+              ])
+
+          invoke(
+              "host-cluster:contract",
+              [
+                  region, asg_name, ecs_cluster_name,
+                  host_cluster, service_cluster
+              ])
+
+          invoke(
+              "service-cluster:contract",
+              [
+                  region, asg_name, ecs_cluster_name,
+                  service_cluster
+              ])
+        end
+
+        say("Instances in host cluster #{host_cluster.name} rolled " +
+            "successfully.")
+      end
+    end
+  end
+end

data/lib/rollo/commands/service_cluster.rb

@@ -0,0 +1,124 @@
+require 'thor'
+require_relative '../model'
+
+module Rollo
+  module Commands
+    class ServiceCluster < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      desc(
+          'expand REGION ASG_NAME ECS_CLUSTER_NAME',
+          '')
+      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.')
+
+      def expand(
+          region, _, ecs_cluster_name,
+              service_cluster = nil)
+        batch_size = options[:batch_size]
+        service_start_wait_minutes = options[:startup_time]
+        service_start_wait_seconds = 60 * service_start_wait_minutes
+
+        service_cluster = service_cluster ||
+            Rollo::ServiceCluster.new(ecs_cluster_name, region)
+
+        say("Increasing service instance counts by #{batch_size}...")
+        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}")
+              with_padding do
+                service.increase_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
+            end
+          end
+        end
+        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
+
+      desc(
+          'contract REGION ASG_NAME ECS_CLUSTER_NAME',
+          '')
+      method_option(
+          :batch_size,
+          aliases: '-b',
+          type: :numeric,
+          default: 3,
+          desc: 'The number of service instances to remove at a time.')
+
+      def contract(
+          region, _, ecs_cluster_name,
+              service_cluster = nil)
+        batch_size = options[:batch_size]
+
+        service_cluster = service_cluster ||
+            Rollo::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}")
+              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
+            end
+          end
+        end
+        say("Service instance counts decreased, continuing...")
+      end
+    end
+  end
+end

data/lib/rollo/commands.rb

@@ -0,0 +1 @@
+require_relative 'commands/main'

data/lib/rollo/model/host.rb

@@ -0,0 +1,25 @@
+module Rollo
+  module Model
+    class Host
+      def initialize(instance)
+        @instance = instance
+      end
+
+      def id
+        @instance.id
+      end
+
+      def terminate
+        @instance.terminate(should_decrement_desired_capacity: false)
+      end
+
+      def is_in_service?
+        @instance.lifecycle_state == 'InService'
+      end
+
+      def is_healthy?
+        @instance.health_status == 'Healthy'
+      end
+    end
+  end
+end