stack_master 0.17.0 → 0.18.0

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

@@ -0,0 +1,36 @@
+require_relative 'value_validator'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class MinSizeValidator < ValueValidator
+
+        KEY = :min_size
+
+        def initialize(name, definition, parameter)
+          @name = name
+          @definition = definition
+          @parameter = parameter
+        end
+
+        private
+
+        def check_is_valid
+          return true unless @definition[:type] == :number
+          return true unless @definition.key?(KEY)
+          invalid_values.empty?
+        end
+
+        def invalid_values
+          values = build_values(@definition, @parameter)
+          values.select { |value| value.to_f < @definition[KEY].to_f}
+        end
+
+        def create_error
+          "#{@name}:#{invalid_values} must not be lesser than #{KEY}:#{@definition[KEY]}"
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require_relative 'value_validator'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class NumberValidator < ValueValidator
+
+        def initialize(name, definition, parameter)
+          @name = name
+          @definition = definition
+          @parameter = parameter
+        end
+
+        private
+
+        def check_is_valid
+          return true unless @definition[:type] == :number
+          invalid_values.empty?
+        end
+
+        def invalid_values
+          values = build_values(@definition, @parameter)
+          values.reject do |value|
+            value.is_a?(Numeric) || value.is_a?(String) && value.to_s =~ /^(\d+)(\.?(\d+))?$/
+          end
+        end
+
+        def create_error
+          "#{@name}:#{invalid_values} are not Numbers"
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require_relative 'value_validator_factory'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class ParametersValidator
+
+        def initialize(definitions, parameters)
+          @definitions = definitions
+          @parameters = parameters
+        end
+
+        def validate
+          @definitions.each do |name, definition|
+            parameter = @parameters[name.to_s.camelize]
+            factory = ValueValidatorFactory.new(name, definition, parameter)
+            value_validators = factory.build
+            value_validators.each do |validator|
+              validator.validate
+              raise ArgumentError.new "Invalid compile time parameter: #{validator.error}" unless validator.is_valid
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require_relative 'value_builder'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class StateBuilder
+
+        def initialize(definitions, parameters)
+          @definitions = definitions
+          @parameters = parameters
+        end
+
+        def build
+          state = {}
+          @definitions.each do |name, definition|
+            parameter_key = name.to_s.camelize
+            parameter = @parameters[parameter_key]
+            state[name] = create_value(definition, parameter)
+          end
+          state
+        end
+
+        private
+
+        def create_value(definition, parameter)
+          ValueBuilder.new(definition, parameter).build
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require_relative 'value_validator'
+
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class StringValidator < ValueValidator
+
+        def initialize(name, definition, parameter)
+          @name = name
+          @definition = definition
+          @parameter = parameter
+        end
+
+        private
+
+        def check_is_valid
+          return true unless @definition[:type] == :string
+          invalid_values.empty?
+        end
+
+        def invalid_values
+          values = build_values(@definition, @parameter)
+          values.reject { |value| value.is_a?(String)}
+        end
+
+        def create_error
+          "#{@name}:#{invalid_values} are not Strings"
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class ValueBuilder
+
+        def initialize(definition, parameter)
+          @definition = definition
+          @parameter = parameter
+        end
+
+        def build
+          parameter_or_default
+          convert_strings_to_array
+          convert_strings_to_numbers
+          @value
+        end
+
+        private
+
+        def parameter_or_default
+          @value = @parameter.nil? ? @definition[:default] : @parameter
+        end
+
+        def convert_strings_to_array
+          if @definition[:multiple] && @value.is_a?(String)
+            @value = @value.split(',').map(&:strip)
+          end
+        end
+
+        def convert_strings_to_numbers
+          if @definition[:type] == :number
+            @value = @value.to_f if @value.is_a?(String)
+            @value = @value.map { |item| item.is_a?(String) ? item.to_f : item } if @value.is_a?(Array)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module StackMaster
+  module SparkleFormation
+    module CompileTime
+      class ValueValidator
+
+        attr_reader :is_valid, :error
+
+        def validate
+          @is_valid = check_is_valid
+          @error = create_error unless @is_valid
+        end
+
+        protected
+
+        def check_is_valid
+          raise NotImplementedError
+        end
+
+        def create_error
+          raise NotImplementedError
+        end
+
+        def build_values(definition, parameter)
+          parameter_or_default = parameter.nil? ? definition[:default] : parameter
+          convert_to_array(definition, parameter_or_default)
+        end
+
+        private
+
+        def convert_to_array(definition, parameter)
+          if definition[:multiple] && parameter.is_a?(String)
+            return parameter.split(',').map(&:strip)
+          end
+          parameter.is_a?(Array) ? parameter : [parameter]
+        end
+
+      end
+    end
+  end
+end

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/stack.rb

@@ -63,16 +63,17 @@ module StackMaster
 
     def self.generate(stack_definition, config)
       parameter_hash = ParameterLoader.load(stack_definition.parameter_files)
-      template_body = TemplateCompiler.compile(config, stack_definition.template_file_path, stack_definition.compiler_options)
+      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)
-      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,
+          parameters: template_parameters,
           template_body: template_body,
           template_format: template_format,
           role_arn: stack_definition.role_arn,

data/lib/stack_master/template_compiler.rb

@@ -2,10 +2,10 @@ module StackMaster
   class TemplateCompiler
     TemplateCompilationFailed = Class.new(RuntimeError)
 
-    def self.compile(config, template_file_path, compiler_options = {})
+    def self.compile(config, template_file_path, compile_time_parameters, compiler_options = {})
       compiler = template_compiler_for_file(template_file_path, config)
       compiler.require_dependencies
-      compiler.compile(template_file_path, compiler_options)
+      compiler.compile(template_file_path, compile_time_parameters, compiler_options)
     rescue
       raise TemplateCompilationFailed.new("Failed to compile #{template_file_path}.")
     end

data/lib/stack_master/template_compilers/cfndsl.rb

@@ -4,7 +4,7 @@ module StackMaster::TemplateCompilers
       require 'cfndsl'
     end
 
-    def self.compile(template_file_path, compiler_options = {})
+    def self.compile(template_file_path, _compile_time_parameters, _compiler_options = {})
       ::CfnDsl.eval_file_with_extras(template_file_path).to_json
     end
 

data/lib/stack_master/template_compilers/json.rb

@@ -7,7 +7,7 @@ module StackMaster::TemplateCompilers
       require 'json'
     end
 
-    def self.compile(template_file_path, compiler_options = {})
+    def self.compile(template_file_path, _compile_time_parameters, _compiler_options = {})
       template_body = File.read(template_file_path)
       if template_body.size > MAX_TEMPLATE_SIZE
         # Parse the json and rewrite compressed

data/lib/stack_master/template_compilers/sparkle_formation.rb

@@ -1,18 +1,47 @@
+require 'stack_master/sparkle_formation/compile_time/parameters_validator'
+require 'stack_master/sparkle_formation/compile_time/definitions_validator'
+require 'stack_master/sparkle_formation/compile_time/state_builder'
+
 module StackMaster::TemplateCompilers
   class SparkleFormation
+
+    CompileTime = StackMaster::SparkleFormation::CompileTime
+
     def self.require_dependencies
       require 'sparkle_formation'
       require 'stack_master/sparkle_formation/template_file'
     end
 
-    def self.compile(template_file_path, compiler_options = {})
-      if compiler_options["sparkle_path"]
-        ::SparkleFormation.sparkle_path = File.expand_path(compiler_options["sparkle_path"])
+    def self.compile(template_file_path, compile_time_parameters, compiler_options = {})
+      if compiler_options['sparkle_path']
+        ::SparkleFormation.sparkle_path = File.expand_path(compiler_options['sparkle_path'])
       else
         ::SparkleFormation.sparkle_path = File.dirname(template_file_path)
       end
+      sparkle_template = ::SparkleFormation.compile(template_file_path, :sparkle)
+      definitions = sparkle_template.parameters
+      validate_definitions(definitions)
+      validate_parameters(definitions, compile_time_parameters)
+
+      sparkle_template.compile_time_parameter_setter do
+        sparkle_template.compile_state = create_state(definitions, compile_time_parameters)
+      end
+
+      JSON.pretty_generate(sparkle_template)
+    end
+
+    private
+
+    def self.validate_definitions(definitions)
+      CompileTime::DefinitionsValidator.new(definitions).validate
+    end
+
+    def self.validate_parameters(definitions, compile_time_parameters)
+      CompileTime::ParametersValidator.new(definitions, compile_time_parameters).validate
+    end
 
-      JSON.pretty_generate(::SparkleFormation.compile(template_file_path))
+    def self.create_state(definitions, compile_time_parameters)
+      CompileTime::StateBuilder.new(definitions, compile_time_parameters).build
     end
 
     StackMaster::TemplateCompiler.register(:sparkle_formation, self)

data/lib/stack_master/template_compilers/yaml.rb

@@ -5,7 +5,7 @@ module StackMaster::TemplateCompilers
       require 'json'
     end
 
-    def self.compile(template_file_path, compiler_options = {})
+    def self.compile(template_file_path, _compile_time_parameters, _compiler_options = {})
       File.read(template_file_path)
     end
 

data/lib/stack_master/validator.rb

@@ -10,8 +10,11 @@ module StackMaster
     end
 
     def perform
+      parameter_hash = ParameterLoader.load(@stack_definition.parameter_files)
+      compile_time_parameters = ParameterResolver.resolve(@config, @stack_definition, parameter_hash[:compile_time_parameters])
+
       StackMaster.stdout.print "#{@stack_definition.stack_name}: "
-      template_body = TemplateCompiler.compile(@config, @stack_definition.template_file_path, @stack_definition.compiler_options)
+      template_body = TemplateCompiler.compile(@config, @stack_definition.template_file_path, compile_time_parameters, @stack_definition.compiler_options)
       cf.validate_template(template_body: TemplateUtils.maybe_compressed_template_body(template_body))
       StackMaster.stdout.puts "valid"
       true

data/lib/stack_master/version.rb

@@ -1,3 +1,3 @@
 module StackMaster
-  VERSION = "0.17.0"
+  VERSION = "0.18.0"
 end

data/spec/spec_helper.rb

@@ -1,6 +1,9 @@
 require 'stack_master'
 require 'timecop'
 require 'pry'
+
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f }
+
 Aws.config[:stub_responses] = true
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.