stack_master 0.0.1

data/lib/stack_master/commands/validate.rb

@@ -0,0 +1,17 @@
+module StackMaster
+  module Commands
+    class Validate
+      include Command
+      include Commander::UI
+
+      def initialize(config, stack_definition)
+        @config = config
+        @stack_definition = stack_definition
+      end
+
+      def perform
+        Validator.perform(@stack_definition)
+      end
+    end
+  end
+end

data/lib/stack_master/config.rb

@@ -0,0 +1,86 @@
+require 'deep_merge/rails_compat'
+require 'active_support/core_ext/object/deep_dup'
+
+module StackMaster
+  class Config
+    def self.load!(config_file = 'stack_master.yml')
+      config = YAML.load(File.read(config_file))
+      base_dir = File.dirname(File.expand_path(config_file))
+      new(config, base_dir)
+    end
+
+    attr_accessor :stacks,
+                  :base_dir,
+                  :stack_defaults,
+                  :region_defaults,
+                  :region_aliases
+
+    def initialize(config, base_dir)
+      @config = config
+      @base_dir = base_dir
+      @stack_defaults = config.fetch('stack_defaults', {})
+      @region_aliases = Utils.underscore_keys_to_hyphen(config.fetch('region_aliases', {}))
+      @region_to_aliases = @region_aliases.inject({}) do |hash, (key, value)|
+        hash[value] ||= []
+        hash[value] << key
+        hash
+      end
+      @region_defaults = normalise_region_defaults(config.fetch('region_defaults', {}))
+      @stacks = []
+      load_config
+    end
+
+    def find_stack(region, stack_name)
+      @stacks.find do |s|
+        (s.region == region || s.region == region.gsub('_', '-')) &&
+          (s.stack_name == stack_name || s.stack_name == stack_name.gsub('_', '-'))
+      end
+    end
+
+    def unalias_region(region)
+      @region_aliases.fetch(region) { region }
+    end
+
+    private
+
+    def load_config
+      unaliased_stacks = resolve_region_aliases(@config.fetch('stacks'))
+      load_stacks(unaliased_stacks)
+    end
+
+    def resolve_region_aliases(stacks)
+      stacks.inject({}) do |hash, (region, attributes)|
+        hash[unalias_region(region)] = attributes
+        hash
+      end
+    end
+
+    def load_stacks(stacks)
+      stacks.each do |region, stacks_for_region|
+        region = Utils.underscore_to_hyphen(region)
+        stacks_for_region.each do |stack_name, attributes|
+          stack_name = Utils.underscore_to_hyphen(stack_name)
+          stack_attributes = build_stack_defaults(region).deeper_merge(attributes).merge(
+            'region' => region,
+            'stack_name' => stack_name,
+            'base_dir' => @base_dir,
+            'additional_parameter_lookup_dirs' => @region_to_aliases[region])
+          @stacks << StackDefinition.new(stack_attributes)
+        end
+      end
+    end
+
+    def build_stack_defaults(region)
+      region_defaults = @region_defaults.fetch(region, {}).deep_dup
+      @stack_defaults.deep_dup.deeper_merge(region_defaults)
+    end
+
+    def normalise_region_defaults(region_defaults)
+      region_defaults.inject({}) do |normalised_aliases, (region_or_alias, value)|
+        region = unalias_region(region_or_alias)
+        normalised_aliases[Utils.underscore_to_hyphen(region)] = value
+        normalised_aliases
+      end
+    end
+  end
+end

data/lib/stack_master/ctrl_c.rb

@@ -0,0 +1,4 @@
+module StackMaster
+  class CtrlC < Exception
+  end
+end

data/lib/stack_master/parameter_loader.rb

@@ -0,0 +1,17 @@
+module StackMaster
+  class ParameterLoader
+    def self.load(parameter_files)
+      parameter_files.reduce({}) do |hash, file_name|
+        parameters = if File.exists?(file_name)
+          YAML.load(File.read(file_name)) || {}
+        else
+          {}
+        end
+        parameters.each do |key, value|
+          hash[key.camelize] = value
+        end
+        hash
+      end
+    end
+  end
+end

data/lib/stack_master/parameter_resolver.rb

@@ -0,0 +1,45 @@
+module StackMaster
+  class ParameterResolver
+    ResolverNotFound = Class.new(StandardError)
+    InvalidParameter = Class.new(StandardError)
+
+    def self.resolve(config, stack_definition, parameters)
+      new(config, stack_definition, parameters).resolve
+    end
+
+    def initialize(config, stack_definition, parameters)
+      @config = config
+      @stack_definition = stack_definition
+      @parameters = parameters
+      @resolvers = {}
+    end
+
+    def resolve
+      @parameters.reduce({}) do |parameters, (key, value)|
+        parameters[key] = resolve_parameter_value(value)
+        parameters
+      end
+    end
+
+    private
+
+    def resolve_parameter_value(parameter_value)
+      return parameter_value if String === parameter_value || parameter_value.nil?
+      raise InvalidParameter, parameter_value unless Hash === parameter_value
+      raise InvalidParameter, parameter_value unless parameter_value.keys.size == 1
+      resolver_class_name = parameter_value.keys.first.to_s.camelize
+      value = parameter_value.values.first
+      resolver_class(resolver_class_name).resolve(value)
+    end
+
+    def resolver_class(class_name)
+      @resolvers.fetch(class_name) do
+        begin
+          @resolvers[class_name] = Kernel.const_get("StackMaster::ParameterResolvers::#{class_name}").new(@config, @stack_definition)
+        rescue NameError
+          raise ResolverNotFound, "Could not find parameter resolver called #{class_name}, please double check your configuration"
+        end
+      end
+    end
+  end
+end

data/lib/stack_master/parameter_resolvers/secret.rb

@@ -0,0 +1,42 @@
+module StackMaster
+  module ParameterResolvers
+    class Secret
+      SecretNotFound = Class.new(StandardError)
+
+      def initialize(config, stack_definition)
+        @config = config
+        @stack_definition = stack_definition
+      end
+
+      def resolve(value)
+        secret_key = value
+        raise ArgumentError, "No secret_file defined for stack definition #{@stack_definition.stack_name} in #{@stack_definition.region}" unless !@stack_definition.secret_file.nil?
+        raise ArgumentError, "Could not find secret file at #{secret_file_path}" unless File.exist?(secret_file_path)
+        secrets_hash.fetch(secret_key) do
+          raise SecretNotFound, "Unable to find key #{secret_key} in file #{secret_file_path}"
+        end
+      end
+
+      private
+
+      def secrets_hash
+        @secrets_hash ||= YAML.load(decrypt_with_dotgpg)
+      end
+
+      def decrypt_with_dotgpg
+        dir = Dotgpg::Dir.closest(secret_file_path)
+        stream = StringIO.new
+        dir.decrypt(secret_path_relative_to_base, stream)
+        stream.string
+      end
+
+      def secret_path_relative_to_base
+        @secret_path_relative_to_base ||= File.join('secrets', @stack_definition.secret_file)
+      end
+
+      def secret_file_path
+        @secret_file_path ||= File.join(@config.base_dir, secret_path_relative_to_base)
+      end
+    end
+  end
+end

data/lib/stack_master/parameter_resolvers/security_group.rb

@@ -0,0 +1,20 @@
+module StackMaster
+  module ParameterResolvers
+    class SecurityGroup
+      def initialize(config, stack_definition)
+        @config = config
+        @stack_definition = stack_definition
+      end
+
+      def resolve(value)
+        security_group_finder.find(value)
+      end
+
+      private
+
+      def security_group_finder
+        StackMaster::SecurityGroupFinder.new(@stack_definition.region)
+      end
+    end
+  end
+end

data/lib/stack_master/parameter_resolvers/sns_topic_name.rb

@@ -0,0 +1,29 @@
+module StackMaster
+  module ParameterResolvers
+    class SnsTopicName
+      TopicNotFound = Class.new(StandardError)
+
+      def initialize(config, stack_definition)
+        @config = config
+        @stack_definition = stack_definition
+        @stacks = {}
+      end
+
+      def resolve(value)
+        sns_topic_finder.find(value)
+      rescue StackMaster::SnsTopicFinder::TopicNotFound => e
+        raise TopicNotFound.new(e.message)
+      end
+
+      private
+
+      def cf
+        @cf ||= StackMaster.cloud_formation_driver
+      end
+
+      def sns_topic_finder
+        StackMaster::SnsTopicFinder.new(@stack_definition.region)
+      end
+    end
+  end
+end

data/lib/stack_master/parameter_resolvers/stack_output.rb

@@ -0,0 +1,53 @@
+module StackMaster
+  module ParameterResolvers
+    class StackOutput
+      StackNotFound = Class.new(StandardError)
+      StackOutputNotFound = Class.new(StandardError)
+
+      def initialize(config, stack_definition)
+        @config = config
+        @stack_definition = stack_definition
+        @stacks = {}
+      end
+
+      def resolve(value)
+        validate_value!(value)
+        stack_name, output_name = value.split('/')
+        stack = find_stack(stack_name)
+        if stack
+          output = stack.outputs.find { |output| output.output_key == output_name.camelize }
+          if output
+            output.output_value
+          else
+            raise StackOutputNotFound, "Stack exists (#{stack_name}), but output does not: #{output_name}"
+          end
+        else
+          raise StackNotFound, "Stack in StackOutput not found: #{value}"
+        end
+      end
+
+      private
+
+      def cf
+        @cf ||= StackMaster.cloud_formation_driver
+      end
+
+      def validate_value!(value)
+        if !value.is_a?(String) || !value.include?('/')
+          raise ArgumentError, 'Stack output values must be in the form of stack-name/output-name'
+        end
+      end
+
+      def find_stack(stack_name)
+        @stacks.fetch(stack_name) do
+          cf_stack = cf.describe_stacks(stack_name: stack_name).stacks.first
+          @stacks[stack_name] = cf_stack
+        end
+      end
+
+      def cf
+        @cf ||= StackMaster.cloud_formation_driver
+      end
+    end
+  end
+end

data/lib/stack_master/prompter.rb

@@ -0,0 +1,14 @@
+module StackMaster
+  module Prompter
+    def ask?(question)
+      StackMaster.stdout.print question
+      answer = if ENV['STUB_AWS']
+        ENV['ANSWER']
+      else
+        STDIN.getch.chomp
+      end
+      StackMaster.stdout.puts
+      answer == 'y'
+    end
+  end
+end

data/lib/stack_master/security_group_finder.rb

@@ -0,0 +1,29 @@
+module StackMaster
+  class SecurityGroupFinder
+    SecurityGroupNotFound = Class.new(StandardError)
+    MultipleSecurityGroupsFound = Class.new(StandardError)
+
+    def initialize(region)
+      @resource = Aws::EC2::Resource.new(region: region)
+    end
+
+    def find(reference)
+      STDERR.puts "Resolving security group reference '#{reference}'"
+      raise ArgumentError, 'Security group references must be non-empty strings' unless reference.is_a?(String) && !reference.empty?
+
+      groups = @resource.security_groups({
+                                           filters: [
+                                             {
+                                               name: "group-name",
+                                               values: [reference],
+                                             },
+                                           ],
+                                         })
+
+      raise SecurityGroupNotFound, "No security group with name #{reference} found" unless groups.any?
+      raise MultipleSecurityGroupsFound, "More than one security group with name #{reference} found" if groups.count > 1
+
+      groups.first.id
+    end
+  end
+end

data/lib/stack_master/sns_topic_finder.rb

@@ -0,0 +1,27 @@
+module StackMaster
+  class SnsTopicFinder
+    TopicNotFound = Class.new(StandardError)
+
+    def initialize(region)
+      @resource = Aws::SNS::Resource.new(region: region)
+    end
+
+    def find(reference)
+      $stderr.puts "Resolving SNS topic reference '#{reference}'"
+      raise ArgumentError, 'SNS topic references must be non-empty strings' unless reference.is_a?(String) && !reference.empty?
+
+      topic = @resource.topics.detect { |t| topic_name_from_arn(t.arn) == reference }
+
+      raise TopicNotFound, "No topic with name #{reference} found" unless topic
+
+      topic.arn
+    end
+
+    private
+
+    def topic_name_from_arn(arn)
+      arn.split(":")[5]
+    end
+
+  end
+end

data/lib/stack_master/stack.rb

@@ -0,0 +1,96 @@
+module StackMaster
+  class Stack
+    MAX_TEMPLATE_SIZE = 51200
+
+    include Virtus.model
+
+    attribute :stack_name, String
+    attribute :region, String
+    attribute :stack_id, String
+    attribute :stack_status, String
+    attribute :parameters, Hash
+    attribute :template_body, String
+    attribute :notification_arns, Array[String]
+    attribute :outputs, Array
+    attribute :stack_policy_body, String
+    attribute :tags, Hash
+
+    def template_hash
+      if template_body
+        @template_hash ||= JSON.parse(template_body)
+      end
+    end
+
+    def maybe_compressed_template_body
+      if template_body.size > MAX_TEMPLATE_SIZE
+        @compressed_template_body ||= JSON.dump(template_hash)
+      else
+        template_body
+      end
+    end
+
+    def template_default_parameters
+      template_hash.fetch('Parameters', {}).inject({}) do |result, (parameter_name, description)|
+        result[parameter_name] = description['Default']
+        result
+      end
+    end
+
+    def parameters_with_defaults
+      template_default_parameters.merge(parameters)
+    end
+
+    def self.find(region, stack_name)
+      cf = StackMaster.cloud_formation_driver
+      cf_stack = cf.describe_stacks(stack_name: stack_name).stacks.first
+      return unless cf_stack
+      parameters = cf_stack.parameters.inject({}) do |params_hash, param_struct|
+        params_hash[param_struct.parameter_key] = param_struct.parameter_value
+        params_hash
+      end
+      template_body ||= cf.get_template(stack_name: stack_name).template_body
+      stack_policy_body ||= cf.get_stack_policy(stack_name: stack_name).stack_policy_body
+      outputs = cf_stack.outputs
+
+      new(region: region,
+          stack_name: stack_name,
+          stack_id: cf_stack.stack_id,
+          parameters: parameters,
+          template_body: template_body,
+          outputs: outputs,
+          notification_arns: cf_stack.notification_arns,
+          stack_policy_body: stack_policy_body,
+          stack_status: cf_stack.stack_status)
+    rescue Aws::CloudFormation::Errors::ValidationError
+      nil
+    end
+
+    def self.generate(stack_definition, config)
+      parameter_hash = ParameterLoader.load(stack_definition.parameter_files)
+      template_body = TemplateCompiler.compile(stack_definition.template_file_path)
+      parameters = ParameterResolver.resolve(config, stack_definition, parameter_hash)
+      stack_policy_body = if stack_definition.stack_policy_file_path
+                            File.read(stack_definition.stack_policy_file_path)
+                          end
+      new(region: stack_definition.region,
+          stack_name: stack_definition.stack_name,
+          tags: stack_definition.tags,
+          parameters: parameters,
+          template_body: template_body,
+          notification_arns: stack_definition.notification_arns,
+          stack_policy_body: stack_policy_body)
+    end
+
+    def too_big?
+      maybe_compressed_template_body.size > MAX_TEMPLATE_SIZE
+    end
+
+    def aws_parameters
+      Utils.hash_to_aws_parameters(parameters)
+    end
+
+    def aws_tags
+      Utils.hash_to_aws_tags(tags)
+    end
+  end
+end