beaker 0.0.0 → 1.0.0

data/lib/beaker/command.rb

@@ -91,7 +91,7 @@ module Beaker
       "#{env_string} #{cmd} #{options_string} #{args_string}"
     end
 
-    # @param [Hash] options These are the options that the command takes
+    # @param [Hash] opts These are the options that the command takes
     #
     # @return [String] String of the options and flags for command.
     #
@@ -150,7 +150,7 @@ module Beaker
     #       knowledge contained here. Really the relationship should be
     #       reversed where a host is asked for an appropriate Command when
     #       given a generic Command.
-    def environment_string_for host, env 
+    def environment_string_for host, env
       return '' if env.empty?
 
       env_array = parse_env_hash_for( host, env ).compact

data/lib/beaker/dsl/helpers.rb

@@ -1,4 +1,6 @@
 require 'resolv'
+require 'inifile'
+require 'timeout'
 require 'beaker/dsl/outcomes'
 
 module Beaker
@@ -13,6 +15,9 @@ module Beaker
     #   {Beaker::Host}'s interface to act upon.
     # * a method *logger* that yields a logger implementing
     #   {Beaker::Logger}'s interface.
+    # * the module {Beaker::DSL::Roles} that provides access to the various hosts implementing
+    #   {Beaker::Host}'s interface to act upon
+    # * the module {Beaker::DSL::Wrappers} the provides convenience methods for {Beaker::DSL::Command} creation
     #
     #
     # @api dsl
@@ -31,7 +36,8 @@ module Beaker
 
       # The primary method for executing commands *on* some set of hosts.
       #
-      # @param [Host, Array<Host>] host    One or more hosts to act upon.
+      # @param [Host, Array<Host>, String, Symbol] host    One or more hosts to act upon,
+      #                            or a role (String or Symbol) that identifies one or more hosts.
       # @param [String, Command]   command The command to execute on *host*.
       # @param [Proc]              block   Additional actions or assertions.
       # @!macro common_opts
@@ -54,6 +60,12 @@ module Beaker
       #       end
       #     end
       #
+      # @example Using a role (defined in a String)  to identify the host
+      #   on "master", "echo hello"
+      #
+      # @example Using a role (defined in a Symbol) to identify the host
+      #   on :dashboard, "echo hello"
+      #
       # @return [Result]   An object representing the outcome of *command*.
       # @raise  [FailTest] Raises an exception if *command* obviously fails.
       def on(host, command, opts = {}, &block)
@@ -61,6 +73,9 @@ module Beaker
           cmd_opts = opts[:environment] ? { 'ENV' => opts.delete(:environment) } : Hash.new
           command = Command.new(command.to_s, [], cmd_opts)
         end
+        if host.is_a? String or host.is_a? Symbol
+          host = hosts_as(host) #check by role
+        end
         if host.is_a? Array
           host.map { |h| on h, command, opts, &block }
         else
@@ -73,6 +88,66 @@ module Beaker
         end
       end
 
+      # The method for executing commands on the default host
+      #
+      # @param [String, Command]   command The command to execute on *host*.
+      # @param [Proc]              block   Additional actions or assertions.
+      # @!macro common_opts
+      #
+      # @example Most basic usage
+      #     shell 'ls /tmp'
+      #
+      # @example Allowing additional exit codes to pass
+      #     shell 'puppet agent -t', :acceptable_exit_codes => [0,2]
+      #
+      # @example Using the returned result for any kind of checking
+      #     if shell('ls -la ~').stdout =~ /\.bin/
+      #       ...do some action...
+      #     end
+      #
+      # @example Using TestCase helpers from within a test.
+      #     agents.each do |agent|
+      #       shell('cat /etc/puppet/puppet.conf') do |result|
+      #         assert_match result.stdout, /server = #{master}/, 'WTF Mate'
+      #       end
+      #     end
+      #
+      # @return [Result]   An object representing the outcome of *command*.
+      # @raise  [FailTest] Raises an exception if *command* obviously fails.
+      def shell(command, opts = {}, &block)
+        on(default, command, opts, &block)
+      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
+
       # Move a file from a remote to a local path
       # @note If using {Beaker::Host} for the hosts *scp* is not
       #   required on the system as it uses Ruby's net/scp library.  The
@@ -119,17 +194,17 @@ module Beaker
 
       # Check to see if a package is installed on a remote host
       #
-      # @param [Host] host             A host object 
+      # @param [Host] host             A host object
       # @param [String] package_name   Name of the package to check for.
       #
-      # @return [Boolean] true/false if the package is found 
+      # @return [Boolean] true/false if the package is found
       def check_for_package host, package_name
         host.check_for_package package_name
       end
 
       # Install a package on a host
       #
-      # @param [Host] host             A host object 
+      # @param [Host] host             A host object
       # @param [String] package_name   Name of the package to install
       #
       # @return [Result]   An object representing the outcome of *install command*.
@@ -180,6 +255,12 @@ module Beaker
         on host, remote_path, opts, &block
       end
 
+      # Move a local script to default host and execute it
+      # @see #run_script_on
+      def run_script(script, opts = {}, &block)
+        run_script_on(default, script, opts, &block)
+      end
+
       # Limit the hosts a test case is run against
       # @note This will modify the {Beaker::TestCase#hosts} member
       #   in place unless an array of hosts is passed into it and
@@ -198,7 +279,7 @@ module Beaker
       #   considered for inclusion or exclusion.  The key is any attribute
       #   of the host that will be yielded by {Beaker::Host#[]}.
       #   The value can be any string/regex or array of strings/regexp.
-      #   The values are compared using {Enumerable#any?} so that if one
+      #   The values are compared using [Enumerable#any?] so that if one
       #   value of an array matches the host is considered a match for that
       #   criteria.
       # @param [Array<Host>] host_array This creatively named parameter is
@@ -259,6 +340,23 @@ module Beaker
         hosts_to_modify
       end
 
+      # Ensures that host restrictions as specifid by type, criteria and
+      # host_array are confined to activity within the passed block.
+      # TestCase#hosts is reset after block has executed.
+      #
+      # @see #confine
+      def confine_block(type, criteria, host_array = nil, &block)
+        begin
+          original_hosts = self.hosts.dup
+          confine(type, criteria, host_array)
+
+          yield
+
+        ensure
+          self.hosts = original_hosts
+        end
+      end
+
       # @!visibility private
       def inspect_host(host, property, one_or_more_values)
         values = Array(one_or_more_values)
@@ -285,14 +383,25 @@ module Beaker
       # 6. Revert Puppet to the pre-test state
       # 7. Testing artifacts are saved in a folder named for the test
       #
-      # @param [Host] hosts        One object that act like Host
+      # @param [Host] host        One object that act like Host
       #
-      # @param [Hash{Symbol=>String}]
-      #                            config_opts Represent puppet settings.
+      # @param [Hash{Symbol=>String}] conf_opts  Represents puppet settings.
       #                            Sections of the puppet.conf may be
       #                            specified, if no section is specified the
       #                            a puppet.conf file will be written with the
-      #                            options put in a section named after [mode].
+      #                            options put in a section named after [mode]
+      #
+      #                            There is a special setting for command_line
+      #                            arguments such as --debug or --logdest, which
+      #                            cannot be set in puppet.conf.   For example:
+      #
+      #                            :__commandline_args__ => '--logdest /tmp/a.log'
+      #
+      #                            These will only be applied when starting a FOSS
+      #                            master, as a pe master is just bounced.
+      #
+      # @param [File] testdir      The temporary directory which will hold backup
+      #                            configuration, and other test artifacts.
       #
       # @param [Block]             block The point of this method, yields so
       #                            tests may be ran. After the block is finished
@@ -314,71 +423,127 @@ module Beaker
       #
       # @api dsl
       def with_puppet_running_on host, conf_opts, testdir = host.tmpdir(File.basename(@path)), &block
+        raise(ArgumentError, "with_puppet_running_on's conf_opts must be a Hash. You provided a #{conf_opts.class}: '#{conf_opts}'") if !conf_opts.kind_of?(Hash)
+        cmdline_args = conf_opts.delete(:__commandline_args__)
+
         begin
-          backup_file host, host['puppetpath'], testdir, 'puppet.conf'
+          backup_file = backup_the_file(host, host['puppetpath'], testdir, 'puppet.conf')
           lay_down_new_puppet_conf host, conf_opts, testdir
 
           if host.is_pe?
-            bounce_service( 'pe-httpd' )
-
+            bounce_service( host, 'pe-httpd' )
           else
-            start_puppet_from_source_on!( host )
+            puppet_master_started = start_puppet_from_source_on!( host, cmdline_args )
           end
 
           yield self if block_given?
+
+        rescue Exception => early_exception
+          original_exception = RuntimeError.new("PuppetAcceptance::DSL::Helpers.with_puppet_running_on failed (check backtrace for location) because: #{early_exception}\n#{early_exception.backtrace.join("\n")}\n")
+          raise(original_exception)
+
         ensure
-          restore_puppet_conf_from_backup( host )
+          begin
+            restore_puppet_conf_from_backup( host, backup_file )
 
-          if host.is_pe?
-            bounce_service( 'pe-httpd' )
+            if host.is_pe?
+              bounce_service( host, 'pe-httpd' )
+            else
+              stop_puppet_from_source_on( host ) if puppet_master_started
+            end
 
-          else
-            stop_puppet_from_source_on( host )
+          rescue Exception => teardown_exception
+            if original_exception
+              logger.error("Raised during attempt to teardown with_puppet_running_on: #{teardown_exception}\n---\n")
+              raise original_exception
+            else
+              raise teardown_exception
+            end
           end
         end
       end
 
+      # Test Puppet running in a certain run mode with specific options,
+      # on the default host
+      # @api dsl
+      # @see #with_puppet_running_on
+      def with_puppet_running conf_opts, testdir = host.tmpdir(File.basename(@path)), &block
+        with_puppet_running_on(default, conf_opts, testdir, &block)
+      end
+
       # @!visibility private
-      def restore_puppet_conf_from_backup( host )
+      def restore_puppet_conf_from_backup( host, backup_file )
         puppetpath = host['puppetpath']
 
-        host.exec( Command.new( "if [ -f #{puppetpath}/puppet.conf.bak ]; then " +
-                                    "cat #{puppetpath}/puppet.conf.bak > " +
-                                    "#{puppetpath}/puppet.conf; " +
-                                    "rm -rf #{puppetpath}/puppet.conf.bak; " +
+        host.exec( Command.new( "if [ -f '#{backup_file}' ]; then " +
+                                    "cat '#{backup_file}' > " +
+                                    "'#{puppetpath}/puppet.conf'; " +
+                                    "rm -f '#{backup_file}'; " +
                                 "fi" ) )
       end
 
       # @!visibility private
-      def backup_file host, current_dir, new_dir, filename = 'puppet.conf'
+      def backup_the_file host, current_dir, new_dir, filename = 'puppet.conf'
         old_location = current_dir + '/' + filename
-        new_location = new_dir + '/' + filename
+        new_location = new_dir + '/' + filename + '.bak'
 
         host.exec( Command.new( "cp #{old_location} #{new_location}" ) )
+
+        return new_location
       end
 
       # @!visibility private
-      def start_puppet_from_source_on! host
-        host.exec( Command.new( puppet( 'master' ) ) )
+      def start_puppet_from_source_on! host, args = ''
+        host.exec( puppet( 'master', args ) )
 
         logger.debug 'Waiting for the puppet master to start'
         unless port_open_within?( host, 8140, 10 )
+          dump_puppet_log(host)
           raise Beaker::DSL::FailTest, 'Puppet master did not start in a timely fashion'
         end
         logger.debug 'The puppet master has started'
+        return true
       end
 
       # @!visibility private
       def stop_puppet_from_source_on( host )
-        host.exec( Command.new( 'kill $(cat `puppet master --configprint pidfile`)' ) )
+        pid = host.exec( Command.new('cat `puppet master --configprint pidfile`') ).stdout.chomp
+        host.exec( Command.new( "kill #{pid}" ) )
+        Timeout.timeout(10) do
+          while host.exec( Command.new( "kill -0 #{pid}"), :acceptable_exit_codes => [0,1] ).exit_code == 0 do
+            # until kill -0 finds no process and we know that puppet has finished cleaning up
+            sleep 1
+          end
+        end
+      rescue RuntimeError => e
+        dump_puppet_log host
+        raise e
+      end
+
+      # @!visibility private
+      def dump_puppet_log(host)
+        syslogfile = case host['platform']
+          when /fedora|centos|el/ then '/var/log/messages'
+          when /ubuntu|debian/ then '/var/log/syslog'
+          else return
+        end
+
+        logger.notify "\n*************************"
+        logger.notify "* Dumping master log    *"
+        logger.notify "*************************"
+        host.exec( Command.new( "tail -n 100 #{syslogfile}" ), :acceptable_exit_codes => [0,1])
+        logger.notify "*************************\n"
       end
 
       # @!visibility private
       def lay_down_new_puppet_conf( host, configuration_options, testdir )
-        new_conf = puppet_conf_for( host )
+        new_conf = puppet_conf_for( host, configuration_options )
         create_remote_file host, "#{testdir}/puppet.conf", new_conf.to_s
 
-        host.exec( Command.new( "cat #{testdir}/puppet.conf > #{host['puppetpath']}/puppet.conf", :silent => true ) )
+        host.exec(
+          Command.new( "cat #{testdir}/puppet.conf > #{host['puppetpath']}/puppet.conf" ),
+          :silent => true
+        )
         host.exec( Command.new( "cat #{host['puppetpath']}/puppet.conf" ) )
       end
 
@@ -467,6 +632,12 @@ module Beaker
         on host, puppet( 'apply', *args), on_options, &block
       end
 
+      # Runs 'puppet apply' on default host, piping manifest through stdin
+      # @see #apply_manifest_on
+      def apply_manifest(manifest, opts = {}, &block)
+        apply_manifest_on(default, manifest, opts, &block)
+      end
+
       # @deprecated
       def run_agent_on(host, arg='--no-daemonize --verbose --onetime --test',
                        options={}, &block)
@@ -517,7 +688,7 @@ module Beaker
       # removed always.
       #
       # @param machine [String] the host to execute this stub
-      # @param hosts [Hash{String=>String}] a hash containing the host to ip
+      # @param ip_spec [Hash{String=>String}] a hash containing the host to ip
       #   mappings
       # @example Stub puppetlabs.com on the master to 127.0.0.1
       #   stub_hosts_on(master, 'puppetlabs.com' => '127.0.0.1')
@@ -537,6 +708,16 @@ module Beaker
         end
       end
 
+      # This method accepts a block and using the puppet resource 'host' will
+      # setup host aliases before and after that block on the default host
+      #
+      # @example Stub puppetlabs.com on the default host to 127.0.0.1
+      #   stub_hosts('puppetlabs.com' => '127.0.0.1')
+      # @see #stub_hosts_on
+      def stub_hosts(ip_spec)
+        stub_hosts_on(default, ip_spec)
+      end
+
       # This wraps the method `stub_hosts_on` and makes the stub specific to
       # the forge alias.
       #
@@ -545,81 +726,114 @@ module Beaker
         @forge_ip ||= Resolv.getaddress(forge)
         stub_hosts_on(machine, 'forge.puppetlabs.com' => @forge_ip)
       end
-       def sleep_until_puppetdb_started(host)
-         curl_with_retries("start puppetdb", host, "http://localhost:8080", 0, 120)
-         curl_with_retries("start puppetdb (ssl)",
-                           host, "https://#{host.node_name}:8081", [35, 60])
-       end
- 
-       def curl_with_retries(desc, host, url, desired_exit_codes, max_retries = 60, retry_interval = 1)
-         retry_command(desc, host, "curl #{url}", desired_exit_codes, max_retries, retry_interval)
-       end
- 
-       def retry_command(desc, host, command, desired_exit_codes = 0, max_retries = 60, retry_interval = 1)
-         desired_exit_codes = [desired_exit_codes].flatten
-         result = on host, command, :acceptable_exit_codes => (0...127)
-         num_retries = 0
-         until desired_exit_codes.include?(result.exit_code)
-           sleep retry_interval
-           result = on host, command, :acceptable_exit_codes => (0...127)
-           num_retries += 1
-           if (num_retries > max_retries)
-             fail("Unable to #{desc}")
-           end
-         end
-       end
- 
-       #stops the puppet agent running on the host
-       def stop_agent(agent)
-         vardir = agent.puppet['vardir']
-         agent_running = true
-         while agent_running
-           result = on agent, "[ -e '#{vardir}/state/agent_catalog_run.lock' ]", :acceptable_exit_codes => [0,1]
-           agent_running = (result.exit_code == 0)
-           sleep 2 unless agent_running
-         end
-        
-         if agent['platform'].include?('solaris')
-           on(agent, '/usr/sbin/svcadm disable -s svc:/network/pe-puppet:default')
-         elsif agent['platform'].include?('aix')
-           on(agent, '/usr/bin/stopsrc -s pe-puppet')
-         elsif agent['platform'].include?('windows')
-           on(agent, 'net stop pe-puppet', :acceptable_exit_codes => [0,2])
-         else
-           # For the sake of not passing the PE version into this method,
-           # we just query the system to find out which service we want to
-           # stop
-           result = on agent, "[ -e /etc/init.d/pe-puppet-agent ]", :acceptable_exit_codes => [0,1]
-           service = (result.exit_code == 0) ? 'pe-puppet-agent' : 'pe-puppet'
-           on(agent, "/etc/init.d/#{service} stop")
-         end
-       end
- 
- 
-       #wait for a given host to appear in the dashboard
-       def wait_for_host_in_dashboard(host)
-         hostname = host.node_name
-         retry_command("Wait for #{hostname} to be in the console", dashboard, "! curl --sslv3 -k -I https://#{dashboard}/nodes/#{hostname} | grep '404 Not Found'")
-       end
- 
- 
-       #prompt the master to sign certs then check to confirm the cert for this host is signed
-       def sign_certificate(host)
-         return if [master, dashboard, database].include? host
- 
-         hostname = Regexp.escape host.node_name
- 
-         last_sleep = 0
-         next_sleep = 1
-         (0..10).each do |i|
-           fail_test("Failed to sign cert for #{hostname}") if i == 10
- 
-           on master, puppet("cert --sign --all"), :acceptable_exit_codes => [0,24]
-           break if on(master, puppet("cert --list --all")).stdout =~ /\+ "?#{hostname}"?/
-           sleep next_sleep
-           (last_sleep, next_sleep) = next_sleep, last_sleep+next_sleep
-         end
-       end
+
+      # This wraps the method `stub_hosts` and makes the stub specific to
+      # the forge alias.
+      #
+      # @see #stub_forge_on
+      def stub_forge
+        stub_forge_on(default)
+      end
+
+      def sleep_until_puppetdb_started(host)
+        curl_with_retries("start puppetdb", host, "http://localhost:8080", 0, 120)
+        curl_with_retries("start puppetdb (ssl)",
+                          host, "https://#{host.node_name}:8081", [35, 60])
+      end
+
+      def curl_with_retries(desc, host, url, desired_exit_codes, max_retries = 60, retry_interval = 1)
+        retry_command(desc, host, "curl #{url}", desired_exit_codes, max_retries, retry_interval)
+      end
+
+      def retry_command(desc, host, command, desired_exit_codes = 0, max_retries = 60, retry_interval = 1)
+        desired_exit_codes = [desired_exit_codes].flatten
+        result = on host, command, :acceptable_exit_codes => (0...127)
+        num_retries = 0
+        until desired_exit_codes.include?(result.exit_code)
+          sleep retry_interval
+          result = on host, command, :acceptable_exit_codes => (0...127)
+          num_retries += 1
+          if (num_retries > max_retries)
+            fail("Unable to #{desc}")
+          end
+        end
+      end
+
+      #stops the puppet agent running on the host
+      def stop_agent_on(agent)
+        vardir = agent.puppet['vardir']
+        agent_running = true
+        while agent_running
+          result = on agent, "[ -e '#{vardir}/state/agent_catalog_run.lock' ]", :acceptable_exit_codes => [0,1]
+          agent_running = (result.exit_code == 0)
+          sleep 2 unless agent_running
+        end
+       
+        if agent['platform'].include?('solaris')
+          on(agent, '/usr/sbin/svcadm disable -s svc:/network/pe-puppet:default')
+        elsif agent['platform'].include?('aix')
+          on(agent, '/usr/bin/stopsrc -s pe-puppet')
+        elsif agent['platform'].include?('windows')
+          on(agent, 'net stop pe-puppet', :acceptable_exit_codes => [0,2])
+        else
+          # For the sake of not passing the PE version into this method,
+          # we just query the system to find out which service we want to
+          # stop
+          result = on agent, "[ -e /etc/init.d/pe-puppet-agent ]", :acceptable_exit_codes => [0,1]
+          service = (result.exit_code == 0) ? 'pe-puppet-agent' : 'pe-puppet'
+          on(agent, "/etc/init.d/#{service} stop")
+        end
+      end
+
+      #stops the puppet agent running on the default host
+      # @see #stop_agent_on
+      def stop_agent
+        stop_agent_on(default)
+      end
+
+
+      #wait for a given host to appear in the dashboard
+      def wait_for_host_in_dashboard(host)
+        hostname = host.node_name
+        retry_command("Wait for #{hostname} to be in the console", dashboard, "! curl --sslv3 -k -I https://#{dashboard}/nodes/#{hostname} | grep '404 Not Found'")
+      end
+
+      # Ensure the host has requested a cert, then sign it
+      #
+      # @param [Host] host  The host to sign for
+      #
+      # @returns nil
+      # @raise [FailTest] if process times out
+      def sign_certificate_for(host)
+        if [master, dashboard, database].include? host
+
+          on host, puppet( 'agent -t' ), :acceptable_exit_codes => [0,1,2]
+          on master, puppet( "cert --allow-dns-alt-names sign #{host}" ), :acceptable_exit_codes => [0,24]
+
+        else
+
+          hostname = Regexp.escape host.node_name
+
+          last_sleep = 0
+          next_sleep = 1
+          (0..10).each do |i|
+            fail_test("Failed to sign cert for #{hostname}") if i == 10
+
+            on master, puppet("cert --sign --all"), :acceptable_exit_codes => [0,24]
+            break if on(master, puppet("cert --list --all")).stdout =~ /\+ "?#{hostname}"?/
+            sleep next_sleep
+            (last_sleep, next_sleep) = next_sleep, last_sleep+next_sleep
+          end
+
+        end
+      end
+
+      #prompt the master to sign certs then check to confirm the cert for the default host is signed
+      #@see #sign_certificate_for
+      def sign_certificate
+        sign_certificate_for(default)
+      end
+
     end
   end
 end