stack_master 1.6.0-x64-mingw32

data/lib/stack_master/parameter_resolvers/ami_finder.rb

@@ -0,0 +1,36 @@
+module StackMaster
+  module ParameterResolvers
+    class AmiFinder
+      def initialize(region)
+        @region = region
+      end
+
+      def build_filters_from_string(value, prefix = nil)
+        filters = value.split(',').map do |name_with_value|
+          name, value = name_with_value.strip.split('=')
+          name = prefix ? "#{prefix}:#{name}" : name
+          { name: name, values: [value] }
+        end
+        filters
+      end
+
+      def build_filters_from_hash(hash)
+        hash.map { |key, value| {name: key, values: Array(value.to_s)}}
+      end
+
+      def find_latest_ami(filters, owners = ['self'])
+        images = ec2.describe_images(owners: owners, filters: filters).images
+        sorted_images = images.sort do |a, b|
+          Time.parse(a.creation_date) <=> Time.parse(b.creation_date)
+        end
+        sorted_images.last
+      end
+
+      private
+
+      def ec2
+        @ec2 ||= Aws::EC2::Client.new(region: @region)
+      end
+    end
+  end
+end

data/lib/stack_master/parameter_resolvers/env.rb

@@ -0,0 +1,18 @@
+module StackMaster
+  module ParameterResolvers
+    class Env < Resolver
+
+      def initialize(config, stack_definition)
+        @config = config
+        @stack_definition = stack_definition
+      end
+
+      def resolve(value)
+        environment_variable = ENV[value]
+        raise ArgumentError, "The environment variable #{value} is not set" if environment_variable.nil?
+        environment_variable
+      end
+
+    end
+  end
+end

data/lib/stack_master/parameter_resolvers/latest_ami.rb

@@ -0,0 +1,19 @@
+module StackMaster
+  module ParameterResolvers
+    class LatestAmi < Resolver
+      array_resolver class_name: 'LatestAmis'
+
+      def initialize(config, stack_definition)
+        @config = config
+        @stack_definition = stack_definition
+        @ami_finder = AmiFinder.new(@stack_definition.region)
+      end
+
+      def resolve(value)
+        owners = Array(value.fetch('owners', 'self').to_s)
+        filters = @ami_finder.build_filters_from_hash(value.fetch('filters'))
+        @ami_finder.find_latest_ami(filters, owners).try(:image_id)
+      end
+    end
+  end
+end

data/lib/stack_master/parameter_resolvers/latest_ami_by_tags.rb

@@ -0,0 +1,18 @@
+module StackMaster
+  module ParameterResolvers
+    class LatestAmiByTags < Resolver
+      array_resolver class_name: 'LatestAmisByTags'
+
+      def initialize(config, stack_definition)
+        @config = config
+        @stack_definition = stack_definition
+        @ami_finder = AmiFinder.new(@stack_definition.region)
+      end
+
+      def resolve(value)
+        filters = @ami_finder.build_filters_from_string(value, prefix = "tag")
+        @ami_finder.find_latest_ami(filters).try(:image_id)
+      end
+    end
+  end
+end

data/lib/stack_master/parameter_resolvers/parameter_store.rb

@@ -0,0 +1,31 @@
+module StackMaster
+  module ParameterResolvers
+    class ParameterStore < Resolver
+
+      ParameterNotFound = Class.new(StandardError)
+
+      def initialize(config, stack_definition)
+        @config = config
+        @stack_definition = stack_definition
+      end
+
+      def resolve(value)
+        begin
+          resp = ssm.get_parameter(
+            name: value,
+            with_decryption: true
+          )
+        rescue Aws::SSM::Errors::ParameterNotFound
+          raise ParameterNotFound, "Unable to find #{value} in Parameter Store"
+        end
+        resp.parameter.value
+      end
+
+      private
+
+      def ssm
+        @ssm ||= Aws::SSM::Client.new(region: @stack_definition.region)
+      end
+    end
+  end
+end

data/lib/stack_master/parameter_resolvers/secret.rb

@@ -0,0 +1,52 @@
+require 'os'
+
+module StackMaster
+  module ParameterResolvers
+    class Secret < Resolver
+      SecretNotFound = Class.new(StandardError)
+      PlatformNotSupported = Class.new(StandardError)
+
+      unless OS.windows?
+        require 'dotgpg'
+        array_resolver  
+      end
+
+      def initialize(config, stack_definition)
+        @config = config
+        @stack_definition = stack_definition
+      end
+
+      def resolve(value)
+        raise PlatformNotSupported, "The GPG Secret Parameter Resolver does not support Windows" if OS.windows?
+        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
+        Dotgpg.interactive = true
+        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,22 @@
+module StackMaster
+  module ParameterResolvers
+    class SecurityGroup < Resolver
+      array_resolver
+
+      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,31 @@
+module StackMaster
+  module ParameterResolvers
+    class SnsTopicName < Resolver
+      TopicNotFound = Class.new(StandardError)
+
+      array_resolver
+
+      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,76 @@
+module StackMaster
+  module ParameterResolvers
+    class StackOutput < Resolver
+      StackNotFound = Class.new(StandardError)
+      StackOutputNotFound = Class.new(StandardError)
+
+      array_resolver
+
+      def initialize(config, stack_definition)
+        @config = config
+        @stack_definition = stack_definition
+        @stacks = {}
+        @cf_drivers = {}
+        @output_regex = %r{(?:(?<region>[^:]+):)?(?<stack_name>[^:/]+)/(?<output_name>.+)}
+      end
+
+      def resolve(value)
+        region, stack_name, output_name = parse!(value)
+        stack = find_stack(stack_name, region)
+        if stack
+          output = stack.outputs.find { |stack_output| stack_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 parse!(value)
+        if !value.is_a?(String) || !(match = @output_regex.match(value))
+          raise ArgumentError, 'Stack output values must be in the form of [region:]stack-name/output_name'
+        end
+
+        [
+          match[:region] || cf.region,
+          match[:stack_name],
+          match[:output_name]
+        ]
+      end
+
+      def find_stack(stack_name, region)
+        unaliased_region = @config.unalias_region(region)
+        stack_key = stack_key(stack_name, unaliased_region)
+
+        @stacks.fetch(stack_key) do
+          regional_cf = cf_for_region(unaliased_region)
+          cf_stack = regional_cf.describe_stacks(stack_name: stack_name).stacks.first
+          @stacks[stack_key] = cf_stack
+        end
+      end
+
+      def stack_key(stack_name, region)
+        "#{region}:#{stack_name}"
+      end
+
+      def cf_for_region(region)
+        return cf if cf.region == region
+
+        @cf_drivers.fetch(region) do
+          cloud_formation_driver = cf.class.new
+          cloud_formation_driver.set_region(region)
+          @cf_drivers[region] = cloud_formation_driver
+        end
+      end
+    end
+  end
+end

data/lib/stack_master/prompter.rb

@@ -0,0 +1,21 @@
+module StackMaster
+  module Prompter
+    def ask?(question)
+      StackMaster.stdout.print question
+      answer = if StackMaster.interactive?
+        if StackMaster.stdin.tty? && StackMaster.stdout.tty?
+          StackMaster.stdin.getch.chomp
+        else
+          StackMaster.stdout.puts
+          StackMaster.stdout.puts "STDOUT or STDIN was not a TTY. Defaulting to no. To force yes use -y"
+          'n'
+        end
+      else
+        print StackMaster.non_interactive_answer
+        StackMaster.non_interactive_answer
+      end
+      StackMaster.stdout.puts
+      answer == 'y'
+    end
+  end
+end

data/lib/stack_master/resolver_array.rb

@@ -0,0 +1,35 @@
+module StackMaster
+  module ParameterResolvers
+    class ResolverArray
+      def initialize(config, stack_definition)
+        @config = config
+        @stack_definition = stack_definition
+      end
+
+      def resolve(values)
+        Array(values).map do |value|
+          resolver_class.new(@config, @stack_definition).resolve(value)
+        end.join(',')
+      end
+
+      def resolver_class
+        fail "Method resolver_class not implemented on #{self.class}"
+      end
+    end
+
+    class Resolver
+      def self.array_resolver(options = {})
+        resolver_class ||= Object.const_get(self.name)
+        array_resolver_class_name = options[:class_name] || resolver_class.to_s.demodulize.pluralize
+
+        klass = Class.new(ResolverArray) do
+          define_method('resolver_class') do
+            resolver_class
+          end
+        end
+        StackMaster::ParameterResolvers.const_set("#{array_resolver_class_name}", klass)
+      end
+    end
+  end
+end
+

data/lib/stack_master/security_group_finder.rb

@@ -0,0 +1,28 @@
+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)
+      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,26 @@
+module StackMaster
+  class SnsTopicFinder
+    TopicNotFound = Class.new(StandardError)
+
+    def initialize(region)
+      @resource = Aws::SNS::Resource.new(region: region)
+    end
+
+    def find(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/sparkle_formation/compile_time/allowed_pattern_validator.rb

@@ -0,0 +1,35 @@
+require_relative 'value_validator'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class AllowedPatternValidator < ValueValidator
+
+        KEY = :allowed_pattern
+
+        def initialize(name, definition, parameter)
+          @name = name
+          @definition = definition
+          @parameter = parameter
+        end
+
+        private
+
+        def check_is_valid
+          return true unless @definition.key?(KEY)
+          invalid_values.empty?
+        end
+
+        def invalid_values
+          values = build_values(@definition, @parameter)
+          values.reject { |value| value.to_s.match(%r{#{@definition[KEY]}}) }
+        end
+
+        def create_error
+          "#{@name}:#{invalid_values} does not match #{KEY}:#{@definition[KEY]}"
+        end
+
+      end
+    end
+  end
+end