beaker 0.0.0

data/lib/beaker/options_parsing.rb

@@ -0,0 +1,323 @@
+module Beaker
+  class Options
+    GITREPO = 'git://github.com/puppetlabs'
+
+    def self.options
+      return @options
+    end
+
+    def self.repo?
+      GITREPO
+    end
+
+    def self.parse_install_options(install_opts)
+      install_opts.map! { |opt|
+        case opt
+          when /^PUPPET\//
+            opt = "#{GITREPO}/puppet.git##{opt.split('/', 2)[1]}"
+          when /^FACTER\//
+            opt = "#{GITREPO}/facter.git##{opt.split('/', 2)[1]}"
+          when /^HIERA\//
+            opt = "#{GITREPO}/hiera.git##{opt.split('/', 2)[1]}"
+          when /^HIERA-PUPPET\//
+            opt = "#{GITREPO}/hiera-puppet.git##{opt.split('/', 2)[1]}"
+        end
+        opt
+      }
+      install_opts
+    end
+
+    def self.file_list(paths)
+      files = []
+      if not paths.empty? 
+        paths.each do |root|
+          if File.file? root then
+            files << root
+          else
+            discover_files = Dir.glob(
+              File.join(root, "**/*.rb")
+            ).select { |f| File.file?(f) }
+            if discover_files.empty?
+              raise ArgumentError, "Empty directory used as an option (#{root})!"
+            end
+            files += discover_files
+          end
+        end
+      end
+      files
+    end
+
+    def self.parse_args
+      return @options if @options
+
+      @no_args = ARGV.empty? ? true : false
+
+      @defaults = {}
+      @options = {}
+      @options_from_file = {}
+
+      optparse = OptionParser.new do|opts|
+        # Set a banner
+        opts.banner = "Usage: #{File.basename($0)} [options...]"
+
+        @defaults[:config] = nil
+        opts.on '-c', '--config FILE',
+                'Use configuration FILE' do |file|
+          @options[:config] = file
+        end
+
+        @defaults[:options_file] = nil
+        opts.on '-o', '--options-file FILE',
+                'Read options from FILE',
+                'This should evaluate to a ruby hash.',
+                'CLI optons are given precedence.' do |file|
+          @options_from_file = parse_options_file file
+        end
+
+        @defaults[:type] = 'pe'
+        opts.on '--type TYPE',
+                'one of git or pe', 
+                'used to determine underlying path structure of puppet install',
+                'defaults to pe' do |type|
+          @options[:type] = type
+        end
+
+        @defaults[:helper] = []
+        opts.on '--helper PATH/TO/SCRIPT',
+                'Ruby file evaluated prior to tests',
+                '(a la spec_helper)' do |script|
+          @options[:helper] = []
+          if script.is_a?(Array)
+            @options[:helper] += script
+          elsif script =~ /,/
+            @options[:helper] += script.split(',')
+          else
+            @options[:helper] << script
+          end
+        end
+
+        @defaults[:load_path] = []
+        opts.on  '--load-path /PATH/TO/DIR,/ADDITIONAL/DIR/PATHS',
+                 'Add paths to LOAD_PATH'  do |value|
+          @options[:load_path] = []
+          if value.is_a?(Array)
+            @options[:load_path] += value
+          elsif value =~ /,/
+            @options[:load_path] += value.split(',')
+          else
+            @options[:load_path] << value
+          end
+        end
+
+        @defaults[:tests] = []
+        opts.on  '-t', '--tests /PATH/TO/DIR,/ADDITIONA/DIR/PATHS,/PATH/TO/FILE.rb',
+                 'Execute tests from paths and files' do |value|
+          @options[:tests] = []
+          if value.is_a?(Array)
+            @options[:tests] += value
+          elsif value =~ /,/
+            @options[:tests] += value.split(',')
+          else
+            @options[:tests] << value
+          end
+          @options[:tests] = file_list(@options[:tests])
+          if @options[:tests].empty?
+            raise ArgumentError, "No tests to run!"
+          end
+        end
+
+        @defaults[:pre_suite] = []
+        opts.on '--pre-suite /PRE-SUITE/DIR/PATH,/ADDITIONAL/DIR/PATHS,/PATH/TO/FILE.rb',
+                'Path to project specific steps to be run BEFORE testing' do |value|
+          @options[:pre_suite] = []
+          if value.is_a?(Array)
+            @options[:pre_suite] += value
+          elsif value =~ /,/
+            @options[:pre_suite] += value.split(',')
+          else
+            @options[:pre_suite] << value
+          end
+          @options[:pre_suite] = file_list(@options[:pre_suite])
+          if @options[:pre_suite].empty?
+            raise ArgumentError, "Empty pre-suite!"
+          end
+        end
+
+        @defaults[:post_suite] = []
+        opts.on '--post-suite /POST-SUITE/DIR/PATH,/OPTIONAL/ADDITONAL/DIR/PATHS,/PATH/TO/FILE.rb',
+                'Path to project specific steps to be run AFTER testing' do |value|
+          @options[:post_suite] = []
+          if value.is_a?(Array)
+            @options[:post_suite] += value
+          elsif value =~ /,/
+            @options[:post_suite] += value.split(',')
+          else
+            @options[:post_suite] << value
+          end
+          @options[:post_suite] = file_list(@options[:post_suite])
+          if @options[:post_suite].empty?
+            raise ArgumentError, "Empty post-suite!"
+          end
+        end
+
+        @defaults[:provision] = true
+        opts.on '--[no-]provision',
+                'Do not provision vm images before testing',
+                '(default: true)' do |bool|
+          @options[:provision] = bool
+        end
+
+        @defaults[:preserve_hosts] = false
+        opts.on '--[no-]preserve-hosts',
+                'Preserve cloud instances' do |value|
+          @options[:preserve_hosts] = value
+        end
+
+        @defaults[:root_keys] = false
+        opts.on '--root-keys',
+                'Install puppetlabs pubkeys for superuser',
+                '(default: false)' do |bool|
+          @options[:root_keys] = bool
+        end
+
+        @defaults[:keyfile] = "#{ENV['HOME']}/.ssh/id_rsa"
+        opts.on '--keyfile /PATH/TO/SSH/KEY',
+                'Specify alternate SSH key',
+                '(default: ~/.ssh/id_rsa)' do |key|
+          @options[:keyfile] = key
+        end
+
+
+        @defaults[:install] = []
+        opts.on '-i URI', '--install URI',
+                'Install a project repo/app on the SUTs', 
+                'Provide full git URI or use short form KEYWORD/name',
+                'supported keywords: PUPPET, FACTER, HIERA, HIERA-PUPPET' do |value|
+          @options[:install] = []
+          if value.is_a?(Array)
+            @options[:install] += value
+          elsif value =~ /,/
+            @options[:install] += value.split(',')
+          else
+            @options[:install] << value
+          end
+          @options[:install] = parse_install_options(@options[:install])
+        end
+
+        @defaults[:modules] = []
+        opts.on('-m', '--modules URI', 'Select puppet module git install URI') do |value|
+          @options[:modules] ||= []
+          @options[:modules] << value
+        end
+
+        @defaults[:quiet] = false
+        opts.on '-q', '--[no-]quiet',
+                'Do not log output to STDOUT',
+                '(default: false)' do |bool|
+          @options[:quiet] = bool
+        end
+
+        @defaults[:xml] = false
+        opts.on '-x', '--[no-]xml',
+                'Emit JUnit XML reports on tests',
+                '(default: false)' do |bool|
+          @options[:xml] = bool
+        end
+
+        @defaults[:color] = true
+        opts.on '--[no-]color',
+                'Do not display color in log output',
+                '(default: true)' do |bool|
+          @options[:color] = bool
+        end
+
+        @defaults[:debug] = false
+        opts.on '--[no-]debug',
+                'Enable full debugging',
+                '(default: false)' do |bool|
+          @options[:debug] = bool
+        end
+
+        @defaults[:dry_run] = false
+        opts.on  '-d', '--[no-]dry-run',
+                 'Report what would happen on targets',
+                 '(default: false)' do |bool|
+          @options[:dry_run] = bool
+          $dry_run = bool
+        end
+
+        @defaults[:fail_mode] = nil
+        opts.on '--fail-mode [MODE]',
+                'How should the harness react to errors/failures',
+                'Possible values:',
+                'fast (skip all subsequent tests, cleanup, exit)',
+                'stop (skip all subsequent tests, do no cleanup, exit immediately)'  do |mode|
+          @options[:fail_mode] = mode
+        end
+
+        @defaults[:timesync] = false
+        opts.on '--[no-]ntp',
+                'Sync time on SUTs before testing',
+                '(default: false)' do |bool|
+          @options[:timesync] = bool
+        end
+
+        @defaults[:repo_proxy] = false
+        opts.on '--repo-proxy',
+                'Proxy packaging repositories on ubuntu, debian and solaris-11',
+                '(default: false)' do
+          @options[:repo_proxy] = true
+        end
+
+        @defaults[:add_el_extras] = false
+        opts.on '--add-el-extras',
+                'Add Extra Packages for Enterprise Linux (EPEL) repository to el-* hosts',
+                '(default: false)' do
+          @options[:add_el_extras] = true
+        end
+
+        opts.on('--help', 'Display this screen' ) do |yes|
+          puts opts
+          exit
+        end
+      end
+
+      optparse.parse!
+
+      # We have use the @no_args var because OptParse consumes ARGV as it parses
+      # so we have to check the value of ARGV at the begining of the method,
+      # let the options be set, then output usage.
+      puts optparse if @no_args
+
+      # merge in the options that we read from the file
+      @options = @options_from_file.merge(@options)
+      # merge in defaults
+      @options = @defaults.merge(@options)
+
+      if @options[:type] !~ /(pe)|(git)/
+        raise ArgumentError.new("--type must be one of pe or git, not '#{@options[:type]}'")
+      end
+
+      raise ArgumentError.new("--fail-mode must be one of fast, stop") unless ["fast", "stop", nil].include?(@options[:fail_mode])
+
+      @options
+    end
+
+    def self.parse_options_file(options_file_path)
+      options_file_path = File.expand_path(options_file_path)
+      unless File.exists?(options_file_path)
+        raise ArgumentError, "Specified options file '#{options_file_path}' does not exist!"
+      end
+      # This eval will allow the specified options file to have access to our
+      #  scope.  It is important that the variable 'options_file_path' is
+      #  accessible, because some existing options files (e.g. puppetdb) rely on
+      #  that variable to determine their own location (for use in 'require's, etc.)
+      result = eval(File.read(options_file_path))
+      unless result.is_a? Hash
+        raise ArgumentError, "Options file '#{options_file_path}' must return a hash!"
+      end
+
+      result
+    end
+  end
+end

data/lib/beaker/result.rb

@@ -0,0 +1,55 @@
+module Beaker
+  class Result
+    attr_accessor :host, :cmd, :exit_code, :stdout, :stderr, :output,
+                  :raw_stdout, :raw_stderr, :raw_output
+    def initialize(host, cmd)
+      @host       = host
+      @cmd        = cmd
+      @stdout     = ''
+      @stderr     = ''
+      @output     = ''
+      @exit_code  = nil
+    end
+
+    # Ruby assumes chunked data (like something it receives from Net::SSH)
+    # to be binary (ASCII-8BIT). We need to gather all chunked data and then
+    # re-encode it as the default encoding it assumes for external text
+    # (ie our test files and the strings they're trying to match Net::SSH's
+    # output from)
+    # This is also the lowest overhead place to normalize line endings, IIRC
+    def finalize!
+      @raw_stdout = @stdout
+      @stdout     = normalize_line_endings( convert( @stdout ) )
+      @raw_stderr = @stderr
+      @stderr     = normalize_line_endings( convert( @stderr ) )
+      @raw_output = @output
+      @output     = normalize_line_endings( convert( @output ) )
+    end
+
+    def normalize_line_endings string
+      return string.gsub(/\r\n?/, "\n")
+    end
+
+    def convert string
+      if string.respond_to?( :force_encoding ) and defined?( Encoding )
+        # We're running in >= 1.9 and we'll need to convert
+        return string.force_encoding( Encoding.default_external )
+      else
+        # We're running in < 1.9 and Ruby doesn't care
+        return string
+      end
+    end
+
+    def log(logger)
+      logger.debug "Exited: #{exit_code}" unless exit_code == 0
+    end
+
+    def formatted_output(limit=10)
+      @output.split("\n").last(limit).collect {|x| "\t" + x}.join("\n")
+    end
+
+    def exit_code_in?(range)
+      range.include?(@exit_code)
+    end
+  end
+end

data/lib/beaker/shared.rb

@@ -0,0 +1,15 @@
+[ 'repetition', 'error_handler', 'host_handler' ].each do |file|
+  begin
+    require "beaker/shared/#{file}"
+  rescue LoadError
+    require File.expand_path(File.join(File.dirname(__FILE__), 'shared', file))
+  end
+end
+module Beaker
+  module Shared
+    include Beaker::Shared::ErrorHandler
+    include Beaker::Shared::HostHandler
+    include Beaker::Shared::Repetition
+  end
+end
+include Beaker::Shared

data/lib/beaker/shared/error_handler.rb

@@ -0,0 +1,17 @@
+module Beaker 
+  module Shared
+    module ErrorHandler
+
+    def report_and_raise(logger, e, msg)
+      logger.error "Failed: errored in #{msg}"
+      logger.error(e.inspect)
+      bt = e.backtrace
+      logger.pretty_backtrace(bt).each_line do |line|
+        logger.error(line)
+      end 
+      raise e
+    end
+
+    end
+  end
+end

data/lib/beaker/shared/host_handler.rb

@@ -0,0 +1,46 @@
+module Beaker 
+  module Shared
+    module HostHandler
+
+      # NOTE: this code is shamelessly stolen from facter's 'domain' fact, but
+      # we don't have access to facter at this point in the run.  Also, this
+      # utility method should perhaps be moved to a more central location in the
+      # framework.
+      def get_domain_name(host)
+        domain = nil
+        search = nil
+        resolv_conf = host.exec(Command.new("cat /etc/resolv.conf")).stdout
+        resolv_conf.each_line { |line|
+          if line =~ /^\s*domain\s+(\S+)/
+            domain = $1
+          elsif line =~ /^\s*search\s+(\S+)/
+            search = $1
+          end
+        }
+        return domain if domain
+        return search if search
+      end
+
+      def get_ip(host)
+        host.exec(Command.new("ip a|awk '/g/{print$2}' | cut -d/ -f1 | head -1")).stdout.chomp
+      end
+
+      def set_etc_hosts(host, etc_hosts)
+        host.exec(Command.new("echo '#{etc_hosts}' > /etc/hosts"))
+      end
+
+      def hosts_with_role(hosts, desired_role = nil)
+        hosts.select do |host|
+          desired_role.nil? or host['roles'].include?(desired_role.to_s)
+        end
+      end 
+
+      def only_host_with_role(hosts, role)
+        a_host = hosts_with_role(hosts, role)
+        raise "There can be only one #{role}, but I found:" +
+          "#{a_host.map {|h| h.to_s } }" unless a_host.length == 1
+        a_host.first 
+      end
+    end
+  end
+end