moonshot 0.7.0

data/lib/moonshot/controller.rb

@@ -0,0 +1,151 @@
+module Moonshot
+  # The Controller coordinates and performs all Moonshot actions.
+  class Controller # rubocop:disable ClassLength
+    def initialize
+      @config = ControllerConfig.new
+      yield @config if block_given?
+    end
+
+    def list
+      Moonshot::StackLister.new(
+        @config.app_name, log: @config.logger).list
+    end
+
+    def create
+      run_plugins(:pre_create)
+      run_hook(:deploy, :pre_create)
+      stack_ok = stack.create
+      if stack_ok # rubocop:disable GuardClause
+        run_hook(:deploy, :post_create)
+        run_plugins(:post_create)
+      end
+    end
+
+    def update
+      run_plugins(:pre_update)
+      run_hook(:deploy, :pre_update)
+      stack.update
+      run_hook(:deploy, :post_update)
+      run_plugins(:post_update)
+    end
+
+    def status
+      run_plugins(:status)
+      run_hook(:deploy, :status)
+      stack.status
+    end
+
+    def deploy_code
+      version = "#{stack_name}-#{Time.now.to_i}"
+      build_version(version)
+      deploy_version(version)
+    end
+
+    def build_version(version_name)
+      run_plugins(:pre_build)
+      run_hook(:build, :pre_build, version_name)
+      run_hook(:build, :build, version_name)
+      run_hook(:build, :post_build, version_name)
+      run_plugins(:post_build)
+      run_hook(:repo, :store, @config.build_mechanism, version_name)
+    end
+
+    def deploy_version(version_name)
+      run_plugins(:pre_deploy)
+      run_hook(:deploy, :deploy, @config.artifact_repository, version_name)
+      run_plugins(:post_deploy)
+    end
+
+    def delete
+      run_plugins(:pre_delete)
+      run_hook(:deploy, :pre_delete)
+      stack.delete
+      run_hook(:deploy, :post_delete)
+      run_plugins(:post_delete)
+    end
+
+    def doctor
+      # @todo use #run_hook when Stack becomes an InfrastructureProvider
+      success = true
+      success &&= stack.doctor_hook
+      success &&= run_hook(:build, :doctor)
+      success &&= run_hook(:repo, :doctor)
+      success &&= run_hook(:deploy, :doctor)
+      results = run_plugins(:doctor)
+
+      success = false if results.value?(false)
+      success
+    end
+
+    def stack
+      @stack ||= Stack.new(stack_name,
+                           app_name: @config.app_name,
+                           log: @config.logger,
+                           ilog: @config.interactive_logger) do |config|
+        config.parent_stacks = @config.parent_stacks
+        config.show_all_events = @config.show_all_stack_events
+      end
+    end
+
+    private
+
+    def default_stack_name
+      user = ENV.fetch('USER').gsub(/\W/, '')
+      "#{@config.app_name}-dev-#{user}"
+    end
+
+    def ensure_prefix(name)
+      if name.start_with?(@config.app_name + '-')
+        name
+      else
+        @config.app_name + "-#{name}"
+      end
+    end
+
+    def stack_name
+      name = @config.environment_name || default_stack_name
+      if @config.auto_prefix_stack == false
+        name
+      else
+        ensure_prefix(name)
+      end
+    end
+
+    def resources
+      @resources ||=
+        Resources.new(stack: stack, log: @config.logger,
+                      ilog: @config.interactive_logger)
+    end
+
+    def run_hook(type, name, *args)
+      mech = get_mechanism(type)
+      name = name.to_s << '_hook'
+
+      @config.logger.debug("Calling hook=#{name} on mech=#{mech.class}")
+      return unless mech && mech.respond_to?(name)
+
+      mech.resources = resources
+      mech.send(name, *args)
+    end
+
+    def run_plugins(type)
+      results = {}
+      @config.plugins.each do |plugin|
+        next unless plugin.respond_to?(type)
+        results[plugin] = plugin.send(type, resources)
+      end
+
+      results
+    end
+
+    def get_mechanism(type)
+      case type
+      when :build then @config.build_mechanism
+      when :repo then @config.artifact_repository
+      when :deploy then @config.deployment_mechanism
+      else
+        raise "Unknown hook type: #{type}"
+      end
+    end
+  end
+end

data/lib/moonshot/controller_config.rb

@@ -0,0 +1,25 @@
+module Moonshot
+  # Holds configuration for Moonshot::Controller
+  class ControllerConfig
+    attr_accessor :app_name
+    attr_accessor :artifact_repository
+    attr_accessor :auto_prefix_stack
+    attr_accessor :build_mechanism
+    attr_accessor :deployment_mechanism
+    attr_accessor :environment_name
+    attr_accessor :interactive_logger
+    attr_accessor :logger
+    attr_accessor :parent_stacks
+    attr_accessor :plugins
+    attr_accessor :show_all_stack_events
+
+    def initialize
+      @auto_prefix_stack = true
+      @interactive_logger = InteractiveLogger.new
+      @logger = Logger.new(STDOUT)
+      @parent_stacks = []
+      @plugins = []
+      @show_all_stack_events = false
+    end
+  end
+end

data/lib/moonshot/creds_helper.rb

@@ -0,0 +1,28 @@
+module Moonshot
+  # Create convenience methods for various AWS client creation.
+  module CredsHelper
+    def cf_client
+      Aws::CloudFormation::Client.new
+    end
+
+    def cd_client
+      Aws::CodeDeploy::Client.new
+    end
+
+    def ec2_client
+      Aws::EC2::Client.new
+    end
+
+    def iam_client
+      Aws::IAM::Client.new
+    end
+
+    def as_client
+      Aws::AutoScaling::Client.new
+    end
+
+    def s3_client
+      Aws::S3::Client.new
+    end
+  end
+end

data/lib/moonshot/deployment_mechanism/code_deploy.rb

@@ -0,0 +1,303 @@
+require 'colorize'
+
+# This mechanism is used to deploy software to an auto-scaling group within
+# a stack. It currently only works with the S3Bucket ArtifactRepository.
+#
+# Usage:
+# class MyApp < Moonshot::CLI
+#   self.artifact_repository = S3Bucket.new('foobucket')
+#   self.deployment_mechanism = CodeDeploy.new(asg: 'AutoScalingGroup')
+# end
+class Moonshot::DeploymentMechanism::CodeDeploy # rubocop:disable ClassLength
+  include Moonshot::ResourcesHelper
+  include Moonshot::CredsHelper
+  include Moonshot::DoctorHelper
+
+  # @param asg [String]
+  #   The logical name of the AutoScalingGroup to create and manage a Deployment
+  #   Group for in CodeDeploy.
+  # @param app_name [String, nil] (nil)
+  #   The name of the CodeDeploy Application and Deployment Group. By default,
+  #   this is the same as the stack name, and probably what you want. If you
+  #   have multiple deployments in a single Stack, they must have unique names.
+  def initialize(asg:, app_name: nil)
+    @asg_logical_id = asg
+    @app_name = app_name
+  end
+
+  def post_create_hook
+    create_application_if_needed
+    create_deployment_group_if_needed
+
+    wait_for_asg_capacity
+  end
+
+  def post_update_hook
+    post_create_hook
+
+    unless deployment_group_ok? # rubocop:disable GuardClause
+      delete_deployment_group
+      create_deployment_group_if_needed
+    end
+  end
+
+  def status_hook
+    t = Moonshot::UnicodeTable.new('')
+    application = t.add_leaf("CodeDeploy Application: #{app_name}")
+    application.add_line(code_deploy_status_msg)
+    t.draw_children
+  end
+
+  def deploy_hook(artifact_repo, version_name)
+    ilog.start_threaded 'Creating Deployment' do |s|
+      res = cd_client.create_deployment(
+        application_name: app_name,
+        deployment_group_name: app_name,
+        revision: revision_for_artifact_repo(artifact_repo, version_name),
+        deployment_config_name: 'CodeDeployDefault.OneAtATime',
+        description: "Deploying version #{version_name}"
+      )
+      deployment_id = res.deployment_id
+      s.continue "Created Deployment #{deployment_id.blue}."
+      wait_for_deployment(deployment_id, s)
+    end
+  end
+
+  def post_delete_hook
+    ilog.start 'Cleaning up CodeDeploy Application' do |s|
+      if application_exists?
+        cd_client.delete_application(application_name: app_name)
+        s.success "Deleted CodeDeploy Application '#{app_name}'."
+      else
+        s.success "CodeDeploy Application '#{app_name}' does not exist."
+      end
+    end
+  end
+
+  private
+
+  # By default, use the stack name as the application and deployment group
+  # names, unless one has been provided.
+  def app_name
+    @app_name || stack.name
+  end
+
+  def pretty_app_name
+    "CodeDeploy Application #{app_name.blue}"
+  end
+
+  def pretty_deploy_group
+    "CodeDeploy Deployment Group #{app_name.blue}"
+  end
+
+  def create_application_if_needed
+    ilog.start "Creating #{pretty_app_name}." do |s|
+      if application_exists?
+        s.success "#{pretty_app_name} already exists."
+      else
+        cd_client.create_application(application_name: app_name)
+        s.success "Created #{pretty_app_name}."
+      end
+    end
+  end
+
+  def create_deployment_group_if_needed
+    ilog.start "Creating #{pretty_deploy_group}." do |s|
+      if deployment_group_exists?
+        s.success "CodeDeploy #{pretty_deploy_group} already exists."
+      else
+        create_deployment_group
+        s.success "Created #{pretty_deploy_group}."
+      end
+    end
+  end
+
+  def code_deploy_status_msg
+    case [application_exists?, deployment_group_exists?, deployment_group_ok?]
+    when [true, true, true]
+      'Application and Deployment Group are configured correctly.'.green
+    when [true, true, false]
+      'Deployment Group exists, but not associated with the correct '\
+      "Auto-Scaling Group, try running #{'update'.yellow}."
+    when [true, false, false]
+      "Deployment Group does not exist, try running #{'create'.yellow}."
+    when [false, false, false]
+      'Application and Deployment Group do not exist, try running'\
+      " #{'create'.yellow}."
+    end
+  end
+
+  def auto_scaling_group
+    @auto_scaling_group ||= load_auto_scaling_group
+  end
+
+  def load_auto_scaling_group
+    asg_name = stack.physical_id_for(@asg_logical_id)
+    unless asg_name
+      raise Thor::Error, "Could not find #{@asg_logical_id} resource in Stack."
+    end
+
+    groups = as_client.describe_auto_scaling_groups(
+      auto_scaling_group_names: [asg_name])
+    if groups.auto_scaling_groups.empty?
+      raise Thor::Error, "Could not find ASG #{asg_name}."
+    end
+
+    groups.auto_scaling_groups.first
+  end
+
+  def asg_name
+    auto_scaling_group.auto_scaling_group_name
+  end
+
+  def application_exists?
+    cd_client.get_application(application_name: app_name)
+    true
+  rescue Aws::CodeDeploy::Errors::ApplicationDoesNotExistException
+    false
+  end
+
+  def deployment_group
+    cd_client.get_deployment_group(
+      application_name: app_name, deployment_group_name: app_name)
+             .deployment_group_info
+  end
+
+  def deployment_group_exists?
+    cd_client.get_deployment_group(
+      application_name: app_name, deployment_group_name: app_name)
+    true
+  rescue Aws::CodeDeploy::Errors::ApplicationDoesNotExistException,
+         Aws::CodeDeploy::Errors::DeploymentGroupDoesNotExistException
+    false
+  end
+
+  def deployment_group_ok?
+    return false unless deployment_group_exists?
+    asg = deployment_group.auto_scaling_groups.first
+    return false unless asg
+    asg.name == auto_scaling_group.auto_scaling_group_name
+  end
+
+  def role
+    iam_client.get_role(role_name: 'CodeDeployRole').role
+  rescue Aws::IAM::Errors::NoSuchEntity
+    raise Thor::Error, 'Did not find an IAM Role: CodeDeployRole'
+  end
+
+  def delete_deployment_group
+    ilog.start "Deleting #{pretty_deploy_group}." do |s|
+      cd_client.delete_deployment_group(
+        application_name: app_name,
+        deployment_group_name: app_name)
+      s.success
+    end
+  end
+
+  def create_deployment_group
+    cd_client.create_deployment_group(
+      application_name: app_name,
+      deployment_group_name: app_name,
+      service_role_arn: role.arn,
+      auto_scaling_groups: [asg_name])
+  end
+
+  def wait_for_asg_capacity
+    ilog.start 'Waiting for AutoScaling Group to reach capacity...' do |s|
+      loop do
+        asg = load_auto_scaling_group
+        count = asg.instances.count { |i| i.lifecycle_state == 'InService' }
+        break if asg.desired_capacity == count
+        s.continue "DesiredCapacity is #{asg.desired_capacity}, currently #{count} instance(s) are InService." # rubocop:disable LineLength
+        sleep 5
+      end
+
+      s.success 'AutoScaling Group up to capacity!'
+    end
+  end
+
+  def wait_for_deployment(id, step)
+    loop do
+      sleep 5
+      info = cd_client.get_deployment(deployment_id: id).deployment_info
+      status = info.status
+
+      case status
+      when 'Created', 'Queued', 'InProgress'
+        step.continue "Waiting for Deployment #{id.blue} to complete, current status is '#{status}'." # rubocop:disable LineLength
+      when 'Succeeded'
+        step.success "Deployment #{id.blue} completed successfully!"
+        break
+      when 'Failed', 'Stopped'
+        step.failure "Deployment #{id.blue} failed with status '#{status}'"
+        handle_deployment_failure(id)
+      end
+    end
+  end
+
+  def handle_deployment_failure(deployment_id) # rubocop:disable AbcSize
+    instances = cd_client.list_deployment_instances(deployment_id: deployment_id)
+                         .instances_list.map do |instance_id|
+      cd_client.get_deployment_instance(deployment_id: deployment_id,
+                                        instance_id: instance_id)
+    end
+
+    instances.map(&:instance_summary).each do |inst_summary|
+      next unless inst_summary.status == 'Failed'
+
+      inst_summary.lifecycle_events.each do |event|
+        next unless event.status == 'Failed'
+
+        ilog.error(event.diagnostics.message)
+        event.diagnostics.log_tail.each_line do |line|
+          ilog.error(line)
+        end
+      end
+    end
+
+    raise Thor::Error, 'Deployment was unsuccessful!'
+  end
+
+  def revision_for_artifact_repo(artifact_repo, version_name)
+    case artifact_repo
+    when Moonshot::ArtifactRepository::S3Bucket
+      s3_revision_for(artifact_repo, version_name)
+    when NilClass
+      raise 'Must specify an ArtifactRepository with CodeDeploy. Take a look at the S3Bucket example.' # rubocop:disable LineLength
+    else
+      raise "Cannot use #{artifact_repo.class} to deploy with CodeDeploy."
+    end
+  end
+
+  def s3_revision_for(artifact_repo, version_name)
+    {
+      revision_type: 'S3',
+      s3_location: {
+        bucket: artifact_repo.bucket_name,
+        key: artifact_repo.filename_for_version(version_name),
+        bundle_type: 'tgz'
+      }
+    }
+  end
+
+  def doctor_check_code_deploy_role
+    iam_client.get_role(role_name: 'CodeDeployRole').role
+    success('CodeDeployRole exists.')
+  rescue => e
+    help = <<-EOF
+Error: #{e.message}
+
+For information on provisioning an account for use with CodeDeploy, see:
+http://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-create-service-role.html
+    EOF
+    critical('Could not find CodeDeployRole, ', help)
+  end
+
+  def doctor_check_auto_scaling_resource_defined
+    if stack.template.resource_names.include?(@asg_logical_id)
+      success("Resource '#{@asg_logical_id}' exists in the CloudFormation template.") # rubocop:disable LineLength
+    else
+      critical("Resource '#{@asg_logical_id}' does not exist in the CloudFormation template!") # rubocop:disable LineLength
+    end
+  end
+end

data/lib/moonshot/doctor_helper.rb

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+require 'colorize'
+
+module Moonshot
+  DoctorCritical = Class.new(RuntimeError)
+
+  #
+  # A series of methods for adding "doctor" checks to a mechanism.
+  #
+  module DoctorHelper
+    def doctor_hook
+      run_all_checks
+    end
+
+    private
+
+    def run_all_checks
+      success = true
+      puts
+      puts self.class.name.split('::').last
+      private_methods.each do |meth|
+        begin
+          send(meth) if meth =~ /^doctor_check_/
+        rescue DoctorCritical
+          # Stop running checks in this Mechanism.
+          success = false
+          break
+        rescue => e
+          success = false
+          print '  ✗ '.red
+          puts "Exception while running check: #{e.class}: #{e.message.lines.first}"
+          break
+        end
+      end
+
+      success
+    end
+
+    def success(str)
+      print '  ✓ '.green
+      puts str
+    end
+
+    def warning(str, additional_info = nil)
+      print '  ? '.yellow
+      puts str
+      additional_info.lines.each { |l| puts "      #{l}" } if additional_info
+    end
+
+    def critical(str, additional_info = nil)
+      print '  ✗ '.red
+      puts str
+      additional_info.lines.each { |l| puts "      #{l}" } if additional_info
+      raise DoctorCritical
+    end
+  end
+end

data/lib/moonshot/environment_parser.rb

@@ -0,0 +1,32 @@
+require 'ostruct'
+
+module Moonshot
+  # This module supports massaging of the incoming environment.
+  module EnvironmentParser
+    def self.parse(log)
+      log.debug('Starting to parse environment.')
+
+      # Ops Bastion servers export AWS_CREDENTIAL_FILE, instead of key and
+      # secret keys, so we support both here. We then set them as environment
+      # variables which will be respected by aws-sdk.
+      parse_credentials_file if ENV.key?('AWS_CREDENTIAL_FILE')
+
+      # Ensure the aws-sdk is able to find a set of credentials.
+      creds = Aws::CredentialProviderChain.new(OpenStruct.new).resolve
+
+      raise 'Unable to find AWS credentials!' unless creds
+
+      log.debug('Environment parsing complete.')
+    end
+
+    def self.parse_credentials_file
+      File.open(ENV.fetch('AWS_CREDENTIAL_FILE')).each_line do |line|
+        key, val = line.chomp.split('=')
+        case key
+        when 'AWSAccessKeyId' then ENV['AWS_ACCESS_KEY_ID'] = val
+        when 'AWSSecretKey'   then ENV['AWS_SECRET_ACCESS_KEY'] = val
+        end
+      end
+    end
+  end
+end

data/lib/moonshot/interactive_logger_proxy.rb

@@ -0,0 +1,49 @@
+require 'forwardable'
+
+module Moonshot
+  # This class pretends to be an InteractiveLogger for systems that are
+  # non-interactive.
+  class InteractiveLoggerProxy
+    # Non-interactive version of InteractiveLogger::Step.
+    class Step
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def blank
+      end
+
+      def continue(str = nil)
+        @logger.info(str) if str
+      end
+
+      def failure(str = 'Failure')
+        @logger.error(str)
+      end
+
+      def repaint
+      end
+
+      def success(str = 'Success')
+        @logger.info(str)
+      end
+    end
+
+    extend Forwardable
+
+    def_delegator :@debug, :itself, :debug?
+    def_delegators :@logger, :debug, :error, :info
+    alias msg info
+
+    def initialize(logger, debug: false)
+      @debug = debug
+      @logger = logger
+    end
+
+    def start(str)
+      @logger.info(str)
+      yield Step.new(@logger)
+    end
+    alias start_threaded start
+  end
+end

data/lib/moonshot/resources.rb

@@ -0,0 +1,13 @@
+module Moonshot
+  # Resources is a dependency container that holds references to instances
+  # provided to a Mechanism (build, deploy, etc.).
+  class Resources
+    attr_reader :log, :stack, :ilog
+
+    def initialize(log:, stack:, ilog:)
+      @log = log
+      @stack = stack
+      @ilog = ilog
+    end
+  end
+end

data/lib/moonshot/resources_helper.rb

@@ -0,0 +1,24 @@
+module Moonshot
+  # Provides shorthand methods for accessing resources provided by the Resources
+  # container.
+  module ResourcesHelper
+    attr_writer :resources
+
+    private
+
+    def log
+      raise 'Resources not provided to Mechanism!' unless @resources
+      @resources.log
+    end
+
+    def stack
+      raise 'Resources not provided to Mechanism!' unless @resources
+      @resources.stack
+    end
+
+    def ilog
+      raise 'Resources not provided to Mechanism!' unless @resources
+      @resources.ilog
+    end
+  end
+end