moonshot 0.7.7 → 1.0.0.rc1

data/lib/moonshot/controller_config.rb

@@ -1,35 +1,53 @@
 require_relative 'default_strategy'
 require_relative 'ssh_config'
+require_relative 'task'
+require_relative 'ask_user_source'
 
 module Moonshot
   # Holds configuration for Moonshot::Controller
   class ControllerConfig
+    attr_accessor :additional_tag
+    attr_accessor :answer_file
     attr_accessor :app_name
     attr_accessor :artifact_repository
-    attr_accessor :auto_prefix_stack
     attr_accessor :build_mechanism
     attr_accessor :deployment_mechanism
+    attr_accessor :dev_build_name_proc
     attr_accessor :environment_name
+    attr_accessor :interactive
     attr_accessor :interactive_logger
-    attr_accessor :logger
+    attr_accessor :parameter_overrides
+    attr_accessor :parameters
     attr_accessor :parent_stacks
+    attr_accessor :default_parameter_source
+    attr_accessor :parameter_sources
     attr_accessor :plugins
+    attr_accessor :project_root
     attr_accessor :show_all_stack_events
-    attr_accessor :parameter_strategy
-    attr_accessor :ssh_config
-    attr_accessor :ssh_command
     attr_accessor :ssh_auto_scaling_group_name
+    attr_accessor :ssh_command
+    attr_accessor :ssh_config
     attr_accessor :ssh_instance
 
     def initialize
-      @auto_prefix_stack = true
-      @interactive_logger = InteractiveLogger.new
-      @logger = Logger.new(STDOUT)
-      @parent_stacks = []
-      @plugins = []
-      @show_all_stack_events = false
-      @parameter_strategy = Moonshot::ParameterStrategy::DefaultStrategy.new
-      @ssh_config = SSHConfig.new
+      @default_parameter_source = AskUserSource.new
+      @interactive              = true
+      @interactive_logger       = InteractiveLogger.new
+      @parameter_overrides      = {}
+      @parameter_sources        = {}
+      @parameters               = ParameterCollection.new
+      @parent_stacks            = []
+      @plugins                  = []
+      @project_root             = Dir.pwd
+      @show_all_stack_events    = false
+      @ssh_config               = SSHConfig.new
+
+      @dev_build_name_proc = lambda do |c|
+        ['dev', c.app_name, c.environment_name, Time.now.to_i].join('/')
+      end
+
+      user = ENV.fetch('USER', 'default-user').gsub(/\W/, '')
+      @environment_name = "dev-#{user}"
     end
   end
 end

data/lib/moonshot/deployment_mechanism/code_deploy.rb

@@ -66,6 +66,9 @@ class Moonshot::DeploymentMechanism::CodeDeploy # rubocop:disable ClassLength
   end
 
   def deploy_hook(artifact_repo, version_name)
+    success = true
+    deployment_id = nil
+
     ilog.start_threaded 'Creating Deployment' do |s|
       res = cd_client.create_deployment(
         application_name: app_name,
@@ -76,8 +79,10 @@ class Moonshot::DeploymentMechanism::CodeDeploy # rubocop:disable ClassLength
       )
       deployment_id = res.deployment_id
       s.continue "Created Deployment #{deployment_id.blue}."
-      wait_for_deployment(deployment_id, s)
+      success = wait_for_deployment(deployment_id, s)
     end
+
+    handle_deployment_failure(deployment_id) unless success
   end
 
   def post_delete_hook
@@ -159,13 +164,13 @@ class Moonshot::DeploymentMechanism::CodeDeploy # rubocop:disable ClassLength
     @asg_logical_ids.each do |asg_logical_id|
       asg_name = stack.physical_id_for(asg_logical_id)
       unless asg_name
-        raise Thor::Error, "Could not find #{asg_logical_id} resource in Stack."
+        raise "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}."
+        raise "Could not find ASG #{asg_name}."
       end
 
       autoscaling_groups.push(groups.auto_scaling_groups.first)
@@ -219,7 +224,7 @@ class Moonshot::DeploymentMechanism::CodeDeploy # rubocop:disable ClassLength
   def role
     iam_client.get_role(role_name: @codedeploy_role).role
   rescue Aws::IAM::Errors::NoSuchEntity
-    raise Thor::Error, "Did not find an IAM Role: #{@codedeploy_role}"
+    raise "Did not find an IAM Role: #{@codedeploy_role}"
   end
 
   def delete_deployment_group
@@ -240,7 +245,7 @@ class Moonshot::DeploymentMechanism::CodeDeploy # rubocop:disable ClassLength
   end
 
   def wait_for_asg_capacity
-    ilog.start 'Waiting for AutoScaling Group(s) to reach capacity...' do |s|
+    ilog.start_threaded 'Waiting for AutoScaling Group(s) to reach capacity...' do |s|
       loop do
         asgs_at_capacity = 0
         asgs = load_auto_scaling_groups
@@ -260,6 +265,8 @@ class Moonshot::DeploymentMechanism::CodeDeploy # rubocop:disable ClassLength
   end
 
   def wait_for_deployment(id, step)
+    success = true
+
     loop do
       sleep 5
       info = cd_client.get_deployment(deployment_id: id).deployment_info
@@ -273,9 +280,12 @@ class Moonshot::DeploymentMechanism::CodeDeploy # rubocop:disable ClassLength
         break
       when 'Failed', 'Stopped'
         step.failure "Deployment #{id.blue} failed with status '#{status}'"
-        handle_deployment_failure(id)
+        success = false
+        break
       end
     end
+
+    success
   end
 
   def handle_deployment_failure(deployment_id)
@@ -298,7 +308,7 @@ class Moonshot::DeploymentMechanism::CodeDeploy # rubocop:disable ClassLength
       end
     end
 
-    raise Thor::Error, 'Deployment was unsuccessful!'
+    raise 'Deployment was unsuccessful!'
   end
 
   def revision_for_artifact_repo(artifact_repo, version_name)

data/lib/moonshot/json_stack_template.rb

@@ -0,0 +1,17 @@
+require 'json'
+require_relative 'stack_template'
+
+module Moonshot
+  # Handles JSON formatted AWS template files.
+  class JsonStackTemplate < StackTemplate
+    def body
+      template_body.to_json
+    end
+
+    private
+
+    def template_body
+      @template_body ||= JSON.parse(File.read(@filename))
+    end
+  end
+end

data/lib/moonshot/parameter_collection.rb

@@ -0,0 +1,50 @@
+module Moonshot
+  # A Rigid Hash-like structure that only accepts manipulation of
+  # parameters defined in the Stack template. Anything else results in
+  # an exception.
+  class ParameterCollection
+    extend Forwardable
+
+    def_delegators :@hash, :key?, :fetch, :[], :keys, :values
+
+    def self.from_template(template)
+      obj = new
+
+      template.parameters.each do |stack_parameter|
+        obj.add(stack_parameter)
+      end
+
+      obj
+    end
+
+    def initialize
+      @hash = {}
+    end
+
+    def []=(key, value)
+      raise "Invalid StackParameter #{key}!" unless @hash.key?(key)
+
+      @hash[key].set(value)
+    end
+
+    def add(parameter)
+      raise ArgumentError, 'Can only add StackParameters!' unless parameter.is_a?(StackParameter)
+
+      @hash[parameter.name] = parameter
+    end
+
+    # What parameters are missing for a CreateStack call, where
+    # UsePreviousValue has no meaning.
+    def missing_for_create
+      # If we haven't set a value, and there is no default, we can't
+      # create the stack.
+      @hash.values.select { |v| !v.set? && !v.default? }
+    end
+
+    def missing_for_update
+      # If we don't have a previous value to use, we haven't set a
+      # value, and there is no default, we can't update a stack.
+      @hash.values.select { |v| !v.set? && !v.default? && !v.use_previous? }
+    end
+  end
+end

data/lib/moonshot/parent_stack_parameter_loader.rb

@@ -0,0 +1,51 @@
+module Moonshot
+  class ParentStackParameterLoader
+    def initialize(config)
+      @config = config
+    end
+
+    def load!
+      @config.parent_stacks.each do |stack_name|
+        count = 0
+
+        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|
+          next unless @config.parameters.key?(output.output_key)
+          # Our Stack has a Parameter matching this output. Set it's
+          # value to the Output's value.
+          count += 1
+          @config.parameters.fetch(output.output_key).set(output.output_value)
+        end
+
+        puts "Imported #{count} parameters from parent stack #{stack_name.blue}!" if count > 0
+      end
+    end
+
+    def load_missing_only!
+      @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|
+          next unless @config.parameters.key?(output.output_key)
+          # Our Stack has a Parameter matching this output. Set it's
+          # value to the Output's value, but only if we don't already
+          # have a previous value we're using.
+          unless @config.parameters.fetch(output.output_key).use_previous?
+            @config.parameters.fetch(output.output_key).set(output.output_value)
+          end
+        end
+      end
+    end
+
+    private
+
+    def cf_client
+      Aws::CloudFormation::Client.new
+    end
+  end
+end

data/lib/moonshot/resources.rb

@@ -2,12 +2,12 @@ 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
+    attr_reader :stack, :ilog, :controller
 
-    def initialize(log:, stack:, ilog:)
-      @log = log
+    def initialize(stack:, ilog:, controller:)
       @stack = stack
       @ilog = ilog
+      @controller = controller
     end
   end
 end

data/lib/moonshot/resources_helper.rb

@@ -6,9 +6,9 @@ module Moonshot
 
     private
 
+    # TODO: Deprecate this interface.
     def log
-      raise 'Resources not provided to Mechanism!' unless @resources
-      @resources.log
+      @log ||= Logger.new(STDOUT)
     end
 
     def stack

data/lib/moonshot/ssh_command.rb

@@ -0,0 +1,31 @@
+require 'thor'
+
+module Moonshot
+  # A SSHCommand that is automatically registered with the
+  # Moonshot::CommandLine, including options for SSH access.
+  class SSHCommand < Moonshot::Command
+    def parser
+      parser = super
+      parser.on('-l', '--user USER', 'User to log into remote machine as') do |v|
+        Moonshot.config.ssh_config.ssh_user = v
+      end
+
+      parser.on('-i', '--identity-file FILE', 'SSH Private Key to authenticate with') do |v|
+        Moonshot.config.ssh_config.ssh_identity_file = v
+      end
+
+      parser.on('-s', '--instance INSTANCE_ID', 'Specific AWS EC2 ID to connect through') do |v|
+        Moonshot.config.ssh_instance = v
+      end
+
+      parser.on('-c', '--command COMMAND', 'Command to execute on the remote host') do |v|
+        Moonshot.config.ssh_command = v
+      end
+
+      parser.on('-g', '--auto-scaling-group ASG_NAME',
+                'The logical ID of the ASG to SSH into, required for multiple stacks') do |v|
+        Moonshot.config.ssh_auto_scaling_group_name = v
+      end
+    end
+  end
+end

data/lib/moonshot/ssh_config.rb

@@ -1,5 +1,5 @@
 module Moonshot
-  class SSHConfig # rubocop:disable Documentation
+  class SSHConfig
     attr_accessor :ssh_identity_file
     attr_accessor :ssh_user
   end

data/lib/moonshot/stack.rb

@@ -1,7 +1,8 @@
 require_relative 'creds_helper'
 require_relative 'doctor_helper'
 
-require_relative 'stack_template'
+require_relative 'yaml_stack_template'
+require_relative 'json_stack_template'
 require_relative 'stack_parameter_printer'
 require_relative 'stack_output_printer'
 require_relative 'stack_asg_printer'
@@ -20,19 +21,15 @@ module Moonshot
     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
+    def initialize(config)
       @config = config
+      @ilog = config.interactive_logger
+      @name = [@config.app_name, @config.environment_name].join('-')
+
       yield @config if block_given?
     end
 
     def create
-      import_parent_parameters
-
       should_wait = true
       @ilog.start "Creating #{stack_name}." do |s|
         if stack_exists?
@@ -48,7 +45,7 @@ module Moonshot
     end
 
     def update
-      raise Thor::Error, "No stack found #{@name.blue}!" unless stack_exists?
+      raise "No stack found #{@name.blue}!" unless stack_exists?
 
       should_wait = true
       @ilog.start "Updating #{stack_name}." do |s|
@@ -61,7 +58,7 @@ module Moonshot
       end
 
       success = should_wait ? wait_for_stack_state(:stack_update_complete, 'updated') : true
-      raise Thor::Error, 'Failed to update the CloudFormation Stack.' unless success
+      raise 'Failed to update the CloudFormation Stack.' unless success
       success
     end
 
@@ -147,31 +144,32 @@ module Moonshot
     # 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']
+      template.parameters.each do |p|
+        h[p.name] = h.default
       end
       h
     end
 
     def template
-      @template ||= StackTemplate.new(template_file, log: @log)
+      @template ||= load_template_file
     end
 
     # @return [String] the path to the template file.
     def template_file
-      File.join(Dir.pwd, 'cloud_formation', "#{@app_name}.json")
+      json = json_template_path
+      yaml = yaml_template_path
+
+      @template_file ||= Dir[json].first || Dir[yaml].first
+
+      raise 'CloudFormation template not found at'\
+            "#{json} or #{yaml}!" unless @template_file
+
+      @template_file
     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
+      File.join(@config.project_root, 'cloud_formation', 'parameters', "#{@name}.yml")
     end
 
     private
@@ -180,63 +178,46 @@ module Moonshot
       "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
+    def json_template_path
+      "#{raw_template_file_name}.json"
     end
 
-    def stack_parameter_overrides
-      overrides.map do |k, v|
-        { parameter_key: k, parameter_value: v.to_s }
-      end
+    def yaml_template_path
+      "#{raw_template_file_name}.yml"
     end
 
-    def stack_parameters
-      @stack_parameters ||= JSON.parse(template.body).fetch('Parameters', {}).keys
+    # @return [String] the path to the template file without extension.
+    def raw_template_file_name
+      @raw_template_file_name ||=
+        File.join(@config.project_root, 'cloud_formation', @config.app_name)
     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
+    def load_template_file
+      json_template = JsonStackTemplate.new(json_template_path)
+      yaml_template = YamlStackTemplate.new(yaml_template_path)
+      case
+      when json_template.exist?
+        json_template
+      when yaml_template.exist?
+        yaml_template
+      else
+        raise "CloudFormation template not found at #{json_template_path} "\
+              "or #{yaml_template_path}!" unless @template_file
       end
+    end
 
-      result
+    def stack_parameters
+      template.parameters.map(&:name)
     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?
+      raise "Could not describe stack: #{name}" if stacks.empty?
 
       stacks.first
     rescue Aws::CloudFormation::Errors::ValidationError
-      raise Thor::Error, "Could not describe stack: #{name}"
+      raise "Could not describe stack: #{name}"
     end
 
     def create_stack
@@ -244,13 +225,11 @@ module Moonshot
         stack_name: @name,
         template_body: template.body,
         capabilities: ['CAPABILITY_IAM'],
-        parameters: load_parameters_file,
-        tags: [
-          { key: 'ah_stage', value: @name }
-        ]
+        parameters: @config.parameters.values.map(&:to_cf),
+        tags: make_tags
       )
     rescue Aws::CloudFormation::Errors::AccessDenied
-      raise Thor::Error, 'You are not authorized to perform create_stack calls.'
+      raise 'You are not authorized to perform create_stack calls.'
     end
 
     # @return [Boolean]
@@ -260,27 +239,24 @@ module Moonshot
         stack_name: @name,
         template_body: template.body,
         capabilities: ['CAPABILITY_IAM'],
-        parameters: @config.parameter_strategy.parameters(
-          overrides,
-          parameters,
-          template
-        )
+        parameters: @config.parameters.values.map(&:to_cf),
+        tags: make_tags
       )
       true
     rescue Aws::CloudFormation::Errors::ValidationError => e
-      raise Thor::Error, e.message unless
+      raise 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
+    def wait_for_stack_state(wait_target, past_tense_verb)
       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
+      events.show_only_errors unless @config.show_all_stack_events
 
       @ilog.start_threaded "Waiting for #{stack_name} to be successfully #{past_tense_verb}." do |s|
         begin
@@ -318,6 +294,19 @@ module Moonshot
       result
     end
 
+    def make_tags
+      default_tags = [
+        { key: 'moonshot_application', value: @config.app_name },
+        { key: 'moonshot_environment', value: @config.environment_name }
+      ]
+
+      if @config.additional_tag
+        default_tags << { key: @config.additional_tag, value: @name }
+      end
+
+      default_tags
+    end
+
     def format_event(event)
       str = case event.resource_status
             when /FAILED/