aws-cfn-stacker 0.0.5 → 0.0.6

data/db/seeds.rb

@@ -0,0 +1,7 @@
+# This file should contain all the record creation needed to seed the database with its default values.
+# The data can then be loaded with the rake db:seed (or created alongside the db with db:setup).
+#
+# Examples:
+#
+#   cities = City.create([{ name: 'Chicago' }, { name: 'Copenhagen' }])
+#   Mayor.create(name: 'Emanuel', city: cities.first)

data/lib/aws/cfn/stacker.rb

@@ -1,5 +1,6 @@
 # Setup
 %w(Patches Errors Prerequisites ).each { |m|
+  # noinspection RubyResolve
   require "aws/cfn/stacker/mixins/#{m.downcase}"
   eval "include Aws::Cfn::Stacker::#{m}"
 }
@@ -7,16 +8,14 @@
 checkOS()
 checkRuby()
 
-require "aws/cfn/stacker/version"
-require "aws/cfn/stacker/base"
+require 'aws/cfn/stacker/version'
+require 'aws/cfn/stacker/base'
 
 module Aws
   module Cfn
     module Stacker
-      # noinspection RubyTooManyInstanceVariablesInspection,RubyTooManyMethodsInspection
-      class Application
-        require 'dldinternet/mixlib/cli'
-        include ::DLDInternet::Mixlib::CLI
+      # noinspection RubyTooManyInstanceVariablesInspection,RubyTooManyMethodsInspection,RubyResolve
+      class StackerApplication < StackerBase
 
         %w(Main Options Logging).each { |m|
           require "aws/cfn/stacker/mixins/#{m.downcase}"

data/lib/aws/cfn/stacker/base.rb

@@ -1,9 +1,206 @@
 require "aws/cfn/stacker/version"
+require 'aws/cfn/stacker/subcommand_loader'
+require 'aws/cfn/stacker/mixins/convert_to_class_name'
+require 'mixlib/cli'
 
 module Aws
   module Cfn
     module Stacker
-      class Base
+      class StackerBase
+
+        include ::Mixlib::CLI
+
+        extend Aws::Cfn::Stacker::ConvertToClassName
+
+        # ClassMethods
+        class << self
+          include ::Mixlib::CLI::ClassMethods
+
+          # noinspection RubyClassVariableUsageInspection
+          def self.reset_config_path!
+            @@stacker_config_dir = nil
+          end
+
+          reset_config_path!
+          # search upward from current_dir until .chef directory is found
+          # noinspection RubyClassVariableUsageInspection
+          def stacker_config_dir
+            if @@stacker_config_dir.nil? # share this with subclasses
+              @@stacker_config_dir = false
+              full_path = Dir.pwd.split(File::SEPARATOR)
+              (full_path.length - 1).downto(0) do |i|
+                candidate_directory = File.join(full_path[0..i] + ["config" ])
+                if File.exist?(candidate_directory) && File.directory?(candidate_directory)
+                  @@stacker_config_dir = candidate_directory
+                  break
+                end
+              end
+            end
+            @@stacker_config_dir
+          end
+          
+          def reset_subcommands!
+            @subcommands = {}
+            @subcommands_by_category = nil
+          end
+
+          def inherited(subclass)
+            unless subclass.unnamed?
+              subcommands[subclass.snake_case_name] = subclass
+            end
+          end
+
+          # Explicitly set the category for the current command to +new_category+
+          # The category is normally determined from the first word of the command
+          # name, but some commands make more sense using two or more words
+          # ===Arguments
+          # new_category::: A String to set the category to (see examples)
+          # ===Examples:
+          # Data bag commands would be in the 'data' category by default. To put them
+          # in the 'data bag' category:
+          #   category('data bag')
+          def category(new_category)
+            @category = new_category
+          end
+
+          def subcommand_category
+            @category || snake_case_name.split('_').first unless unnamed?
+          end
+
+          def snake_case_name
+            convert_to_snake_case(name.split('::').last) unless unnamed?
+          end
+
+          def common_name
+            snake_case_name.split('_').join(' ')
+          end
+
+          # Does this class have a name? (Classes created via Class.new don't)
+          def unnamed?
+            name.nil? || name.empty?
+          end
+
+          def subcommand_loader
+            @subcommand_loader ||= SubcommandLoader.new(stacker_config_dir)
+          end
+
+          def load_commands
+            @commands_loaded ||= subcommand_loader.load_commands
+          end
+
+          def subcommands
+            @@subcommands ||= {}
+          end
+
+          def subcommands_by_category
+            unless @subcommands_by_category
+              @subcommands_by_category = Hash.new { |hash, key| hash[key] = [] }
+              subcommands.each do |snake_cased, klass|
+                @subcommands_by_category[klass.subcommand_category] << snake_cased
+              end
+            end
+            @subcommands_by_category
+          end
+
+          # Print the list of subcommands knife knows about. If +preferred_category+
+          # is given, only subcommands in that category are shown
+          def list_commands(preferred_category=nil)
+            load_commands
+
+            category_desc = preferred_category ? preferred_category + " " : ''
+            puts "Available #{category_desc}subcommands: (for details, #{@stacker_cmd} SUB-COMMAND --help)\n\n"
+
+            if preferred_category && subcommands_by_category.key?(preferred_category)
+              commands_to_show = {preferred_category => subcommands_by_category[preferred_category]}
+            else
+              commands_to_show = subcommands_by_category
+            end
+
+            commands_to_show.sort.each do |category, commands|
+              next if category =~ /deprecated/i
+              puts "** #{category.upcase} COMMANDS **"
+              commands.sort.each do |command|
+                puts subcommands[command].banner if subcommands[command]
+              end
+              puts
+            end
+          end
+
+          def dependency_loaders
+            @dependency_loaders ||= []
+          end
+
+          def requires(&block)
+            dependency_loaders << block
+          end
+
+          def load_deps
+            dependency_loaders.each do |dep_loader|
+              dep_loader.call
+            end
+          end
+
+          def subcommand_class_from(args)
+            command_words = args.select {|arg| arg =~ /^(([[:alnum:]])[[:alnum:]\_\-]+)$/ }
+
+            subcommand_class = nil
+
+            while ( !subcommand_class ) && ( !command_words.empty? )
+              snake_case_class_name = command_words.join("_")
+              subcommand_class = subcommands[snake_case_class_name]
+              unless subcommand_class
+                command_words.pop
+              end
+            end
+            # see if we got the command as e.g., knife node-list
+            subcommand_class ||= subcommands[args.first.gsub('-', '_')]
+            subcommand_class || subcommand_not_found!(args)
+          end
+
+          # :nodoc:
+          # Error out and print usage. probably becuase the arguments given by the
+          # user could not be resolved to a subcommand.
+          def subcommand_not_found!(args)
+            puts "Cannot find sub command for: '#{args.join(' ')}'"
+
+            if category_commands = guess_category(args)
+              list_commands(category_commands)
+            else
+              list_commands
+            end
+
+            exit 10
+          end
+
+          def guess_category(args)
+            category_words = args.select {|arg| arg =~ /^(([[:alnum:]])[[:alnum:]\_\-]+)$/ }
+            category_words.map! {|w| w.split('-')}.flatten!
+            matching_category = nil
+            while (!matching_category) && (!category_words.empty?)
+              candidate_category = category_words.join(' ')
+              matching_category = candidate_category if subcommands_by_category.key?(candidate_category)
+              matching_category || category_words.pop
+            end
+            matching_category
+          end
+
+          attr_accessor :stacker_cmd
+          def cmd=(cmd)
+            @stacker_cmd = cmd
+          end
+
+        end # ClassMethods
+
+        # Called prior to starting the application, by the run method
+        def setup_application
+          logger.warn "#{self.to_s}: you must override setup_application"
+        end
+
+        # Actually run the application
+        def run_application
+          logger.warn "#{self.to_s}: you must override run_application"
+        end
+
       end
     end
   end

data/lib/aws/cfn/stacker/commands/list_params.rb

@@ -0,0 +1,5 @@
+module Aws::Cfn::Stacker
+  class ListParams < StackerApplication
+    include Options
+  end
+end

data/lib/aws/cfn/stacker/mixins/convert_to_class_name.rb

@@ -0,0 +1,44 @@
+module Aws::Cfn::Stacker
+  module ConvertToClassName
+    extend self
+
+    def convert_to_class_name(str)
+      str = str.dup
+      str.gsub!(/[^A-Za-z0-9_]/,'_')
+      rname = nil
+      regexp = %r{^(.+?)(_(.+))?$}
+
+      mn = str.match(regexp)
+      if mn
+        rname = mn[1].capitalize
+
+        while mn && mn[3]
+          mn = mn[3].match(regexp)
+          rname << mn[1].capitalize if mn
+        end
+      end
+
+      rname
+    end
+
+    def convert_to_snake_case(str, namespace=nil)
+      str = str.dup
+      str.sub!(/^#{namespace}(\:\:)?/, '') if namespace
+      str.gsub!(/[A-Z]/) {|s| "_" + s}
+      str.downcase!
+      str.sub!(/^\_/, "")
+      str
+    end
+
+    def snake_case_basename(str)
+      with_namespace = convert_to_snake_case(str)
+      with_namespace.split("::").last.sub(/^_/, '')
+    end
+
+    def filename_to_qualified_string(base, filename)
+      file_base = File.basename(filename, ".rb")
+      base.to_s + (file_base == 'default' ? '' : "_#{file_base}")
+    end
+
+  end
+end

data/lib/aws/cfn/stacker/mixins/main.rb

@@ -1,7 +1,3 @@
-require 'colorize'
-require 'inifile'
-require 'awesome_print'
-
 module Aws
   module Cfn
     module Stacker
@@ -9,12 +5,12 @@ module Aws
       module Main
 
         # --------------------------------------------------------------------------------------------------------------
-        MY_NAME = "cfn-stacker"
-        NO_COMMAND_GIVEN = "You need to pass a sub-command (e.g., #{MY_NAME} SUB-COMMAND or #{MY_NAME} -a|--action SUB-COMMAND)\n"
+        @MY_NAME = "cfn-stacker"
+        @NO_COMMAND_GIVEN = "You need to pass a sub-command (e.g., #{@MY_NAME} SUB-COMMAND or #{@MY_NAME} -a|--action SUB-COMMAND)\n"
 
         # --------------------------------------------------------------------------------------------------------------
         attr_accessor :logger
-        attr_accessor :verbosity
+        attr_accessor :actors
         attr_accessor :LOGLEVELS
         attr_accessor :ALLACTIONS
         # --------------------------------------------------------------------------------------------------------------
@@ -22,6 +18,14 @@ module Aws
         # --------------------------------------------------------------------------------------------------------------
         module ClassMethods
 
+          def actors
+            @ACTORS
+          end
+
+          def actors=(v)
+          @ACTORS  = v
+          end
+
           def loglevels
             @LOGLEVELS
           end
@@ -38,32 +42,39 @@ module Aws
             @ALLACTIONS = acts || [ :build, :configure, :create, :status, :update, :delete, :outputs, :watch, :listparams ]
           end
 
-
         end
 
         # --------------------------------------------------------------------------------------------------------------
         def self.included(includer)
           includer.extend(ClassMethods)
           includer.class_eval do
+            requires do
+              require 'colorize'
+              require 'inifile'
+              require 'awesome_print'
+            end
+
+            self.actors     = {}
             self.loglevels  = [:trace, :debug, :step, :info, :warn, :error, :fatal, :todo]
-            self.allactions = [ :build, :configure, :create, :status, :update, :delete, :outputs, :watch, :listparams ]
+            self.allactions = [ :build, :configure, :create, :status, :update, :delete, :outputs, :watch, :list_params, :list_stacks ]
           end
         end
 
         # --------------------------------------------------------------------------------
         # Create a new instance of the current class configured for the given
         # arguments and options
-        def initialize
+        def initialize()
           $STKR           = self
           @TODO           = {}
           @defaultOptions = {}
-
+          @inis           = []
           super
         end
 
         # -----------------------------------------------------------------------------
         def run(argv)
           begin
+            StackerApplication.load_commands
             @argv           = argv
             prescreen_options()
             quiet_traps()
@@ -74,7 +85,7 @@ module Aws
             exit 0
           rescue StackerError => e
             puts e.message.light_red
-            puts "#{__FILE__}::#{__LINE__} reraising ... "
+            puts "#{__FILE__}:#{__LINE__} reraising ... "
             raise e
             exit -1
           end
@@ -133,7 +144,7 @@ module Aws
           defaults={
               disable_rollback: true,
               template_dir:   File.join(cwd, 'templates'),
-              stack_dir:      File.join(File.dirname(@options[:config_file]), 'stacks'),
+              stack_dir:      File.join(File.dirname(@config[:config_file]), 'stacks'),
               playbooks_dir:  File.join(cwd, 'ansible', 'playbooks')
           }
           #config = ConfigParser.ConfigParser(
@@ -162,12 +173,11 @@ module Aws
         end
 
         def configure_logging
-          super
           @config[:log_opts] = lambda{|mlll| {
-              :pattern      => "%#{mlll}l: %m %C\n",
-              :date_pattern => '%Y-%m-%d %H:%M:%S',
-          }
-          }
+                                                :pattern      => "%#{mlll}l: %m %C\n",
+                                                :date_pattern => '%Y-%m-%d %H:%M:%S',
+                                              }
+                                      }
 
           @logger = getLogger(@config)
         end
@@ -175,17 +185,6 @@ module Aws
         def configure_stdout_logger
         end
 
-        # Called prior to starting the application, by the run method
-        def setup_application
-          raise ApplicationError, "#{self.to_s}: you must override setup_application"
-        end
-
-        # Actually run the application
-        def run_application
-          raise ApplicationError, "#{self.to_s}: you must override run_application"
-        end
-
-
       end
     end
   end

data/lib/aws/cfn/stacker/mixins/options.rb

@@ -1,10 +1,14 @@
+require 'awesome_print'
+require 'inifile'
+require 'colorize'
 
 module Aws
   module Cfn
     module Stacker
-
       module Options
-        include ::DLDInternet::Mixlib::CLI
+
+        require 'dldinternet/mixlib/cli/mixins/parsers'
+        include ::DLDInternet::Mixlib::CLI::Parsers
 
         # --------------------------------------------------------------------------------
         #
@@ -20,17 +24,29 @@ module Aws
 
           prescreen_options(argv)
 
-          @config = parse_and_validate_options(@config,source ? source : "ARGV - #{__LINE__}")
+          @config = parse_and_validate_options(@config,source ? source : "ARGV - #{File.basename __FILE__}::#{__LINE__}")
 
-          unless @config[:actions]
-            @config[:actions] = [ argv[1].to_sym ]
+          if argv.size > 0
+            argv.each { |arg|
+              action = parseOptionString(arg, ',', 'parseActionSymbol')
+              if action
+                @config[:actions] << action
+              end
+            }
           end
-          @actors[argv[1].to_sym] = self
-          others = @config[:actions].select{|a|
-            a != argv[1].to_sym
+          actions = Hash[@config[:actions].flatten.map{ |v| [v, 1] }]
+          @config[:actions] = actions.keys
+          @config[:actions].each {|action|
+            unless StackerApplication.actors[action]
+              subcommand_class = StackerApplication.subcommand_class_from([action.to_s])
+              subcommand_class.load_deps
+              instance = subcommand_class.new()
+              StackerApplication.actors[action] = instance
+              instance.configure_application
+            end
           }
-          index   = args.index '--action'
           argv
+
         end
 
         # --------------------------------------------------------------------------------------------------------------
@@ -41,12 +57,12 @@ module Aws
           # Checking ARGV validity *before* parse_options because parse_options
           # mangles ARGV in some situations
           if no_command_given?
-            print_help_and_exit(1, NO_COMMAND_GIVEN)
+            print_help_and_exit(1, @NO_COMMAND_GIVEN)
           elsif no_subcommand_given?
             if want_help? || want_version?
               print_help_and_exit
             else
-              print_help_and_exit(2, NO_COMMAND_GIVEN)
+              print_help_and_exit(2, @NO_COMMAND_GIVEN)
             end
           end
         end
@@ -81,16 +97,16 @@ module Aws
         # --------------------------------------------------------------------------------
         def parseActionSymbol(v)
           if v.to_sym == :all
-            ::Aws::Cfn::Stacker::Application.allactions
+            StackerApplication.allactions
           else
-            s = v.to_sym
-            allactions = [::Aws::Cfn::Stacker::Application.allactions, :all].flatten
+            s = v.gsub('-', '_').to_sym
+            allactions = [StackerApplication.allactions, :all].flatten
             unless allactions.include?(s)
               allactions.each{ |p|
                 s = p if p.match(%r/^#{s}/)
               }
             end
-            s = ::Aws::Cfn::Stacker::Application.allactions if s == :all
+            s = StackerApplication.allactions if s == :all
             s
           end
         end
@@ -128,10 +144,11 @@ module Aws
             raise StackerError.new("Recursive call to inifile == '#{options[:inifile]}'") if @inis.include?(options[:inifile])
             ini = nil
             begin
+              # puts "IniFile.load('#{options[:inifile]}')"
               ini = IniFile.load(options[:inifile])
               @inis << options[:inifile]
               ini['global'].each { |key, value|
-                #puts "#{key}=#{value}"
+                # puts "#{key}=#{value}"
                 ENV[key]=value
               }
               argv=[]
@@ -218,12 +235,12 @@ module Aws
               #findRootPath(options)
           rescue StackerError => e
             puts e.message.light_red
-            puts "#{__FILE__}::#{__LINE__} reraising ... "
+            puts "#{__FILE__}:#{__LINE__} reraising ... "
             raise e
             exit -1
           rescue Exception => e
             puts e.message.light_red
-            puts "#{__FILE__}::#{__LINE__} reraising ... "
+            puts "#{__FILE__}:#{__LINE__} reraising ... "
             raise e
             exit -2
           end
@@ -266,8 +283,11 @@ module Aws
         #
         # If this module is included we inject this payload into the including class.
         #
+        def self.extended(includer)
+          included includer
+        end
         def self.included(includer)
-          includer.extend(::DLDInternet::Mixlib::CLI::ClassMethods)
+          includer.extend(::DLDInternet::Mixlib::CLI::Parsers::ClassMethods)
           includer.extend(ClassMethods)
 
           includer.class_eval do
@@ -317,7 +337,7 @@ module Aws
                     short:        '-V',
                     long:         '--version',
                     description:  'Show version',
-                    proc:         Proc.new{ puts ::Aws::Cfn::Stacker::Application::VERSION },
+                    proc:         Proc.new{ puts ::Aws::Cfn::Stacker::VERSION },
                     exit:         2
             option  :config_file_alt,
                     short:        '-c',
@@ -329,40 +349,41 @@ module Aws
             option  :config_file,
                     short:        '-c',
                     long:         '--config_file FILE',
-                    description:  'A config file to use that contains one section per stack, with all the parameters for the stack enumerated. INI, YAML and JSON formats supported.'
+                    description:  'A config file to use that contains one section per stack, with all the parameters for the stack enumerated. INI, YAML and JSON formats supported.',
+                    default:      'config/config.ini'
             option  :verbose,
                     short:        '-v',
                     long:         '--verbose',
                     description:  'Increase verbosity, can be specified multiple times',
                     proc:         lambda {|v|
-                      index = ::Aws::Cfn::Stacker::Application.loglevels.index(@options[:log_level]) || ::Aws::Cfn::Stacker::Application.loglevels.index(:warn)
+                      index = $STKR.class.loglevels.index(@options[:log_level]) || $STKR.class.loglevels.index(:warn)
                       index -= 1 if index > 0
-                      @options[:log_level] = ::Aws::Cfn::Stacker::Application.loglevels[index]
+                      @options[:log_level] = $STKR.class..loglevels[index]
                     }
             option  :log_level,
                     long:         '--debug',
                     description:  'Set debug level logging. No effect if specified second time.',
-                    value:        :debug
-            option  :action,
+                    default:      :debug
+            option  :actions,
                     short:        '-a',
                     long:         '--action ACTION',
-                    description:  "Perform the requested action against the stack. (#{::Aws::Cfn::Stacker::Application.allactions.to_s})",
+                    description:  "Perform the requested action against the stack. (#{StackerApplication.allactions.to_s})",
                     proc:         lambda{|v|
                       actions = $STKR.parseOptionString(v,',', 'parseActionSymbol')
-                      all     = [::Aws::Cfn::Stacker::Application.allactions, :all].flatten
+                      all     = [StackerApplication.allactions, :all].flatten
                       actions.each{ |act|
                         unless all.include?(act.to_sym)
                           raise ::OptionParser::InvalidOption.new("Invalid action: #{act.to_s}. Valid actions are: #{all.to_s}")
                         end
                       }
                       actions
-                    }
+                    },
+                    default:      [ :create ]
             option  :build,
                     short:        '-b',
                     long:         '--build',
                     description:  'Build configuration directory for use with Ansible.',
                     proc:         lambda { |v| @options[:action] = :build}
-
             option  :remove,
                     short:        '-r',
                     long:         '--remove',
@@ -396,14 +417,15 @@ module Aws
             option  :template,
                     short:        '-t',
                     long:         '--template FILE',
-                    description:  "Specify a template to run. Note that specific outputs are expected, so results may vary. Default #{::Aws::Cfn::Stacker::Application.defaultoptions[:template_file]}",
+                    description:  "Specify a template to run. Note that specific outputs are expected, so results may vary. Default #{StackerApplication.defaultoptions[:template_file]}",
                     proc:         lambda { |v| @options[:template_file] = v }
             option  :template_file,
                     long:         '--template-file FILE',
-                    description:  "Specify a template to run. Note that specific outputs are expected, so results may vary. Default #{::Aws::Cfn::Stacker::Application.defaultoptions[:template_file]}"
+                    description:  "Specify a template to run. Note that specific outputs are expected, so results may vary. Default #{StackerApplication.defaultoptions[:template_file]}",
+                    default:      'templates/mvc-vpc.json'
             option  :template_file_alt,
                     long:         '--template_file FILE',
-                    description:  "Specify a template to run. Note that specific outputs are expected, so results may vary. Default #{::Aws::Cfn::Stacker::Application.defaultoptions[:template_file]}",
+                    description:  "Specify a template to run. Note that specific outputs are expected, so results may vary. Default #{StackerApplication.defaultoptions[:template_file]}",
                     proc:         lambda { |v| @options[:template_file] = v }
             option  :template_url_alt,
                     long:         '--template-url URL',
@@ -421,14 +443,17 @@ module Aws
                     description:  'The path to the SSH key file to use for SSH to hosts'
             option  :ssh_user,
                     long:         '--ssh_user USER',
-                    description:  'SSH User name'
+                    description:  'SSH User name',
+                    default:      'ubuntu'
             option  :ssh_user_bastion,
                     long:         '--ssh_user_bastion USER',
-                    description:  'Bastion SSH User name'
+                    description:  'Bastion SSH User name',
+                    default:      'ubuntu'
             option  :initial_setup,
                     short:        '-i',
                     long:         '--initial_setup FILE',
-                    description:  'An initial setup file for Ansible'
+                    description:  'An initial setup file for Ansible',
+                    default:      'ansible/playbooks/initial_setup.yml'
             option  :output_path,
                     short:        '-o',
                     long:         '--output PATH',
@@ -436,11 +461,17 @@ module Aws
             option  :roles_path,
                     short:        '-r',
                     long:         '--roles_path PATH',
-                    description:  'Output folder for the Ansible build configuration'
+                    description:  'Output folder for the Ansible build configuration',
+                    default:      'ansible/playbooks/roles'
             option  :progress,
                     short:        '-p',
                     long:         '--progress',
-                    description:  'Print a progress indicator during stack create/update/delete.'
+                    description:  'Print a progress indicator during stack create/update/delete.',
+                    default:      false
+            option  :inifile,
+                    short:        "-f",
+                    long:         "--inifile FILE",
+                    description:  "INI file with settings"
             option  :log_file_alt,
                     long:         '--log-file PATH',
                     description:  'Log destination file',
@@ -452,12 +483,12 @@ module Aws
                     long:         '--log-level LEVEL',
                     description:  'Logging level',
                     proc:         lambda{|v|
-                      if ::Aws::Cfn::Stacker::Application.loglevels.include? v.to_sym
+                      if StackerApplication.loglevels.include? v.to_sym
                         v.to_sym
                       else
-                        level = ::Aws::Cfn::Stacker::Application.loglevels.select{|l| l.to_s.match(%r(^#{v}))}
+                        level = StackerApplication.loglevels.select{|l| l.to_s.match(%r(^#{v}))}
                         unless level.size > 0
-                          raise ::OptionParser::InvalidOption.new("Invalid log level: #{v}. Valid levels are #{::Aws::Cfn::Stacker::Application.loglevels.ai}")
+                          raise ::OptionParser::InvalidOption.new("Invalid log level: #{v}. Valid levels are #{StackerApplication.loglevels.ai}")
                         end
                         level[0].to_sym
                       end
@@ -466,12 +497,12 @@ module Aws
                     long:         '--log_level LEVEL',
                     description:  'Logging level',
                     proc:         lambda{|v|
-                      if ::Aws::Cfn::Stacker::Application.loglevels.include? v.to_sym
+                      if StackerApplication.loglevels.include? v.to_sym
                         v.to_sym
                       else
-                        level = ::Aws::Cfn::Stacker::Application.loglevels.select{|l| l.to_s.match(%r(^#{v}))}
+                        level = StackerApplication.loglevels.select{|l| l.to_s.match(%r(^#{v}))}
                         unless level.size > 0
-                          raise ::OptionParser::InvalidOption.new("Invalid log level: #{v}. Valid levels are #{::Aws::Cfn::Stacker::Application.loglevels.ai}")
+                          raise ::OptionParser::InvalidOption.new("Invalid log level: #{v}. Valid levels are #{StackerApplication.loglevels.ai}")
                         end
                         level[0].to_sym
                       end