moonshot 0.7.0

data/lib/moonshot/shell.rb

@@ -0,0 +1,52 @@
+# Mixin providing the Thor::Shell methods and other shell execution helpers.
+module Moonshot::Shell
+  # Run a command, returning stdout. Stderr is suppressed unless the command
+  # returns non-zero.
+  def sh_out(cmd, fail: true, stdin: '') # rubocop:disable AbcSize
+    r_in, w_in = IO.pipe
+    r_out, w_out = IO.pipe
+    r_err, w_err = IO.pipe
+    w_in.write(stdin)
+    w_in.close
+    pid = Process.spawn(cmd, in: r_in, out: w_out, err: w_err)
+    Process.wait(pid)
+
+    r_in.close
+    w_out.close
+    w_err.close
+    stdout = r_out.read
+    r_out.close
+    stderr = r_err.read
+    r_err.close
+
+    if fail && $CHILD_STATUS.exitstatus != 0
+      raise "`#{cmd}` exited #{$CHILD_STATUS.exitstatus}\n" \
+           "stdout:\n" \
+           "#{stdout}\n" \
+           "stderr:\n" \
+           "#{stderr}\n"
+    end
+    stdout
+  end
+  module_function :sh_out
+
+  def shell
+    @thor_shell ||= Thor::Base.shell.new
+  end
+
+  Thor::Shell::Basic.public_instance_methods(false).each do |meth|
+    define_method(meth) { |*args| shell.public_send(meth, *args) }
+  end
+
+  def sh_step(cmd, args = {})
+    msg = args.delete(:msg) || cmd
+    if msg.length > (terminal_width - 18)
+      msg = "#{msg[0..(terminal_width - 22)]}..."
+    end
+    ilog.start_threaded(msg) do |step|
+      out = sh_out(cmd, args)
+      yield step, out if block_given?
+      step.success
+    end
+  end
+end

data/lib/moonshot/stack.rb

@@ -0,0 +1,345 @@
+require_relative 'creds_helper'
+require_relative 'doctor_helper'
+
+require_relative 'stack_template'
+require_relative 'stack_parameter_printer'
+require_relative 'stack_output_printer'
+require_relative 'stack_asg_printer'
+require_relative 'unicode_table'
+require 'yaml'
+
+module Moonshot
+  # The Stack wraps all CloudFormation actions performed by Moonshot. It
+  # stores the state of the active stack running on AWS, but contains a
+  # reference to the StackTemplate that would be applied with an update
+  # action.
+  class Stack # rubocop:disable ClassLength
+    include CredsHelper
+    include DoctorHelper
+
+    attr_reader :app_name
+    attr_reader :name
+
+    # TODO: Refactor more of these parameters into the config object.
+    def initialize(name, app_name:, log:, ilog:, config: StackConfig.new)
+      @name = name
+      @app_name = app_name
+      @log = log
+      @ilog = ilog
+      @config = config
+      yield @config if block_given?
+    end
+
+    def create
+      import_parent_parameters
+
+      should_wait = true
+      @ilog.start "Creating #{stack_name}." do |s|
+        if stack_exists?
+          s.success "#{stack_name} already exists."
+          should_wait = false
+        else
+          create_stack
+          s.success "Created #{stack_name}."
+        end
+      end
+
+      should_wait ? wait_for_stack_state(:stack_create_complete, 'created') : true
+    end
+
+    def update
+      raise Thor::Error, "No stack found #{@name.blue}!" unless stack_exists?
+
+      should_wait = true
+      @ilog.start "Updating #{stack_name}." do |s|
+        if update_stack
+          s.success "Initiated update for #{stack_name}."
+        else
+          s.success 'No Stack update required.'
+          should_wait = false
+        end
+      end
+
+      should_wait ? wait_for_stack_state(:stack_update_complete, 'updated') : true
+    end
+
+    def delete
+      should_wait = true
+      @ilog.start "Deleting #{stack_name}." do |s|
+        if stack_exists?
+          cf_client.delete_stack(stack_name: @name)
+          s.success "Initiated deletion of #{stack_name}."
+        else
+          s.success "#{stack_name} does not exist."
+          should_wait = false
+        end
+      end
+
+      should_wait ? wait_for_stack_state(:stack_delete_complete, 'deleted') : true
+    end
+
+    def status
+      if exists?
+        puts "#{stack_name} exists."
+        t = UnicodeTable.new('')
+        StackParameterPrinter.new(self, t).print
+        StackOutputPrinter.new(self, t).print
+        StackASGPrinter.new(self, t).print
+        t.draw_children
+      else
+        puts "#{stack_name} does NOT exist."
+      end
+    end
+
+    def parameters
+      get_stack(@name)
+        .parameters
+        .map { |p| [p.parameter_key, p.parameter_value] }
+        .to_h
+    end
+
+    def outputs
+      get_stack(@name)
+        .outputs
+        .map { |o| [o.output_key, o.output_value] }
+        .to_h
+    end
+
+    def exists?
+      cf_client.describe_stacks(stack_name: @name)
+      true
+    rescue Aws::CloudFormation::Errors::ValidationError
+      false
+    end
+    alias stack_exists? exists?
+
+    def resource_summaries
+      cf_client.list_stack_resources(stack_name: @name).stack_resource_summaries
+    end
+
+    # @return [String, nil]
+    def physical_id_for(logical_id)
+      resource_summary = resource_summaries.find do |r|
+        r.logical_resource_id == logical_id
+      end
+      resource_summary.physical_resource_id if resource_summary
+    end
+
+    # @return [Array<Aws::CloudFormation::Types::StackResourceSummary>]
+    def resources_of_type(type)
+      resource_summaries.select do |r|
+        r.resource_type == type
+      end
+    end
+
+    # Build a hash of overrides that would be applied to this stack by an
+    # update.
+    def overrides
+      if File.exist?(parameters_file)
+        YAML.load_file(parameters_file)
+      else
+        {}
+      end
+    end
+
+    # Return a Hash of the default values defined in the stack template.
+    def default_values
+      h = {}
+      JSON.parse(template.body).fetch('Parameters', {}).map do |k, v|
+        h[k] = v['Default']
+      end
+      h
+    end
+
+    def template
+      @template ||= StackTemplate.new(template_file, log: @log)
+    end
+
+    # @return [String] the path to the template file.
+    def template_file
+      File.join(Dir.pwd, 'cloud_formation', "#{@app_name}.json")
+    end
+
+    # @return [String] the path to the parameters file.
+    def parameters_file
+      File.join(Dir.pwd, 'cloud_formation', 'parameters', "#{@name}.yml")
+    end
+
+    def add_parameter_overrides(hash)
+      new_overrides = hash.merge(overrides)
+      File.open(parameters_file, 'w') do |f|
+        YAML.dump(new_overrides, f)
+      end
+    end
+
+    private
+
+    def stack_name
+      "CloudFormation Stack #{@name.blue}"
+    end
+
+    def load_parameters_file
+      @ilog.msg "Loading stack parameters file '#{parameters_file}'."
+      result = stack_parameter_overrides
+
+      if result.empty?
+        @ilog.msg "No parameters file for #{@name.blue}, using defaults."
+        return result
+      end
+
+      @ilog.msg 'Setting stack parameter overrides:'
+      result.each do |e|
+        @ilog.msg "   #{e[:parameter_key]}: #{e[:parameter_value]}"
+      end
+    end
+
+    def stack_parameter_overrides
+      overrides.map do |k, v|
+        { parameter_key: k, parameter_value: v.to_s }
+      end
+    end
+
+    def stack_parameters
+      @stack_parameters ||= JSON.parse(template.body).fetch('Parameters', {}).keys
+    end
+
+    def import_parent_parameters
+      add_parameter_overrides(parent_stack_outputs)
+    end
+
+    # Return a Hash of parent stack outputs that match parameter names for this
+    # stack.
+    def parent_stack_outputs
+      result = {}
+
+      @config.parent_stacks.each do |stack_name|
+        resp = cf_client.describe_stacks(stack_name: stack_name)
+        raise "Parent Stack #{stack_name} not found!" unless resp.stacks.size == 1
+
+        # If there is an input parameters matching a stack output, pass it.
+        resp.stacks[0].outputs.each do |output|
+          if stack_parameters.include?(output.output_key)
+            result[output.output_key] = output.output_value
+          end
+        end
+      end
+
+      result
+    end
+
+    # @return [Aws::CloudFormation::Types::Stack]
+    def get_stack(name)
+      stacks = cf_client.describe_stacks(stack_name: name).stacks
+      raise Thor::Error, "Could not describe stack: #{name}" if stacks.empty?
+
+      stacks.first
+    rescue Aws::CloudFormation::Errors::ValidationError
+      raise Thor::Error, "Could not describe stack: #{name}"
+    end
+
+    def create_stack
+      cf_client.create_stack(
+        stack_name: @name,
+        template_body: template.body,
+        capabilities: ['CAPABILITY_IAM'],
+        parameters: load_parameters_file,
+        tags: [
+          { key: 'ah_stage', value: @name }
+        ]
+      )
+    rescue Aws::CloudFormation::Errors::AccessDenied
+      raise Thor::Error, 'You are not authorized to perform create_stack calls.'
+    end
+
+    # @return [Boolean]
+    #   true if a stack update was required and initiated, false otherwise.
+    def update_stack
+      cf_client.update_stack(
+        stack_name: @name,
+        template_body: template.body,
+        capabilities: ['CAPABILITY_IAM'],
+        parameters: stack_parameter_overrides
+      )
+      true
+    rescue Aws::CloudFormation::Errors::ValidationError => e
+      raise Thor::Error, e.message unless
+        e.message == 'No updates are to be performed.'
+      false
+    end
+
+    # TODO: Refactor this into it's own class.
+    def wait_for_stack_state(wait_target, past_tense_verb) # rubocop:disable AbcSize
+      result = true
+
+      stack_id = get_stack(@name).stack_id
+
+      events = StackEventsPoller.new(cf_client, stack_id)
+      events.show_only_errors unless @config.show_all_events
+
+      @ilog.start_threaded "Waiting for #{stack_name} to be successfully #{past_tense_verb}." do |s|
+        begin
+          cf_client.wait_until(wait_target, stack_name: stack_id) do |w|
+            w.delay = 10
+            w.max_attempts = 180 # 30 minutes.
+            w.before_wait do |attempt, resp|
+              begin
+                events.latest_events.each { |e| @ilog.error(format_event(e)) }
+                # rubocop:disable Lint/HandleExceptions
+              rescue Aws::CloudFormation::Errors::ValidationError
+                # Do nothing.  The above event logging block may result in
+                # a ValidationError while waiting for a stack to delete.
+              end
+              # rubocop:enable Lint/HandleExceptions
+
+              if attempt == w.max_attempts - 1
+                s.failure "#{stack_name} was not #{past_tense_verb} after 30 minutes."
+                result = false
+
+                # We don't want the interactive logger to catch an exception.
+                throw :success
+              end
+              s.continue "Waiting for CloudFormation Stack to be successfully #{past_tense_verb}, current status '#{resp.stacks.first.stack_status}'." # rubocop:disable LineLength
+            end
+          end
+
+          s.success "#{stack_name} successfully #{past_tense_verb}." if result
+        rescue Aws::Waiters::Errors::FailureStateError
+          result = false
+          s.failure "#{stack_name} failed to update."
+        end
+      end
+
+      result
+    end
+
+    def format_event(event)
+      str = case event.resource_status
+            when /FAILED/
+              event.resource_status.red
+            when /IN_PROGRESS/
+              event.resource_status.yellow
+            else
+              event.resource_status.green
+            end
+      str << " #{event.logical_resource_id}"
+      str << " #{event.resource_status_reason.light_black}" if event.resource_status_reason
+
+      str
+    end
+
+    def doctor_check_template_exists
+      if File.exist?(template_file)
+        success "CloudFormation template found at '#{template_file}'."
+      else
+        critical "CloudFormation template not found at '#{template_file}'!"
+      end
+    end
+
+    def doctor_check_template_against_aws
+      cf_client.validate_template(template_body: template.body)
+      success('CloudFormation template is valid.')
+    rescue => e
+      critical('Invalid CloudFormation template!', e.message)
+    end
+  end
+end

data/lib/moonshot/stack_asg_printer.rb

@@ -0,0 +1,151 @@
+# coding: utf-8
+require 'colorize'
+require 'ruby-duration'
+
+module Moonshot
+  # Display information about the AutoScaling Groups, associated ELBs, and
+  # managed instances to the user.
+  class StackASGPrinter # rubocop:disable ClassLength
+    include CredsHelper
+
+    def initialize(stack, table)
+      @stack = stack
+      @table = table
+    end
+
+    def print
+      asgs.each do |asg|
+        asg_info = as_client.describe_auto_scaling_groups(
+          auto_scaling_group_names: [asg.physical_resource_id])
+                            .auto_scaling_groups.first
+        t_asg_info = @table.add_leaf("ASG: #{asg.logical_resource_id}")
+
+        add_asg_info(t_asg_info, asg_info)
+        instances_leaf = t_asg_info.add_leaf('Instances')
+
+        if asg_info.instances.empty?
+          instances_leaf.add_line('There are no instances in this Auto-Scaling Group.')
+        else
+          instances_leaf.add_table(create_instance_table(asg_info))
+        end
+
+        add_recent_activity_leaf(t_asg_info, asg.physical_resource_id)
+      end
+    end
+
+    private
+
+    def asgs
+      @stack.resources_of_type('AWS::AutoScaling::AutoScalingGroup')
+    end
+
+    def status_with_color(status)
+      case status
+      when 'Successful'
+        status.green
+      when 'Failed'
+        status.red
+      else
+        status.yellow
+      end
+    end
+
+    def lifecycle_color(lifecycle)
+      case lifecycle
+      when 'InService'
+        lifecycle.green
+      else
+        lifecycle.red
+      end
+    end
+
+    def health_color(health)
+      case health
+      when 'Healthy'
+        health.green
+      else
+        health.red
+      end
+    end
+
+    # Get additional information about instances not returned by the ASG API.
+    def get_addl_info(instance_ids)
+      resp = ec2_client.describe_instances(instance_ids: instance_ids)
+
+      data = {}
+      resp.reservations.map(&:instances).flatten.each do |instance|
+        data[instance.instance_id] = instance
+      end
+      data
+    end
+
+    def add_asg_info(table, asg_info) # rubocop:disable AbcSize
+      name = asg_info.auto_scaling_group_name.blue
+      table.add_line "Name: #{name}"
+
+      hc = asg_info.health_check_type.blue
+      gp = (asg_info.health_check_grace_period.to_s << 's').blue
+      table.add_line "Using #{hc} health checks, with a #{gp} health check grace period." # rubocop:disable LineLength
+
+      dc = asg_info.desired_capacity.to_s.blue
+      min = asg_info.min_size.to_s.blue
+      max = asg_info.max_size.to_s.blue
+      table.add_line "Desired Capacity is #{dc} (Min: #{min}, Max: #{max})."
+
+      lbs = asg_info.load_balancer_names
+      table.add_line "Has #{lbs.count.to_s.blue} Load Balancer(s): #{lbs.map(&:blue).join(', ')}" # rubocop:disable LineLength
+    end
+
+    def create_instance_table(asg_info)
+      current_lc = asg_info.launch_configuration_name
+      ec2_info = get_addl_info(asg_info.instances.map(&:instance_id))
+      asg_info.instances.map do |asg_instance|
+        row = instance_row(asg_instance,
+                           ec2_info[asg_instance.instance_id])
+        row << if current_lc == asg_instance.launch_configuration_name
+                 '(launch config up to date)'.green
+               else
+                 '(launch config out of date)'.red
+               end
+      end
+    end
+
+    def instance_row(asg_instance, ec2_instance)
+      [
+        asg_instance.instance_id,
+        # @todo What about ASGs with only private IPs?
+        ec2_instance.public_ip_address,
+        lifecycle_color(asg_instance.lifecycle_state),
+        health_color(asg_instance.health_status),
+        uptime_format(ec2_instance.launch_time)
+      ]
+    end
+
+    def uptime_format(launch_time)
+      # %td is "total days", instead of counting up again to weeks.
+      Duration.new(Time.now.to_i - launch_time.to_i)
+              .format('%tdd %hh %mm %ss')
+    end
+
+    def add_recent_activity_leaf(table, asg_name)
+      recent = table.add_leaf('Recent Activity')
+      resp = as_client.describe_scaling_activities(
+        auto_scaling_group_name: asg_name).activities
+
+      rows = resp.sort_by(&:start_time).reverse.first(10).map do |activity|
+        row_for_activity(activity)
+      end
+
+      recent.add_table(rows)
+    end
+
+    def row_for_activity(activity)
+      [
+        activity.start_time.to_s.light_black,
+        activity.description,
+        status_with_color(activity.status_code),
+        activity.progress.to_s << '%'
+      ]
+    end
+  end
+end

data/lib/moonshot/stack_config.rb

@@ -0,0 +1,12 @@
+module Moonshot
+  # Configuration for the Moonshot::Stack class.
+  class StackConfig
+    attr_accessor :parent_stacks
+    attr_accessor :show_all_events
+
+    def initialize
+      @parent_stacks = []
+      @show_all_events = false
+    end
+  end
+end

data/lib/moonshot/stack_events_poller.rb

@@ -0,0 +1,56 @@
+module Moonshot
+  # The StackEventsPoller queries DescribeStackEvents every time #latest_events
+  # is invoked, filtering out events that have already been returned. It can
+  # also, optionally, filter all non-error events (@see #show_errors_only).
+  class StackEventsPoller
+    def initialize(cf_client, stack_name)
+      @cf_client = cf_client
+      @stack_name = stack_name
+
+      # Start showing events from now.
+      @last_time = Time.now
+    end
+
+    def show_only_errors
+      @errors_only = true
+    end
+
+    # Build a list of events that have occurred since the last call to this
+    # method.
+    #
+    # @return [Array<Aws::CloudFormation::Event>]
+    def latest_events
+      events = get_stack_events.select do |event|
+        event.timestamp > @last_time
+      end
+
+      @last_time = Time.now
+
+      filter_events(events.sort_by(&:timestamp))
+    end
+
+    def filter_events(events)
+      if @errors_only
+        events.select do |event|
+          %w(CREATE_FAILED UPDATE_FAILED DELETE_FAILED).include?(event.resource_status)
+        end
+      else
+        events
+      end
+    end
+
+    def get_stack_events(token = nil)
+      opts = {
+        stack_name: @stack_name
+      }
+
+      opts[:next_token] = token if token
+
+      result = @cf_client.describe_stack_events(**opts)
+      events = result.stack_events
+      events += get_stack_events(result.next_token) if result.next_token
+
+      events
+    end
+  end
+end

data/lib/moonshot/stack_lister.rb

@@ -0,0 +1,20 @@
+module Moonshot
+  # The StackLister is world renoun for it's ability to list stacks.
+  class StackLister
+    include CredsHelper
+
+    def initialize(app_name, log:)
+      @app_name = app_name
+      @log = log
+    end
+
+    def list
+      all_stacks = cf_client.describe_stacks.stacks
+      app_stacks = all_stacks.reject { |s| s.stack_name !~ /^#{@app_name}/ }
+
+      app_stacks.each do |stack|
+        puts stack.stack_name
+      end
+    end
+  end
+end

data/lib/moonshot/stack_output_printer.rb

@@ -0,0 +1,16 @@
+module Moonshot
+  # Display the stack outputs to the user.
+  class StackOutputPrinter
+    def initialize(stack, table)
+      @stack = stack
+      @table = table
+    end
+
+    def print
+      o_table = @table.add_leaf('Stack Outputs')
+      @stack.outputs.each do |k, v|
+        o_table.add_line("#{k}: #{v}")
+      end
+    end
+  end
+end