stack_master 1.6.0-x64-mingw32

data/lib/stack_master/commands/list_stacks.rb

@@ -0,0 +1,20 @@
+require 'table_print'
+
+module StackMaster
+  module Commands
+    class ListStacks
+      include Command
+      include Commander::UI
+      include StackMaster::Commands::TerminalHelper
+
+      def initialize(config)
+        @config = config
+      end
+
+      def perform
+        tp.set :max_width, self.window_size
+        tp @config.stacks, :region, :stack_name
+      end
+    end
+  end
+end

data/lib/stack_master/commands/outputs.rb

@@ -0,0 +1,31 @@
+require 'table_print'
+
+module StackMaster
+  module Commands
+    class Outputs
+      include Command
+      include Commander::UI
+      include StackMaster::Commands::TerminalHelper
+
+      def initialize(config, stack_definition, options = {})
+        @config = config
+        @stack_definition = stack_definition
+      end
+
+      def perform
+        if stack
+          tp.set :max_width, self.window_size
+          tp stack.outputs, :output_key, :output_value, :description
+        else
+          StackMaster.stdout.puts "Stack doesn't exist"
+        end
+      end
+
+      private
+
+      def stack
+        @stack ||= Stack.find(@stack_definition.region, @stack_definition.stack_name)
+      end
+    end
+  end
+end

data/lib/stack_master/commands/resources.rb

@@ -0,0 +1,33 @@
+module StackMaster
+  module Commands
+    class Resources
+      include Command
+      include Commander::UI
+
+      def initialize(config, stack_definition, options = {})
+        @config = config
+        @stack_definition = stack_definition
+      end
+
+      def perform
+        if stack_resources
+          tp stack_resources, :logical_resource_id, :resource_type, :timestamp, :resource_status, :resource_status_reason, :description
+        else
+          StackMaster.stdout.puts "Stack doesn't exist"
+        end
+      end
+
+      private
+
+      def stack_resources
+        @stack_resources = cf.describe_stack_resources(stack_name: @stack_definition.stack_name).stack_resources
+      rescue Aws::CloudFormation::Errors::ValidationError
+        nil
+      end
+
+      def cf
+        @cf ||= StackMaster.cloud_formation_driver
+      end
+    end
+  end
+end

data/lib/stack_master/commands/status.rb

@@ -0,0 +1,46 @@
+require 'table_print'
+require 'ruby-progressbar'
+
+module StackMaster
+  module Commands
+    class Status
+      include Command
+      include StackMaster::Commands::TerminalHelper
+
+      def initialize(config, show_progress = true)
+        @config = config
+        @show_progress = show_progress
+      end
+
+      def perform
+        progress if @show_progress
+        status = @config.stacks.map do |stack_definition|
+          stack_status = StackStatus.new(@config, stack_definition)
+          progress.increment if @show_progress
+          {
+            region: stack_definition.region,
+            stack_name: stack_definition.stack_name,
+            stack_status: stack_status.status,
+            different: stack_status.changed_message,
+          }
+        end
+        tp.set :max_width, self.window_size
+        tp.set :io, StackMaster.stdout
+        tp status
+        StackMaster.stdout.puts " * No echo parameters can't be diffed"
+      end
+
+      private
+
+      def progress
+        @progress ||= ProgressBar.create(title: "Fetching stack information",
+                                         total: @config.stacks.size,
+                                         output: StackMaster.stdout)
+      end
+
+      def sort_params(hash)
+        hash.sort.to_h
+      end
+    end
+  end
+end

data/lib/stack_master/commands/terminal_helper.rb

@@ -0,0 +1,28 @@
+require 'os'
+
+module StackMaster
+  module Commands
+    module TerminalHelper
+      def window_size
+        size = ENV.fetch("COLUMNS") { OS.windows? ? windows_window_size : unix_window_size }
+
+        if size.nil? || size == ""
+          80
+        else
+          size.to_i
+        end
+      end
+
+      def unix_window_size
+        `tput cols`.chomp
+      end
+
+      def windows_window_size
+        columns_regex = %r{^\s+Columns:\s+([0-9]+)$}
+        output = `mode con`
+        columns_line = output.split("\n").select { |line| line.match(columns_regex) }.last
+        columns_line.match(columns_regex)[1]
+      end
+    end
+  end
+end

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, options = {})
+        @config = config
+        @stack_definition = stack_definition
+      end
+
+      def perform
+        failed unless Validator.valid?(@stack_definition, @config)
+      end
+    end
+  end
+end

data/lib/stack_master/config.rb

@@ -0,0 +1,133 @@
+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')
+      resolved_config_file = search_up_and_chdir(config_file)
+      config = YAML.load(File.read(resolved_config_file))
+      base_dir = File.dirname(File.expand_path(resolved_config_file))
+      new(config, base_dir)
+    end
+
+    attr_accessor :stacks,
+                  :base_dir,
+                  :template_dir,
+                  :stack_defaults,
+                  :region_defaults,
+                  :region_aliases,
+                  :template_compilers,
+
+    def self.search_up_and_chdir(config_file)
+      return config_file unless File.dirname(config_file) == "."
+
+      dir = Dir.pwd
+      parent_dir = File.expand_path("..", Dir.pwd)
+      while parent_dir != dir && !File.exists?(File.join(dir, config_file))
+        dir = parent_dir
+        parent_dir = File.expand_path("..", dir)
+      end
+
+      File.join(dir, config_file)
+    end
+
+    def initialize(config, base_dir)
+      @config = config
+      @base_dir = base_dir
+      @template_dir = config.fetch('template_dir', nil)
+      @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_template_compilers(config)
+      load_config
+    end
+
+    def filter(region = nil, stack_name = nil)
+      @stacks.select do |s|
+        (region.blank? || s.region == region || s.region == region.gsub('_', '-')) &&
+          (stack_name.blank? || s.stack_name == stack_name || s.stack_name == stack_name.gsub('_', '-'))
+      end
+    end
+
+    def find_stack(region, stack_name)
+      filter(region, stack_name).first
+    end
+
+    def unalias_region(region)
+      @region_aliases.fetch(region) { region }
+    end
+
+    private
+    def load_template_compilers(config)
+      @template_compilers = {}
+      populate_template_compilers(config.fetch('template_compilers', {}))
+      merge_defaults_to_user_defined_compilers
+    end
+
+    def merge_defaults_to_user_defined_compilers
+      @template_compilers = default_template_compilers.merge(@template_compilers)
+    end
+
+    def populate_template_compilers user_defined_compilers
+      user_defined_compilers.each do |key, val|
+        @template_compilers[key.to_sym] = val.to_sym
+      end
+    end
+
+    def default_template_compilers
+      {
+        rb: :sparkle_formation,
+        json: :json,
+        yml:  :yaml,
+        yaml: :yaml,
+      }
+    end
+
+    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,
+            'template_dir' => @template_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/paged_response_accumulator.rb

@@ -0,0 +1,29 @@
+module StackMaster
+  class PagedResponseAccumulator
+    def self.call(*args)
+      new(*args).call
+    end
+
+    def initialize(cf, method, arguments, accumulator_method)
+      @cf = cf
+      @method = method
+      @arguments = arguments
+      @accumulator_method = accumulator_method
+    end
+
+    def call
+      book = []
+      next_token = nil
+      first_response = nil
+      begin
+        response = @cf.public_send(@method, @arguments.merge(next_token: next_token))
+        first_response = response if first_response.nil?
+        next_token = response.next_token
+        book += response.public_send(@accumulator_method)
+      end while !next_token.nil?
+      first_response.send("#{@accumulator_method}=", book.reverse)
+      first_response.send(:next_token=, book.reverse)
+      first_response
+    end
+  end
+end

data/lib/stack_master/parameter_loader.rb

@@ -0,0 +1,49 @@
+require 'active_support/core_ext/object/deep_dup'
+
+module StackMaster
+  class ParameterLoader
+
+    COMPILE_TIME_PARAMETERS_KEY = 'compile_time_parameters'
+
+    def self.load(parameter_files)
+      StackMaster.debug 'Searching for parameter files...'
+      parameter_files.reduce({template_parameters: {}, compile_time_parameters: {}}) do |hash, file_name|
+        parameters = load_parameters(file_name)
+        template_parameters = create_template_parameters(parameters)
+        compile_time_parameters = create_compile_time_parameters(parameters)
+
+        merge_and_camelize(hash[:template_parameters], template_parameters)
+        merge_and_camelize(hash[:compile_time_parameters], compile_time_parameters)
+        hash
+      end
+
+    end
+
+    private
+
+    def self.load_parameters(file_name)
+      file_exists = File.exists?(file_name)
+      StackMaster.debug file_exists ? "  #{file_name} found" : "  #{file_name} not found"
+      file_exists ? load_file(file_name) : {}
+    end
+
+    def self.load_file(file_name)
+      YAML.load(File.read(file_name)) || {}
+    end
+
+    def self.create_template_parameters(parameters)
+      parameters.deep_dup.tap do |parameters_clone|
+        parameters_clone.delete(COMPILE_TIME_PARAMETERS_KEY) || parameters_clone.delete(COMPILE_TIME_PARAMETERS_KEY.camelize)
+      end
+    end
+
+    def self.create_compile_time_parameters(parameters)
+      (parameters[COMPILE_TIME_PARAMETERS_KEY] || parameters[COMPILE_TIME_PARAMETERS_KEY.camelize] || {}).deep_dup
+    end
+
+    def self.merge_and_camelize(hash, parameters)
+      parameters.each { |key, value| hash[key.camelize] = value }
+    end
+
+  end
+end

data/lib/stack_master/parameter_resolver.rb

@@ -0,0 +1,98 @@
+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)|
+        begin
+          parameters[key] = resolve_parameter_value(key, value)
+        rescue InvalidParameter
+          raise InvalidParameter, "Unable to resolve parameter #{key.inspect} value causing error: #{$!.message}"
+        end
+        parameters
+      end
+    end
+
+    private
+
+    def require_parameter_resolver(file_name)
+      require "stack_master/parameter_resolvers/#{file_name}"
+    rescue LoadError
+      if file_name == file_name.singularize
+        raise ResolverNotFound.new(file_name)
+      else
+        require_parameter_resolver(file_name.singularize)
+      end
+    end
+
+    def load_parameter_resolver(class_name)
+      # Check if the class name already exists
+      resolver_class_const(class_name)
+    rescue NameError
+      # If it doesn't, try to load it
+      require_parameter_resolver(class_name.underscore)
+    end
+
+    def resolve_parameter_value(key, parameter_value)
+      return parameter_value.to_s if Numeric === parameter_value || parameter_value == true || parameter_value == false
+      return resolve_array_parameter_values(key, parameter_value).join(',') if Array === parameter_value
+      return parameter_value unless Hash === parameter_value
+      validate_parameter_value!(key, parameter_value)
+
+      resolver_name = parameter_value.keys.first.to_s
+      load_parameter_resolver(resolver_name)
+
+      value = parameter_value.values.first
+      resolver_class_name = resolver_name.camelize
+      call_resolver(resolver_class_name, value)
+    rescue Aws::CloudFormation::Errors::ValidationError
+      raise InvalidParameter, $!.message
+    end
+
+    def resolve_array_parameter_values(key, parameter_values)
+      parameter_values.reduce([]) do |values, parameter_value|
+        values << resolve_parameter_value(key, parameter_value)
+      end
+    end
+
+    def call_resolver(class_name, value)
+      resolver_class(class_name).resolve(value)
+    end
+
+    def resolver_class_name(class_name)
+      "StackMaster::ParameterResolvers::#{class_name.camelize}"
+    end
+
+    def resolver_class_const(class_name)
+      Kernel.const_get(resolver_class_name(class_name))
+    end
+
+    def resolver_class(class_name)
+      @resolvers.fetch(class_name) do
+        begin
+          @resolvers[class_name] = resolver_class_const(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
+
+    def validate_parameter_value!(key, parameter_value)
+      if parameter_value.keys.size != 1
+        raise InvalidParameter, "#{key} hash contained more than one key: #{parameter_value.inspect}"
+      end
+    end
+  end
+end