beaker 0.0.0

data/lib/beaker/shared/repetition.rb

@@ -0,0 +1,28 @@
+module Beaker
+  module Shared
+    module Repetition
+
+      def repeat_for seconds, &block
+        timeout = Time.now + seconds
+        done = false
+        until done or timeout < Time.now do
+          done = block.call
+        end
+        return done
+      end
+
+      def repeat_fibonacci_style_for attempts, &block
+        done = false
+        attempt = 1
+        last_wait, wait = 0, 1
+        while not done and attempt <= attempts do
+          done = block.call
+          sleep wait
+          last_wait, wait = wait, last_wait + wait
+        end
+        return done
+      end
+    end
+  end
+end
+

data/lib/beaker/ssh_connection.rb

@@ -0,0 +1,198 @@
+require 'socket'
+require 'timeout'
+require 'net/scp'
+
+module Beaker
+  class SshConnection
+
+    RETRYABLE_EXCEPTIONS = [
+      SocketError,
+      Timeout::Error,
+      Errno::ETIMEDOUT,
+      Errno::EHOSTDOWN,
+      Errno::EHOSTUNREACH,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::ENETUNREACH,
+      Net::SSH::Disconnect
+    ]
+
+    def initialize hostname, user = nil, options = {}
+      @hostname = hostname
+      @user = user
+      @options = options
+    end
+
+    def self.connect hostname, user = 'root', options = {}
+      connection = new hostname, user, options
+      connection.connect
+      connection
+    end
+
+    def connect
+      try = 1
+      last_wait = 0
+      wait = 1
+      @ssh ||= begin
+                 Net::SSH.start(@hostname, @user, @options)
+               rescue *RETRYABLE_EXCEPTIONS => e
+                 if try <= 11
+                   puts "Try #{try} -- Host #{@hostname} unreachable: #{e.message}"
+                   puts "Trying again in #{wait} seconds"
+                   sleep wait
+                   (last_wait, wait) = wait, last_wait + wait
+                   try += 1
+                   retry
+                 else
+                   # why is the logger not passed into this class?
+                   puts "Failed to connect to #{@hostname}"
+                   raise
+                 end
+               rescue Net::SSH::AuthenticationFailed => e
+                 raise "Unable to authenticate to #{@hostname} with user #{e.message.inspect}"
+               end
+      self
+    end
+
+    def close
+      begin
+        @ssh.close if @ssh
+      rescue
+        @ssh.shutdown! 
+      end
+      @ssh = nil
+    end
+
+    def try_to_execute command, options = {}, stdout_callback = nil,
+                stderr_callback = stdout_callback
+
+      result = Result.new(@hostname, command)
+      # why are we getting to this point on a dry run anyways?
+      # also... the host creates connections through the class method,
+      # which automatically connects, so you can't do a dry run unless you also
+      # can connect to your hosts?
+      return result if options[:dry_run]
+
+      @ssh.open_channel do |channel|
+        request_terminal_for( channel, command ) if options[:pty]
+
+        channel.exec(command) do |terminal, success|
+          abort "FAILED: to execute command on a new channel on #{@hostname}" unless success
+          register_stdout_for terminal, result, stdout_callback
+          register_stderr_for terminal, result, stderr_callback
+          register_exit_code_for terminal, result
+
+          process_stdin_for( terminal, options[:stdin] ) if options[:stdin]
+        end
+      end
+
+      # Process SSH activity until we stop doing that - which is when our
+      # channel is finished with...
+      @ssh.loop
+
+      result.finalize!
+      result
+    end
+
+    def execute command, options = {}, stdout_callback = nil,
+                stderr_callback = stdout_callback
+      attempt = true
+      begin
+        result = try_to_execute(command, options, stdout_callback, stderr_callback)
+      rescue *RETRYABLE_EXCEPTIONS => e
+        if attempt
+          attempt = false
+          puts "Command execution failed, attempting to reconnect to #{@hostname}"
+          close
+          connect 
+          retry
+        else
+          raise
+        end
+      end
+
+      result
+    end
+
+    def request_terminal_for channel, command
+      channel.request_pty do |ch, success|
+        if success
+          puts "Allocated a PTY on #{@hostname} for #{command.inspect}"
+        else
+          abort "FAILED: could not allocate a pty when requested on " +
+            "#{@hostname} for #{command.inspect}"
+        end
+      end
+    end
+
+    def register_stdout_for channel, output, callback = nil
+      channel.on_data do |ch, data|
+        callback[data] if callback
+        output.stdout << data
+        output.output << data
+      end
+    end
+
+    def register_stderr_for channel, output, callback = nil
+      channel.on_extended_data do |ch, type, data|
+        if type == 1
+          callback[data] if callback
+          output.stderr << data
+          output.output << data
+        end
+      end
+    end
+
+    def register_exit_code_for channel, output
+      channel.on_request("exit-status") do |ch, data|
+        output.exit_code = data.read_long
+      end
+    end
+
+    def process_stdin_for channel, stdin
+      # queue stdin data, force it to packets, and signal eof: this
+      # triggers action in many remote commands, notably including
+      # 'puppet apply'.  It must be sent at some point before the rest
+      # of the action.
+      channel.send_data stdin.to_s
+      channel.process
+      channel.eof!
+    end
+
+    def scp_to source, target, options = {}, dry_run = false
+      return if dry_run
+
+      options[:recursive]=File.directory?(source) if options[:recursive].nil?
+
+      @ssh.scp.upload! source, target, options
+
+      result = Result.new(@hostname, [source, target])
+
+      # Setting these values allows reporting via result.log(test_name)
+      result.stdout = "SCP'ed file #{source} to #{@hostname}:#{target}"
+
+      # Net::Scp always returns 0, so just set the return code to 0.
+      result.exit_code = 0
+
+      return result
+    end
+
+    def scp_from source, target, options = {}, dry_run = false
+      return if dry_run
+
+      options[:recursive] = true if options[:recursive].nil?
+
+      @ssh.scp.download! source, target, options
+
+      result = Result.new(@hostname, [source, target])
+
+      # Setting these values allows reporting via result.log(test_name)
+      result.stdout = "SCP'ed file #{@hostname}:#{source} to #{target}"
+
+      # Net::Scp always returns 0, so just set the return code to 0.
+      result.exit_code = 0
+
+      result
+    end
+  end
+end

data/lib/beaker/test_case.rb

@@ -0,0 +1,225 @@
+%w( host answers dsl ).each do |lib|
+  begin
+    require "beaker/#{lib}"
+  rescue LoadError
+    require File.expand_path(File.join(File.dirname(__FILE__), lib))
+  end
+end
+
+require 'tempfile'
+require 'benchmark'
+require 'stringio'
+require 'rbconfig'
+require 'test/unit'
+
+module Beaker
+  # This class represents a single test case. A test case is necessarily
+  # contained all in one file though may have multiple dependent examples.
+  # They are executed in order (save for any teardown procs registered
+  # through {Beaker::DSL::Structure#teardown}) and once completed
+  # the status of the TestCase is saved. Instance readers/accessors provide
+  # the test case access to various details of the environment and suite
+  # the test case is running within.
+  #
+  # See {Beaker::DSL} for more information about writing tests
+  # using the DSL.
+  class TestCase
+    include Beaker::DSL
+
+    rb_config_class = defined?(RbConfig) ? RbConfig : Config
+    if rb_config_class::CONFIG['MAJOR'].to_i == 1 &&
+      rb_config_class::CONFIG['MINOR'].to_i == 8 then
+      Test::Unit.run = true
+      # The Exception raised by Ruby's STDLIB's test framework (Ruby 1.8)
+      TEST_EXCEPTION_CLASS = Test::Unit::AssertionFailedError
+    else
+      # The Exception raised by Ruby's STDLIB's test framework (Ruby 1.9)
+      TEST_EXCEPTION_CLASS = ::MiniTest::Assertion
+    end
+
+    # Necessary for implementing {Beaker::DSL::Helpers#confine}.
+    # Assumed to be an array of valid {Beaker::Host} objects for
+    # this test case.
+    attr_accessor :hosts
+
+    # Necessary for many methods in {Beaker::DSL}. Assumed to be
+    # an instance of {Beaker::Logger}.
+    attr_accessor :logger
+
+    # A Hash of 'product name' => 'version installed', only set when
+    # products are installed via git or PE install steps. See the 'git' or
+    # 'pe' directories within 'ROOT/setup' for examples.
+    attr_reader :version
+
+    # A Hash of values taken from host config file.
+    attr_reader :config
+
+    # Parsed command line options.
+    attr_reader :options
+
+    # The path to the file which contains this test case.
+    attr_reader :path
+
+    # I don't know why this is here
+    attr_reader :fail_flag
+
+    # The user that is running this tests home directory, needed by 'net/ssh'.
+    attr_reader :usr_home
+
+    # A Symbol denoting the status of this test (:fail, :pending,
+    # :skipped, :pass).
+    attr_reader :test_status
+
+    # The exception that may have stopped this test's execution.
+    attr_reader :exception
+
+    # @deprecated
+    # The amount of time taken to execute the test. Unused, probably soon
+    # to be removed or refactored.
+    attr_reader :runtime
+
+    # An Array of Procs to be called after test execution has stopped
+    # (whether by exception or not).
+    attr_reader :teardown_procs
+
+    # @deprecated
+    # Legacy accessor from when test files would only contain one remote
+    # action.  Contains the Result of the last call to utilize
+    # {Beaker::DSL::Helpers#on}.  Do not use as it is not safe
+    # in test files that use multiple calls to
+    # {Beaker::DSL::Helpers#on}.
+    attr_accessor :result
+
+    # @param [Hosts,Array<Host>] these_hosts The hosts to execute this test
+    #                                        against/on.
+    # @param [Logger] logger A logger that implements
+    #                        {Beaker::Logger}'s interface.
+    # @param [Hash{String=>String}] config Clusterfck of various config opts.
+    # @param [Hash{Symbol=>String}] options Parsed command line options.
+    # @param [String] path The local path to a test file to be executed.
+    def initialize(these_hosts, logger, config, options={}, path=nil)
+      @config  = config['CONFIG']
+      @hosts   = these_hosts
+      @logger = logger
+      @options = options
+      @path    = path
+      @usr_home = ENV['HOME']
+      @test_status = :pass
+      @exception = nil
+      @runtime = nil
+      @teardown_procs = []
+
+
+      #
+      # We put this on each wrapper (rather than the class) so that methods
+      # defined in the tests don't leak out to other tests.
+      class << self
+        def run_test
+          @runtime = Benchmark.realtime do
+            begin
+              test = File.read(path)
+              eval test,nil,path,1
+            rescue FailTest, TEST_EXCEPTION_CLASS => e
+              @test_status = :fail
+              @exception   = e
+            rescue PendingTest
+              @test_status = :pending
+            rescue SkipTest
+              @test_status = :skip
+            rescue StandardError, ScriptError => e
+              log_and_fail_test(e)
+            ensure
+              @teardown_procs.each do |teardown|
+                begin
+                  teardown.call
+                rescue StandardError => e
+                  log_and_fail_test(e)
+                end
+              end
+            end
+          end
+          return self
+        end
+
+        private
+
+        # Log an error and mark the test as failed, passing through an
+        # exception so it can be displayed at the end of the total run.
+        #
+        # We break out the complete exception backtrace and log each line
+        # individually as well.
+        #
+        # @param exception [Exception] exception to fail with
+        def log_and_fail_test(exception)
+          logger.error(exception.inspect)
+          bt = exception.backtrace
+          logger.pretty_backtrace(bt).each_line do |line|
+            logger.error(line)
+          end
+          @test_status = :error
+          @exception   = exception
+        end
+      end
+    end
+
+    # The TestCase as a hash
+    # @api public
+    # @note The visibility and semantics of this method are valid, but the
+    #   structure of the Hash it returns may change without notice
+    #
+    # @return [Hash] A Hash representation of this test.
+    def to_hash
+      hash = {}
+      hash['HOSTS'] = {}
+      hash['CONFIG'] = @config
+      @hosts.each do |host|
+        hash['HOSTS'][host.name] = host.overrides
+      end
+      hash
+    end
+
+    # @deprecated
+    # An proxy for the last {Beaker::Result#stdout} returned by
+    # a method that makes remote calls.  Use the {Beaker::Result}
+    # object returned by the method directly instead. For Usage see
+    # {Beaker::Result}.
+    def stdout
+      return nil if @result.nil?
+      @result.stdout
+    end
+
+    # @deprecated
+    # An proxy for the last {Beaker::Result#stderr} returned by
+    # a method that makes remote calls.  Use the {Beaker::Result}
+    # object returned by the method directly instead. For Usage see
+    # {Beaker::Result}.
+    def stderr
+      return nil if @result.nil?
+      @result.stderr
+    end
+
+    # @deprecated
+    # An proxy for the last {Beaker::Result#exit_code} returned by
+    # a method that makes remote calls.  Use the {Beaker::Result}
+    # object returned by the method directly instead. For Usage see
+    # {Beaker::Result}.
+    def exit_code
+      return nil if @result.nil?
+      @result.exit_code
+    end
+
+    # This method retrieves the forge hostname from either:
+    # * The environment variable 'forge_host'
+    # * The parameter 'forge_host' from the CONFIG hash in a node definition
+    #
+    # If none of these are available, it falls back to the static
+    # 'vulcan-acceptance.delivery.puppetlabs.net' hostname
+    #
+    # @return [String] hostname of test forge
+    def forge
+      ENV['forge_host'] ||
+        @config['forge_host'] ||
+        'vulcan-acceptance.delivery.puppetlabs.net'
+    end
+  end
+end