olery-aws 1.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4592a112c2bfde7e1fc50a21e6f06e6d5308de8ccb1c6c6291494df50184e732
+  data.tar.gz: b6e2b32c49a1859ae05298850f081e55173b39ddb4605f122a63c03dc07ec4a2
+SHA512:
+  metadata.gz: 44679fc3c631095891f66d11369119512136e06d8d6df86616d5b68e7256cc89106bb53c28781394c0c89c569ff91cc62084d1d6922ac0db55d14e30f4eca8b3
+  data.tar.gz: 7c6d2d6ddd2faf261fc64879759bd5cdf1cbbd1a95dbec7aba3834e4160dfa71b001ddeacc0dd977393bb294872a1a9b60bdaa5a05d32b95313b543bddc31cdd

data/README.md

@@ -0,0 +1,24 @@
+# Olery AWS
+
+Command-line tools for interacting with the Olery services running on AWS. This
+includes tools for rotating instances, listing running instances, retrieving
+information about autoscaling groups, etc.
+
+## Requirements
+
+* Ruby 2.0 or newer
+* AWS credentials (e.g. in `~/.bashrc`)
+
+## Installation
+
+Install all the required Gems:
+
+    bundle install
+
+Install the application as a Gem (so you can use it everywhere):
+
+    rake install
+
+Now you can use it, for example:
+
+    olery-aws rotate kaf_processor-olery-com

data/bin/olery-aws

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/olery/aws'
+
+command = ARGV[0]
+
+if command and Olery::AWS::Command.exists?(command)
+  cmd_class = Olery::AWS::Command.get(command)
+  cmd_opts  = cmd_class.parse(ARGV[1..-1])
+
+  if cmd_class.instance_method(:initialize).arity != 0
+    instance = cmd_class.new(cmd_opts.to_hash)
+  else
+    instance = cmd_class.new
+  end
+
+  if instance.method(:run).arity != 0
+    instance.run(*cmd_opts.arguments)
+  else
+    instance.run
+  end
+else
+  opts = Slop.parse do |opt|
+    opt.banner = 'Usage: olery-aws [COMMAND] [OPTIONS]'
+
+    opt.separator <<-EOF
+
+Examples:
+  olery-aws instances --running --grep reputation
+  olery-aws rotate scrapers-high-as-group-1
+
+Commands:
+  #{Olery::AWS::Command.command_descriptions.join("\n  ")}
+    EOF
+
+    opt.separator 'Options:'
+
+    opt.on '-h', '--help', 'Shows this help message' do
+      puts opt
+      exit
+    end
+
+    opt.on '--version', 'Shows version information' do
+      puts "olery-aws v#{Olery::AWS::VERSION} on #{RUBY_DESCRIPTION}"
+      exit
+    end
+  end
+
+  puts opts
+end
+
+# vim: set ft=ruby:

data/lib/olery/aws/command/autoscaling_groups.rb

@@ -0,0 +1,69 @@
+module Olery
+  module AWS
+    module Command
+      ##
+      # Command for listing autoscaling groups and their details.
+      #
+      class AutoscalingGroups
+        NAME        = 'as-groups'
+        DESCRIPTION = 'Lists autoscaling groups and their details'
+
+        ##
+        # @param [Array] argv
+        # @return [Slop]
+        #
+        def self.parse(argv)
+          Slop.parse(argv) do |opt|
+            opt.banner = "Usage: olery-aws #{NAME} [OPTIONS]"
+
+            opt.separator <<-EOF
+
+Examples:
+  olery-aws #{NAME}
+  olery-aws #{NAME} --pattern scraper
+            EOF
+
+            opt.separator 'Options:'
+
+            opt.regexp '-p', '--pattern', 'Matches group names using a Regexp'
+
+            opt.on '-h', '--help', 'Shows this help message' do
+              puts opt
+              exit
+            end
+          end
+        end
+
+        ##
+        # @param [Regexp] pattern When given only autoscaling groups who's names
+        #  match this pattern will be included.
+        #
+        def initialize(pattern: nil)
+          @pattern = pattern
+        end
+
+        def run
+          auto_scaling_groups.each do |group|
+            next if @pattern && group.auto_scaling_group_name !~ @pattern
+
+            puts group.auto_scaling_group_name
+          end
+        end
+
+        private
+
+        # @return [Array]
+        def auto_scaling_groups
+          response = auto_scaling.describe_auto_scaling_groups
+
+          response.auto_scaling_groups
+        end
+
+        # @return [Aws::AutoScaling::Client]
+        def auto_scaling
+          @auto_scaling ||= Aws::AutoScaling::Client.new
+        end
+      end # AutoscalingGroups
+    end # Command
+  end # AWS
+end # Olery

data/lib/olery/aws/command/instances.rb

@@ -0,0 +1,108 @@
+module Olery
+  module AWS
+    module Command
+      ##
+      # Command for listing EC2 instances and basic details.
+      #
+      class Instances
+        NAME        = 'instances'
+        DESCRIPTION = 'Lists EC2 instances'
+
+        ##
+        # @param [Array] argv
+        # @return [Slop]
+        #
+        def self.parse(argv)
+          Slop.parse(argv) do |opt|
+            opt.banner = "Usage: olery-aws #{NAME} [OPTIONS]"
+
+            opt.separator <<-EOF
+
+Examples:
+  olery-aws #{NAME}
+  olery-aws #{NAME} --running
+  olery-aws #{NAME} --running --name api
+            EOF
+
+            opt.separator 'Options:'
+
+            opt.bool '-r', '--running', 'List running instances only'
+
+            opt.regexp '-p', '--pattern', 'List instances with a matching name'
+
+            opt.on '-h', '--help', 'Shows this help message' do
+              puts opt
+              exit
+            end
+          end
+        end
+
+        ##
+        # @param [Regexp] pattern
+        # @param [TrueClass|FalseClass] running
+        #
+        def initialize(pattern: nil, running: false)
+          @pattern = pattern
+          @running = running
+        end
+
+        def run
+          if filters.empty?
+            instances = ec2.instances
+          else
+            instances = ec2.instances(:filters => filters)
+          end
+
+          table = Table.new
+
+          instances.each do |instance|
+            name = instance_name(instance)
+
+            if (@pattern and name and name =~ @pattern) or !@pattern
+              table << [
+                instance.instance_id,
+                instance.state.name,
+                instance.public_dns_name,
+                name.to_s
+              ]
+            end
+          end
+
+          table.sort_column!(3)
+
+          puts table.to_s
+        end
+
+        # @return [Array]
+        def filters
+          filters = []
+
+          if @running
+            filters << {:name => 'instance-state-name', :values => %w{running}}
+          end
+
+          filters
+        end
+
+        ##
+        # Returns the name of an EC2 instance.
+        #
+        # @param [Aws::EC2::Instance] instance
+        # @return [String|NilClass]
+        #
+        def instance_name(instance)
+          tag = instance.tags.find { |tag| tag.key == 'Name' }
+
+          tag ? tag.value : nil
+        end
+
+        private
+
+        # @return [Aws::EC2::Client]
+        def ec2
+          @ec2 ||= Aws::EC2::Resource.new
+        end
+      end # Instances
+    end # Command
+  end # AWS
+end # Olery

data/lib/olery/aws/command/rotate.rb

@@ -0,0 +1,563 @@
+module Olery
+  module AWS
+    module Command
+      ##
+      # Command for rotating EC2 instances in an autoscaling group.
+      #
+      # Two different rotation strategies can be used:
+      #
+      # 1. Rotating via an ELB (if present)
+      # 2. Simply scaling down and back up again
+      #
+      # If an ELB is present the autoscaling group capacity is doubled and the
+      # old instances terminated. This ensures that the autoscaling group
+      # remains operational during a deploy.
+      #
+      # The 2nd strategy is used when no ELB is present, this is usually only
+      # the case for autoscaling groups used for background processing. In these
+      # cases downtime doesn't really matter since users won't notice it.
+      #
+      # ## Synchronization
+      #
+      # To ensure deployments operate smoothly only 1 entity can deploy to the
+      # same autoscaling group at a given time. Synchronization is done by
+      # emulating a semaphore using autoscaling group tags. This setup should
+      # prevent parallel deploys in 99,99% of the cases (fingers crossed).
+      #
+      class Rotate
+        NAME        = 'rotate'
+        DESCRIPTION = 'Rotates EC2 instances in an autoscaling group'
+
+        # The name of the tag used for locking deployments
+        LOCK_TAG = 'olery-deployment-lock'
+
+        ##
+        # @param [Array] argv
+        # @return [Slop]
+        #
+        def self.parse(argv)
+          Slop.parse(argv) do |opt|
+            opt.banner = "Usage: olery-aws #{NAME} [OPTIONS]"
+
+            opt.separator <<-EOF
+
+Examples:
+  olery-aws #{NAME} scrapers-high-as-group-1
+            EOF
+
+            opt.separator 'Options:'
+
+            opt.on '-h', '--help', 'Shows this help message' do
+              puts opt
+              exit
+            end
+          end
+        end
+
+        def initialize
+          @logger = Logger.new(STDERR)
+
+          @logger.formatter = proc do |level, time, prog, msg|
+            "#{time.strftime('%H:%M:%S')} #{level}: #{msg}\n"
+          end
+        end
+
+        ##
+        # @param [String] group_name The name of the autoscaling group.
+        #
+        def run(group_name)
+          info 'Acquiring deployment lock'
+
+          synchronize_group(group_name) do
+            info 'Lock acquired'
+
+            group = get_group(group_name)
+
+            if group.instances.length > 0
+              if has_elbs?(group)
+                rotate_elb(group)
+              else
+                rotate(group)
+              end
+            else
+              info 'No running instances in autoscaling group'
+            end
+          end
+        end
+
+        ##
+        # Rotates all instances attached to an autoscaling group with a number
+        # of ELBs.
+        #
+        # The process for this is as following:
+        #
+        # 1. Double the capacity of the autoscaling group.
+        # 2. Wait for all instances to be registered with all ELBs.
+        # 3. Wait for all instances to be in service.
+        # 4. Detach the old instances and wait for them to be de-registered from
+        #    the autoscaling group.
+        # 5. Terminate the old instances and wait for them to be terminated.
+        # 6. Reset the autoscaling group's settings to their original values.
+        #
+        # @param [Struct] group
+        #
+        def rotate_elb(group)
+          info 'Disabling terminating of instances'
+
+          suspend_processes(group.auto_scaling_group_name, 'Terminate')
+
+          new_size    = group.max_size * 2
+          new_desired = group.desired_capacity * 2
+
+          info "Doubling autoscaling capacity to #{new_size}"
+
+          update_group(
+            group.auto_scaling_group_name,
+            max_size:         new_size,
+            desired_capacity: new_desired,
+          )
+
+          info 'Waiting for ELBs to register instances'
+
+          wait_for_elbs group.load_balancer_names, new_desired
+
+          info 'Waiting for all instances to be in service'
+
+          group.load_balancer_names.each do |elb_name|
+            wait_until_in_service(elb_name)
+          end
+
+          instance_ids = group.instances.map(&:instance_id)
+
+          info 'Disabling launching of new instances'
+
+          suspend_processes(group.auto_scaling_group_name, 'Launch')
+
+          info 'Detaching old instances'
+
+          detach_instances(group.auto_scaling_group_name, instance_ids)
+
+          info 'Waiting for instances to be removed from autoscaling group'
+
+          wait_until_removed_from_group(
+            group.auto_scaling_group_name,
+            instance_ids
+          )
+
+          info 'Terminating old instances'
+
+          terminate_instances(instance_ids)
+
+          wait_until_terminated(instance_ids)
+
+        # In the event of any errors/timeouts/etc we want to be absolutely sure
+        # the autoscaling group is back in its initial state.
+        ensure
+          info 'Restoring autoscaling group'
+
+          update_group(
+            group.auto_scaling_group_name,
+            :max_size => group.max_size
+          )
+
+          info 'Re-enabling all autoscaling processes'
+
+          resume_processes(group.auto_scaling_group_name)
+        end
+
+        ##
+        # Terminates all instances in an autoscaling group and adds the same
+        # amount of new instances.
+        #
+        # The process for this is as following:
+        #
+        # 1. Scale down to 0 instances and wait for all instances to be
+        #    terminated.
+        # 2. Scale back up to the original capacity and wait for all instances
+        #    to be in service.
+        # 3. Reset the autoscaling group's settings to their original values.
+        #
+        # @param [Struct] group
+        #
+        def rotate(group)
+          info 'Disabling launching of new instances'
+
+          suspend_processes(group.auto_scaling_group_name, 'Launch')
+
+          info 'Setting minimum amount of instances to 0'
+
+          instance_ids = group.instances.map(&:instance_id)
+
+          info 'Scaling down to 0 instances'
+
+          update_group(
+            group.auto_scaling_group_name,
+            :min_size         => 0,
+            :desired_capacity => 0
+          )
+
+          wait_until_terminated(instance_ids)
+
+          info 'Waiting for instances to be removed from autoscaling group'
+
+          wait_until_removed_from_group(
+            group.auto_scaling_group_name,
+            instance_ids
+          )
+
+          resume_processes(group.auto_scaling_group_name)
+
+          info 'Disabling terminating of instances'
+
+          suspend_processes(group.auto_scaling_group_name, 'Terminate')
+
+          info 'Scaling back to original capacity'
+
+          update_group(
+            group.auto_scaling_group_name,
+            :desired_capacity => group.desired_capacity
+          )
+
+          # Spot instances may take a long time to start up due to pricing. As
+          # such, in case an autoscaling group runs spot instances we _won't_
+          # wait for the instances to start up.
+          unless spot_instances?(group.auto_scaling_group_name)
+            wait_until_group_capacity(
+              group.auto_scaling_group_name,
+              group.desired_capacity
+            )
+
+            info 'Waiting for instances to start'
+
+            new_group        = get_group(group.auto_scaling_group_name)
+            new_instance_ids = new_group.instances.map(&:instance_id)
+
+            wait_until_running(new_instance_ids) unless new_instance_ids.empty?
+          end
+
+        # In the event of any errors/timeouts/etc we want to be absolutely sure
+        # the autoscaling group is back in its initial state.
+        ensure
+          info 'Restoring autoscaling group'
+
+          update_group(
+            group.auto_scaling_group_name,
+            :min_size => group.min_size
+          )
+
+          info 'Re-enabling all autoscaling processes'
+
+          resume_processes(group.auto_scaling_group_name)
+        end
+
+        ##
+        # @param [String] group_name
+        # @param [Array] processes
+        #
+        def suspend_processes(group_name, *processes)
+          auto_scaling.suspend_processes(
+            :auto_scaling_group_name => group_name,
+            :scaling_processes       => processes
+          )
+        end
+
+        ##
+        # @param [String] group_name
+        #
+        def resume_processes(group_name)
+          auto_scaling.resume_processes(:auto_scaling_group_name => group_name)
+        end
+
+        ##
+        # @param [String] group_name
+        # @return [Mixed]
+        #
+        def get_group(group_name)
+          group = auto_scaling.describe_auto_scaling_groups(
+            :auto_scaling_group_names => [group_name]
+          )
+
+          group.auto_scaling_groups[0]
+        end
+
+        ##
+        # @param [Struct] group
+        # @return [TrueClass|FalseClass]
+        #
+        def has_elbs?(group)
+          group.load_balancer_names.length > 0
+        end
+
+        ##
+        # @param [String] name
+        # @param [Hash] options
+        #
+        def update_group(name, options)
+          auto_scaling.update_auto_scaling_group(
+            options.merge(:auto_scaling_group_name => name)
+          )
+        end
+
+        ##
+        # @param [Array] elb_names
+        # @param [Struct] group
+        #
+        def wait_for_elbs(elb_names, instances)
+          loop_with_limit do
+            response = load_balancing.describe_load_balancers(
+              :load_balancer_names => elb_names
+            )
+
+            ok_elbs = response.load_balancer_descriptions.count do |elb|
+              elb.instances.length == instances
+            end
+
+            break if ok_elbs == elb_names.length
+
+            sleep(5)
+          end
+        end
+
+        ##
+        # @param [String] elb_name
+        #
+        def wait_until_in_service(elb_name)
+          load_balancing.wait_until(
+            :instance_in_service,
+            :load_balancer_name => elb_name
+          ) do |waiter|
+            waiter.delay = 30
+          end
+        end
+
+        ##
+        # @param [String] group_name
+        # @param [Fixnum] capacity
+        #
+        def wait_until_group_capacity(group_name, capacity)
+          loop_with_limit do
+            group   = get_group(group_name)
+            current = group.instances.length
+
+            break if current == capacity
+
+            sleep(5)
+          end
+        end
+
+        ##
+        # @param [Array] ids
+        #
+        def terminate_instances(ids)
+          ec2.terminate_instances(:instance_ids => ids)
+        end
+
+        ##
+        # @param [String] group_name
+        # @param [Array] ids
+        #
+        def detach_instances(group_name, ids)
+          auto_scaling.detach_instances(
+            :auto_scaling_group_name           => group_name,
+            :instance_ids                      => ids,
+            :should_decrement_desired_capacity => true
+          )
+        end
+
+        ##
+        # Waits until the given instances are terminated.
+        #
+        # @param [Array] ids
+        #
+        def wait_until_terminated(ids)
+          ec2.wait_until(:instance_terminated, :instance_ids => ids) do |waiter|
+            waiter.delay        = 30
+            waiter.max_attempts = 60
+          end
+        end
+
+        ##
+        # Waits until the given instances are running.
+        #
+        # @param [Array] ids
+        #
+        def wait_until_running(ids)
+          ec2.wait_until(:instance_running, :instance_ids => ids) do |waiter|
+            waiter.delay        = 30
+            waiter.max_attempts = 60
+          end
+        end
+
+        ##
+        # Waits until the given instances are removed from the autoscaling
+        # group.
+        #
+        # @param [String] group_name
+        # @param [Array] instance_ids
+        #
+        def wait_until_removed_from_group(group_name, instance_ids)
+          loop_with_limit do
+            group   = get_group(group_name)
+            current = group.instances.map(&:instance_id)
+
+            break if (current & instance_ids).empty?
+
+            sleep(5)
+          end
+        end
+
+        ##
+        # Yields the given block at most `max` times.
+        #
+        def loop_with_limit(max = 60)
+          max.times { yield }
+        end
+
+        ##
+        # Locks an autoscaling group to prevent concurrent deploys from messing
+        # up the capacity. Once locked the block is yielded, once the block
+        # returns the lock is released.
+        #
+        # @param [String] group_name
+        #
+        def synchronize_group(group_name)
+          loop do
+            # Somebody else has the lock
+            sleep(5) while group_locked_by(group_name)
+
+            # Make sure we only acquire the lock if nobody else did so in the
+            # mean time.
+            unless group_locked_by(group_name)
+              add_group_tag(group_name, LOCK_TAG, uuid)
+            end
+
+            held_by = group_locked_by(group_name)
+
+            # Did we _actually_ acquire the lock, or did somebody else overwrite
+            # ours?
+            if held_by == uuid
+              yield
+              break
+            end
+          end
+
+        # Lets try to not leave behind a locked group that needs manual
+        # unlocking.
+        ensure
+          unlock_group(group_name)
+        end
+
+        ##
+        # Unlocks an autoscaling group.
+        #
+        # @param [String] group_name
+        #
+        def unlock_group(group_name)
+          if group_locked_by(group_name) == uuid
+            remove_group_tag(group_name, LOCK_TAG)
+          end
+        end
+
+        ##
+        # @param [String] group_name
+        # @return [String|NilClass]
+        #
+        def group_locked_by(group_name)
+          tag = get_group(group_name).tags.find { |tag| tag.key == LOCK_TAG }
+
+          tag ? tag.value : nil
+        end
+
+        ##
+        # @param [String] group_name
+        # @param [String] tag_name
+        # @param [String] tag_value
+        #
+        def add_group_tag(group_name, tag_name, tag_value)
+          auto_scaling.create_or_update_tags(
+            :tags => [
+              {
+                :resource_id         => group_name,
+                :resource_type       => 'auto-scaling-group',
+                :key                 => tag_name,
+                :value               => tag_value,
+                :propagate_at_launch => false
+              }
+            ]
+          )
+        end
+
+        ##
+        # @param [String] group_name
+        # @param [String] tag_name
+        #
+        def remove_group_tag(group_name, tag_name)
+          auto_scaling.delete_tags(
+            :tags => [
+              {
+                :resource_id   => group_name,
+                :resource_type => 'auto-scaling-group',
+                :key           => tag_name
+              }
+            ]
+          )
+        end
+
+        ##
+        # Checks if an autoscaling group has any spot instances.
+        #
+        # @param [String] group_name
+        # @return [TrueClass|FalseClass]
+        #
+        def spot_instances?(group_name)
+          group  = get_group(group_name)
+          group_launch_spot? group
+        end
+
+        ##
+        # @param [String] group
+        # @return [Boolean]
+        #
+        def group_launch_spot? group
+          if config_name = group.launch_configuration_name
+            response = auto_scaling.describe_launch_configurations launch_configuration_names: [config_name]
+            !!response.launch_configurations[0].spot_price
+          else
+            versions = ec2.describe_launch_template_versions launch_template_id: group.launch_template.launch_template_id
+            final    = versions.launch_template_versions.first
+            final.launch_template_data.instance_market_options.market_type == 'spot'
+          end
+        end
+
+        private
+
+        ##
+        # @param [String] message
+        #
+        def info(message)
+          @logger.info(message)
+        end
+
+        # @return [Aws::AutoScaling::Client]
+        def auto_scaling
+          @auto_scaling ||= Aws::AutoScaling::Client.new
+        end
+
+        # @return [Aws::ElasticLoadBalancing::Client]
+        def load_balancing
+          @load_balancing ||= Aws::ElasticLoadBalancing::Client.new
+        end
+
+        # @return [Aws::EC2::Client]
+        def ec2
+          @ec2 ||= Aws::EC2::Client.new
+        end
+
+        # @return [String]
+        def uuid
+          @uuid ||= UUID.generate
+        end
+      end # Rotate
+    end # Command
+  end # AWS
+end # Olery

data/lib/olery/aws/command.rb

@@ -0,0 +1,49 @@
+module Olery
+  module AWS
+    module Command
+      ##
+      # Returns all the available command classes.
+      #
+      # @return [Array<Class>]
+      #
+      def self.commands
+        Command.constants.map { |name| Command.const_get(name) }
+      end
+
+      ##
+      # Returns an Array with command names and their descriptions. The command
+      # names contain padding so they can be aligned.
+      #
+      # @return [Array]
+      #
+      def self.command_descriptions
+        lines  = commands.map { |const| [const::NAME, const::DESCRIPTION] }
+        names  = Formatting.pad_strings(lines.map { |line| line[0] })
+
+        names.sort.map.with_index do |name, index|
+          "#{name}  #{lines[index][1]}"
+        end
+      end
+
+      ##
+      # Returns `true` if the given command exists.
+      #
+      # @param [String] name
+      # @return [TrueClass|FalseClass]
+      #
+      def self.exists?(name)
+        commands.map { |const| const::NAME }.include?(name)
+      end
+
+      ##
+      # Returns the command for the given name.
+      #
+      # @param [String] name
+      # @return [Class]
+      #
+      def self.get(name)
+        commands.find { |const| const::NAME == name }
+      end
+    end # Command
+  end # AWS
+end # Olery

data/lib/olery/aws/formatting.rb

@@ -0,0 +1,26 @@
+module Olery
+  module AWS
+    ##
+    # Helper module for formatting output, aligning text, etc.
+    #
+    module Formatting
+      module_function
+
+      ##
+      # Returns an Array with all strings padded with whitespace.
+      #
+      # @example
+      #  pad_strings(%w{foo foobar}) # => ["foo   ", "foobar"]
+      #
+      # @param [Array] values
+      # @return [Array]
+      #
+      def pad_strings(values)
+        longest = values.sort { |left, right| right.length <=> left.length }
+        padding = longest[0] ? longest[0].length : 0
+
+        values.map { |value| value.ljust(padding, ' ') }
+      end
+    end # Formatting
+  end # AWS
+end # Olery

data/lib/olery/aws/table.rb

@@ -0,0 +1,88 @@
+module Olery
+  module AWS
+    ##
+    # Class for generating an ASCII table with the columns aligned. The output
+    # format is grep/awk/etc friendly.
+    #
+    class Table
+      # @return [Array]
+      attr_reader :rows
+
+      def initialize
+        @rows = []
+
+        @column_count = 0
+      end
+
+      ##
+      # Adds a new row to the table.
+      #
+      # @param [Array] row
+      #
+      def push(row)
+        @rows << row
+
+        if row.length > @column_count
+          @column_count = row.length
+        end
+      end
+
+      alias_method :<<, :push
+
+      ##
+      # Sorts the table rows.
+      #
+      # @yieldparam [Array]
+      #
+      def sort!(&block)
+        @rows.sort_by!(&block)
+      end
+
+      ##
+      # Sorts all rows by the given column index.
+      #
+      # @param [Fixnum] column
+      #
+      def sort_column!(column)
+        sort! { |row| row[column] }
+      end
+
+      # @return [String]
+      def to_s
+        lengths = column_lengths
+        lines   = []
+
+        @rows.each do |row|
+          line = row.map.with_index do |column, index|
+            column.ljust(lengths[index], ' ')
+          end
+
+          lines << line.join(' ')
+        end
+
+        lines.join("\n")
+      end
+
+      private
+
+      ##
+      # Returns an array containing the longest length for every column.
+      #
+      # @return [Array]
+      #
+      def column_lengths
+        lengths = Array.new(@column_count, 0)
+
+        @rows.each do |row|
+          row.each_with_index do |column, index|
+            length = column.length
+
+            lengths[index] = length if length > lengths[index]
+          end
+        end
+
+        lengths
+      end
+    end # Table
+  end # AWS
+end # Olery

data/lib/olery/aws/version.rb

@@ -0,0 +1,7 @@
+module Olery
+  module AWS
+
+    VERSION = '1.2.1'
+
+  end
+end

data/lib/olery/aws.rb

@@ -0,0 +1,13 @@
+require 'aws-sdk'
+require 'slop'
+require 'uuid'
+
+require 'logger'
+
+require_relative 'aws/version'
+require_relative 'aws/command'
+require_relative 'aws/formatting'
+require_relative 'aws/table'
+require_relative 'aws/command/autoscaling_groups'
+require_relative 'aws/command/instances'
+require_relative 'aws/command/rotate'

data/olery-aws.gemspec

@@ -0,0 +1,30 @@
+require File.expand_path('../lib/olery/aws/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = 'olery-aws'
+  gem.version     = Olery::AWS::VERSION
+  gem.authors     = ['Olery B.V.']
+  gem.email       = 'development@olery.com'
+  gem.summary     = 'Command-line tools for interacting with the Olery services running on AWS.'
+  gem.homepage    = 'https://github.com/olery/olery-aws/'
+  gem.description = gem.summary
+  gem.executables = %w{olery-aws}
+
+  gem.files = Dir.glob([
+    'bin/**/*',
+    'lib/**/*.rb',
+    'README.md',
+    '*.gemspec'
+  ]).select { |file| File.file?(file) }
+
+  gem.required_ruby_version = '>= 2.0'
+
+  gem.add_dependency 'aws-sdk', '~> 2.0'
+  gem.add_dependency 'slop', '~> 4.0'
+  gem.add_dependency 'uuid'
+
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'bundler'
+  gem.add_development_dependency 'rspec', '~> 3.0'
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: olery-aws
+version: !ruby/object:Gem::Version
+  version: 1.2.1
+platform: ruby
+authors:
+- Olery B.V.
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-12-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: uuid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Command-line tools for interacting with the Olery services running on
+  AWS.
+email: development@olery.com
+executables:
+- olery-aws
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/olery-aws
+- lib/olery/aws.rb
+- lib/olery/aws/command.rb
+- lib/olery/aws/command/autoscaling_groups.rb
+- lib/olery/aws/command/instances.rb
+- lib/olery/aws/command/rotate.rb
+- lib/olery/aws/formatting.rb
+- lib/olery/aws/table.rb
+- lib/olery/aws/version.rb
+- olery-aws.gemspec
+homepage: https://github.com/olery/olery-aws/
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.9
+signing_key:
+specification_version: 4
+summary: Command-line tools for interacting with the Olery services running on AWS.
+test_files: []