stack_master 1.6.0-x64-mingw32

data/lib/stack_master/sparkle_formation/compile_time/value_validator_factory.rb

@@ -0,0 +1,41 @@
+require_relative 'empty_validator'
+require_relative 'string_validator'
+require_relative 'number_validator'
+require_relative 'allowed_values_validator'
+require_relative 'allowed_pattern_validator'
+require_relative 'max_length_validator'
+require_relative 'min_length_validator'
+require_relative 'max_size_validator'
+require_relative 'min_size_validator'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class ValueValidatorFactory
+
+        VALIDATORS_TYPES = [
+            EmptyValidator,
+            StringValidator,
+            NumberValidator,
+            AllowedValuesValidator,
+            AllowedPatternValidator,
+            MaxLengthValidator,
+            MinLengthValidator,
+            MaxSizeValidator,
+            MinSizeValidator
+        ]
+
+        def initialize(name, definition, parameter)
+          @name = name
+          @definition = definition
+          @parameter = parameter
+        end
+
+        def build
+          VALIDATORS_TYPES.map { |validator| validator.new(@name, @definition, @parameter)}
+        end
+
+      end
+    end
+  end
+end

data/lib/stack_master/sparkle_formation/template_file.rb

@@ -0,0 +1,115 @@
+require 'sparkle_formation'
+require 'erubis'
+
+module StackMaster
+  module SparkleFormation
+    TemplateFileNotFound = ::Class.new(StandardError)
+
+    class SfEruby < Erubis::Eruby
+      include Erubis::ArrayEnhancer
+
+      def add_expr(src, code, indicator)
+        case indicator
+          when '='
+            src << " #{@bufvar} << (" << code << ');'
+          else
+            super
+        end
+      end
+    end
+
+    class TemplateContext < AttributeStruct
+      include ::SparkleFormation::SparkleAttribute
+      include ::SparkleFormation::SparkleAttribute::Aws
+      include ::SparkleFormation::Utils::TypeCheckers
+
+      def self.build(vars, prefix)
+        ::Class.new(self).tap do |klass|
+          vars.each do |key, value|
+            klass.send(:define_method, key) do
+              value
+            end
+          end
+
+        end.new(vars, prefix)
+      end
+
+      def initialize(vars, prefix)
+        self._camel_keys = true
+        @vars = vars
+        @prefix = prefix
+      end
+
+      def has_var?(var_key)
+        @vars.include?(var_key)
+      end
+
+      def render(file_name, vars = {})
+        Template.render(@prefix, file_name, vars)
+      end
+    end
+
+    # Splits up long strings with multiple lines in them to multiple strings
+    # in the CF array. Makes the compiled template and diffs more readable.
+    class CloudFormationLineFormatter
+      def self.format(template)
+        new(template).format
+      end
+
+      def initialize(template)
+        @template = template
+      end
+
+      def format
+        @template.flat_map do |lines|
+          lines = lines.to_s if Symbol === lines
+          if String === lines
+            newlines = []
+            lines.count("\n").times do
+              newlines << "\n"
+            end
+            newlines = lines.split("\n").map do |line|
+              "#{line}#{newlines.pop}"
+            end
+            if lines.starts_with?("\n")
+              newlines.insert(0, "\n")
+            end
+            newlines
+          else
+            lines
+          end
+        end
+      end
+    end
+
+    module Template
+      def self.render(prefix, file_name, vars)
+        file_path = File.join(::SparkleFormation.sparkle_path, prefix, file_name)
+        template = File.read(file_path)
+        template_context = TemplateContext.build(vars, prefix)
+        compiled_template = SfEruby.new(template).evaluate(template_context)
+        CloudFormationLineFormatter.format(compiled_template)
+      rescue Errno::ENOENT => e
+        Kernel.raise TemplateFileNotFound, "Could not find template file at path: #{file_path}"
+      end
+    end
+
+    module JoinedFile
+      def _joined_file(file_name, vars = {})
+        join!(Template.render('joined_file', file_name, vars))
+      end
+      alias_method :joined_file!, :_joined_file
+    end
+
+    module UserDataFile
+      def _user_data_file(file_name, vars = {})
+        base64!(join!(Template.render('user_data', file_name, vars)))
+      end
+      alias_method :user_data_file!, :_user_data_file
+    end
+  end
+end
+
+SparkleFormation::SparkleAttribute::Aws.send(:include, StackMaster::SparkleFormation::UserDataFile)
+SparkleFormation::SparkleAttribute::Aws.send(:include, StackMaster::SparkleFormation::JoinedFile)
+

data/lib/stack_master/stack.rb

@@ -0,0 +1,105 @@
+module StackMaster
+  class Stack
+    attr_reader :stack_name,
+                :region,
+                :stack_id,
+                :stack_status,
+                :parameters,
+                :template_body,
+                :template_format,
+                :role_arn,
+                :notification_arns,
+                :outputs,
+                :stack_policy_body,
+                :tags,
+                :files
+
+    include Utils::Initializable
+
+    def template_default_parameters
+      TemplateUtils.template_hash(template).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 missing_parameters?
+      parameters_with_defaults.any? do |key, value|
+        value == nil
+      end
+    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_stage: 'Original').template_body
+      template_format = TemplateUtils.identify_template_format(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,
+          template_format: template_format,
+          outputs: outputs,
+          role_arn: cf_stack.role_arn,
+          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_parameters = ParameterResolver.resolve(config, stack_definition, parameter_hash[:template_parameters])
+      compile_time_parameters = ParameterResolver.resolve(config, stack_definition, parameter_hash[:compile_time_parameters])
+      template_body = TemplateCompiler.compile(config, stack_definition.template_file_path, compile_time_parameters, stack_definition.compiler_options)
+      template_format = TemplateUtils.identify_template_format(template_body)
+      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: template_parameters,
+          template_body: template_body,
+          template_format: template_format,
+          role_arn: stack_definition.role_arn,
+          notification_arns: stack_definition.notification_arns,
+          stack_policy_body: stack_policy_body)
+    end
+
+    def max_template_size(use_s3)
+      return TemplateUtils::MAX_S3_TEMPLATE_SIZE if use_s3
+      TemplateUtils::MAX_TEMPLATE_SIZE
+    end
+
+    def too_big?(use_s3 = false)
+      template.size > max_template_size(use_s3)
+    end
+
+    def aws_parameters
+      Utils.hash_to_aws_parameters(parameters)
+    end
+
+    def aws_tags
+      Utils.hash_to_aws_tags(tags)
+    end
+
+    def template
+      @template ||= TemplateUtils.maybe_compressed_template_body(template_body)
+    end
+  end
+end

data/lib/stack_master/stack_definition.rb

@@ -0,0 +1,103 @@
+module StackMaster
+  class StackDefinition
+    attr_accessor :region,
+                  :stack_name,
+                  :template,
+                  :tags,
+                  :role_arn,
+                  :notification_arns,
+                  :base_dir,
+                  :template_dir,
+                  :secret_file,
+                  :stack_policy_file,
+                  :additional_parameter_lookup_dirs,
+                  :s3,
+                  :files,
+                  :compiler_options
+
+    include Utils::Initializable
+
+    def initialize(attributes = {})
+      @additional_parameter_lookup_dirs = []
+      @compiler_options = {}
+      @notification_arns = []
+      @s3 = {}
+      @files = []
+      super
+      @template_dir ||= File.join(@base_dir, 'templates')
+    end
+
+    def ==(other)
+      self.class === other &&
+        @region == other.region &&
+        @stack_name == other.stack_name &&
+        @template == other.template &&
+        @tags == other.tags &&
+        @role_arn == other.role_arn &&
+        @notification_arns == other.notification_arns &&
+        @base_dir == other.base_dir &&
+        @secret_file == other.secret_file &&
+        @stack_policy_file == other.stack_policy_file &&
+        @additional_parameter_lookup_dirs == other.additional_parameter_lookup_dirs &&
+        @s3 == other.s3 &&
+        @compiler_options == other.compiler_options
+    end
+
+    def template_file_path
+      File.expand_path(File.join(template_dir, template))
+    end
+
+    def files_dir
+      File.join(base_dir, 'files')
+    end
+
+    def s3_files
+      files.inject({}) do |hash, file|
+        path = File.join(files_dir, file)
+        hash[file] = {
+          path: path,
+          body: File.read(path)
+        }
+        hash
+      end
+    end
+
+    def s3_template_file_name
+      return template if ['.json', '.yaml', '.yml'].include?(File.extname(template))
+      Utils.change_extension(template, 'json')
+    end
+
+    def parameter_files
+      [ default_parameter_file_path, region_parameter_file_path, additional_parameter_lookup_file_paths ].flatten.compact
+    end
+
+    def stack_policy_file_path
+      File.join(base_dir, 'policies', stack_policy_file) if stack_policy_file
+    end
+
+    def s3_configured?
+      !s3.nil?
+    end
+
+    private
+
+    def additional_parameter_lookup_file_paths
+      return unless additional_parameter_lookup_dirs
+      additional_parameter_lookup_dirs.map do |a|
+        Dir.glob(File.join(base_dir, 'parameters', a, "#{underscored_stack_name}.y*ml"))
+      end
+    end
+
+    def region_parameter_file_path
+      Dir.glob(File.join(base_dir, 'parameters', "#{region}", "#{underscored_stack_name}.y*ml"))
+    end
+
+    def default_parameter_file_path
+      Dir.glob(File.join(base_dir, 'parameters', "#{underscored_stack_name}.y*ml"))
+    end
+
+    def underscored_stack_name
+      stack_name.gsub('-', '_')
+    end
+  end
+end

data/lib/stack_master/stack_differ.rb

@@ -0,0 +1,111 @@
+require "diffy"
+
+module StackMaster
+  class StackDiffer
+    def initialize(proposed_stack, current_stack)
+      @proposed_stack = proposed_stack
+      @current_stack = current_stack
+    end
+
+    def proposed_template
+      return @proposed_stack.template_body unless @proposed_stack.template_format == :json
+      JSON.pretty_generate(JSON.parse(@proposed_stack.template_body))
+    end
+
+    def current_template
+      return '' unless @current_stack
+      return @current_stack.template_body unless @current_stack.template_format == :json
+      JSON.pretty_generate(TemplateUtils.template_hash(@current_stack.template_body))
+    end
+
+    def current_parameters
+      if @current_stack
+        YAML.dump(sort_params(@current_stack.parameters_with_defaults))
+      else
+        ''
+      end
+    end
+
+    def proposed_parameters
+      # **** out any secret parameters in the current stack.
+      params = @proposed_stack.parameters_with_defaults
+      if @current_stack
+        noecho_keys.each do |key|
+          params[key] = "****"
+        end
+      end
+      YAML.dump(sort_params(params))
+    end
+
+    def body_different?
+      body_diff != ''
+    end
+
+    def body_diff
+      @body_diff ||= Diffy::Diff.new(current_template, proposed_template, context: 7, include_diff_info: true).to_s
+    end
+
+    def params_different?
+      params_diff != ''
+    end
+
+    def params_diff
+      @param_diff ||= Diffy::Diff.new(current_parameters, proposed_parameters, {}).to_s
+    end
+
+    def output_diff
+      display_diff('Stack', body_diff)
+      display_diff('Parameters', params_diff)
+      unless noecho_keys.empty?
+        StackMaster.stdout.puts " * can not tell if NoEcho parameters are different."
+      end
+      StackMaster.stdout.puts "No stack found" if @current_stack.nil?
+    end
+
+    def noecho_keys
+      if @current_stack
+        @current_stack.parameters_with_defaults.select do |key, value|
+          value == "****"
+        end.keys
+      else
+        []
+      end
+    end
+
+    private
+
+    def display_diff(thing, diff)
+      StackMaster.stdout.print "#{thing} diff: "
+      if diff == ''
+        StackMaster.stdout.puts "No changes"
+      else
+        StackMaster.stdout.puts
+        diff.each_line do |line|
+          if line.start_with?('+')
+            StackMaster.stdout.print colorize(line, :green)
+          elsif line.start_with?('-')
+            StackMaster.stdout.print colorize(line, :red)
+          else
+            StackMaster.stdout.print line
+          end
+        end
+      end
+    end
+
+    def sort_params(hash)
+      hash.sort.to_h
+    end
+
+    def colorize(text, color)
+      if colorize?
+        text.colorize(color)
+      else
+        text
+      end
+    end
+
+    def colorize?
+      ENV.fetch('COLORIZE') { 'true' } == 'true'
+    end
+  end
+end