beaker 4.40.2 → 5.0.0

data/lib/beaker/host.rb

@@ -6,7 +6,7 @@ require 'rsync'
 require 'beaker/dsl/helpers'
 require 'beaker/dsl/patterns'
 
-[ 'command', 'ssh_connection', 'local_connection' ].each do |lib|
+%w[command ssh_connection local_connection].each do |lib|
   require "beaker/#{lib}"
 end
 
@@ -68,6 +68,7 @@ module Beaker
 
     attr_accessor :logger
     attr_reader :name, :host_hash, :options
+
     def initialize name, host_hash, options
       @logger = host_hash[:logger] || options[:logger]
       @name, @host_hash, @options = name.to_s, host_hash.dup, options.dup
@@ -103,12 +104,12 @@ module Beaker
     # Wait for a port on the host.  Useful for those occasions when you've called
     # host.reboot and want to avoid spam from subsequent SSH connections retrying
     # to connect from say retry_on()
-    def wait_for_port(port, attempts=15)
+    def wait_for_port(port, attempts = 15)
       @logger.debug("  Waiting for port #{port} ... ", false)
       start = Time.now
       done = repeat_fibonacci_style_for(attempts) { port_open?(port) }
       if done
-        @logger.debug('connected in %0.2f seconds' % (Time.now - start))
+        @logger.debug(format('connected in %0.2f seconds', (Time.now - start)))
       else
         @logger.debug('timeout')
       end
@@ -117,7 +118,7 @@ module Beaker
 
     def up?
       begin
-        Socket.getaddrinfo( reachable_name, nil )
+        Socket.getaddrinfo(reachable_name, nil)
         return true
       rescue SocketError
         return false
@@ -133,10 +134,10 @@ module Beaker
     # class to do things like `host.puppet['vardir']` to query the
     # 'main' section or, if they want the configuration for a
     # particular run type, `host.puppet('agent')['vardir']`
-    def puppet_configprint(command='agent')
+    def puppet_configprint(command = 'agent')
       PuppetConfigReader.new(self, command)
     end
-    alias_method :puppet, :puppet_configprint
+    alias puppet puppet_configprint
 
     def []= k, v
       host_hash[k] = v
@@ -181,35 +182,17 @@ module Beaker
     end
 
     def is_cygwin?
-      self.class == Windows::Host
+      self.instance_of?(Windows::Host)
     end
 
     def is_powershell?
-      self.class == PSWindows::Host
+      self.instance_of?(PSWindows::Host)
     end
 
     def platform
       self['platform']
     end
 
-    # True if this is a pe run, or if the host has had a 'use-service' property set.
-    def use_service_scripts?
-      is_pe? || self['use-service']
-    end
-
-    # Mirrors the true/false value of the host's 'graceful-restarts' property,
-    # or falls back to the value of +is_using_passenger?+ if
-    # 'graceful-restarts' is nil, but only if this is not a PE run (foss only).
-    def graceful_restarts?
-      graceful =
-      if !self['graceful-restarts'].nil?
-        self['graceful-restarts']
-      else
-        !is_pe? && is_using_passenger?
-      end
-      graceful
-    end
-
     # Returns true if the host is running in FIPS mode.
     def fips_mode?
       if self.file_exist?('/proc/sys/crypto/fips_enabled')
@@ -223,25 +206,6 @@ module Beaker
       end
     end
 
-    # Modifies the host settings to indicate that it will be using passenger service scripts,
-    # (apache2) by default.  Does nothing if this is a PE host, since it is already using
-    # passenger.
-    # @param [String] puppetservice Name of the service script that should be
-    #   called to stop/startPuppet on this host.  Defaults to 'apache2'.
-    def uses_passenger!(puppetservice = 'apache2')
-      if !is_pe?
-        self['passenger'] = true
-        self['puppetservice'] = puppetservice
-        self['use-service'] = true
-      end
-      return true
-    end
-
-    # True if this is a PE run, or if the host's 'passenger' property has been set.
-    def is_using_passenger?
-      is_pe? || self['passenger']
-    end
-
     def log_prefix
       if host_hash['vmhostname']
         "#{self} (#{@name})"
@@ -250,7 +214,7 @@ module Beaker
       end
     end
 
-    #Determine the ip address of this host
+    # Determine the ip address of this host
     def get_ip
       @logger.warn("Uh oh, this should be handled by sub-classes but hasn't been")
     end
@@ -263,27 +227,25 @@ module Beaker
           return self[:instance].ip_address
         elsif self[:hypervisor] == 'openstack' && self[:ip]
           return self[:ip]
-        else
+        elsif self.instance_of?(Windows::Host)
           # In the case of using ec2 instances with the --no-provision flag, the ec2
           # instance object does not exist and we should just use the curl endpoint
           # specified here:
           # http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing.html
-          if self.instance_of?(Windows::Host)
           execute("wget http://169.254.169.254/latest/meta-data/public-ipv4").strip
-          else
+        else
           execute("curl http://169.254.169.254/latest/meta-data/public-ipv4").strip
-          end
         end
       end
     end
 
-    #Return the ip address of this host
-    #Always pull fresh, because this can sometimes change
+    # Return the ip address of this host
+    # Always pull fresh, because this can sometimes change
     def ip
       self['ip'] = get_public_ip || get_ip
     end
 
-    #@return [Boolean] true if x86_64, false otherwise
+    # @return [Boolean] true if x86_64, false otherwise
     def is_x86_64?
       @x86_64 ||= determine_if_x86_64
     end
@@ -291,23 +253,17 @@ module Beaker
     def connection
       # create new connection object if necessary
       if self['hypervisor'] == 'none' && @name == 'localhost'
-        @connection ||= LocalConnection.connect( { :ssh_env_file => self['ssh_env_file'], :logger => @logger })
+        @connection ||= LocalConnection.connect({ :ssh_env_file => self['ssh_env_file'], :logger => @logger })
         return @connection
       end
 
-      @connection ||= SshConnection.connect( { :ip => self['ip'], :vmhostname => self['vmhostname'], :hostname => @name },
-                                             self['user'],
-                                             self['ssh'], { :logger => @logger, :ssh_connection_preference => self[:ssh_connection_preference]} )
+      @connection ||= SshConnection.connect({ :ip => self['ip'], :vmhostname => self['vmhostname'], :hostname => @name },
+                                            self['user'],
+                                            self['ssh'], { :logger => @logger, :ssh_connection_preference => self[:ssh_connection_preference] })
       # update connection information
-      if self['ip'] && (@connection.ip != self['ip'])
-        @connection.ip = self['ip']
-      end
-      if self['vmhostname'] && (@connection.vmhostname != self['vmhostname'])
-        @connection.vmhostname = self['vmhostname']
-      end
-      if @name && (@connection.hostname != @name)
-        @connection.hostname = @name
-      end
+      @connection.ip = self['ip'] if self['ip'] && (@connection.ip != self['ip'])
+      @connection.vmhostname = self['vmhostname'] if self['vmhostname'] && (@connection.vmhostname != self['vmhostname'])
+      @connection.hostname = @name if @name && (@connection.hostname != @name)
       @connection
     end
 
@@ -322,7 +278,7 @@ module Beaker
       @connection = nil
     end
 
-    def exec command, options={}
+    def exec command, options = {}
       result = nil
       # I've always found this confusing
       cmdline = command.cmd_line(self)
@@ -341,11 +297,11 @@ module Beaker
         output_callback = nil
       else
         @logger.debug "\n#{log_prefix} #{Time.new.strftime('%H:%M:%S')}$ #{cmdline}"
-        if @options[:color_host_output]
-          output_callback = logger.method(:color_host_output)
-        else
-          output_callback = logger.method(:host_output)
-        end
+        output_callback = if @options[:color_host_output]
+                            logger.method(:color_host_output)
+                          else
+                            logger.method(:host_output)
+                          end
       end
 
       unless options[:dry_run]
@@ -353,16 +309,14 @@ module Beaker
         # the options should come at the end of the method signature (rubyism)
         # and they shouldn't be ssh specific
 
-        seconds = Benchmark.realtime {
+        seconds = Benchmark.realtime do
           @logger.with_indent do
             result = connection.execute(cmdline, options, output_callback)
           end
-        }
-
-        if not options[:silent]
-          @logger.debug "\n#{log_prefix} executed in %0.2f seconds" % seconds
         end
 
+        @logger.debug "\n#{log_prefix} executed in %0.2f seconds" % seconds if not options[:silent]
+
         if options[:reset_connection]
           # Expect the connection to fail hard and possibly take a long time timeout.
           # Pre-emptively reset it so we don't wait forever.
@@ -378,11 +332,12 @@ module Beaker
             raise CommandFailure, "Host '#{self}' connection failure running:\n #{cmdline}\nLast #{@options[:trace_limit]} lines of output were:\n#{result.formatted_output(@options[:trace_limit])}"
 
           end
+
           if options[:expect_connection_failure] && result.exit_code
             # should have had a connection failure, but didn't
             # wait to see if the connection failure will be generation, otherwise raise error
             if not connection.wait_for_connection_failure(options, output_callback)
-              raise CommandFailure,  "Host '#{self}' should have resulted in a connection failure running:\n #{cmdline}\nLast #{@options[:trace_limit]} lines of output were:\n#{result.formatted_output(@options[:trace_limit])}"
+              raise CommandFailure, "Host '#{self}' should have resulted in a connection failure running:\n #{cmdline}\nLast #{@options[:trace_limit]} lines of output were:\n#{result.formatted_output(@options[:trace_limit])}"
             end
           end
           # No, TestCase has the knowledge about whether its failed, checking acceptable
@@ -418,7 +373,7 @@ module Beaker
     #   do_scp_to('source/file.rb', 'target', { :ignore => 'file.rb' }
     #   -> will result in not files copyed to the host, all are ignored
     def do_scp_to source, target_path, options
-      target = self.scp_path( target_path )
+      target = self.scp_path(target_path)
 
       # use the value of :dry_run passed to the method unless
       # undefined, then use parsed @options hash.
@@ -445,9 +400,8 @@ module Beaker
       end
 
       # either a single file, or a directory with no ignores
-      if not File.file?(source) and not File.directory?(source)
-        raise IOError, "No such file or directory - #{source}"
-      end
+      raise IOError, "No such file or directory - #{source}" if not File.file?(source) and not File.directory?(source)
+
       if File.file?(source) or (File.directory?(source) and not has_ignore)
         source_file = source
         if has_ignore and ignore_re&.match?(source)
@@ -462,21 +416,21 @@ module Beaker
         end
       else # a directory with ignores
         dir_source = Dir.glob("#{source}/**/*").reject do |f|
-          ignore_re&.match?(f.gsub(/\A#{Regexp.escape(source)}/, '')) #only match against subdirs, not full path
+          ignore_re&.match?(f.gsub(/\A#{Regexp.escape(source)}/, '')) # only match against subdirs, not full path
         end
-        @logger.trace "After rejecting ignored files/dirs, going to scp [#{dir_source.join(", ")}]"
+        @logger.trace "After rejecting ignored files/dirs, going to scp [#{dir_source.join(', ')}]"
 
         # create necessary directory structure on host
         # run this quietly (no STDOUT)
         @logger.quiet(true)
-        required_dirs = (dir_source.map{ | dir | File.dirname(dir) }).uniq
+        required_dirs = (dir_source.map { |dir| File.dirname(dir) }).uniq
         require 'pathname'
         required_dirs.each do |dir|
           dir_path = Pathname.new(dir)
           if dir_path.absolute? and (File.dirname(File.absolute_path(source)).to_s != '/')
             mkdir_p(File.join(target, dir.gsub(/#{Regexp.escape(File.dirname(File.absolute_path(source)))}/, '')))
           else
-            mkdir_p( File.join(target, dir) )
+            mkdir_p(File.join(target, dir))
           end
         end
         @logger.quiet(false)
@@ -487,17 +441,17 @@ module Beaker
           next if File.directory?(s)
 
           s_path = Pathname.new(s)
-          if s_path.absolute? and (File.dirname(File.absolute_path(source)).to_s != '/')
-            file_path = File.join(target, File.dirname(s).gsub(/#{Regexp.escape(File.dirname(File.absolute_path(source)))}/,''))
-          else
-            file_path = File.join(target, File.dirname(s))
-          end
+          file_path = if s_path.absolute? and (File.dirname(File.absolute_path(source)).to_s != '/')
+                        File.join(target, File.dirname(s).gsub(/#{Regexp.escape(File.dirname(File.absolute_path(source)))}/, ''))
+                      else
+                        File.join(target, File.dirname(s))
+                      end
           result = connection.scp_to(s, file_path, options)
           @logger.trace result.stdout
         end
       end
 
-      self.scp_post_operations( target, target_path )
+      self.scp_post_operations(target, target_path)
       return result
     end
 
@@ -509,7 +463,7 @@ module Beaker
       if options[:dry_run]
         scp_cmd = "scp #{@name}:#{source} #{target}"
         @logger.debug "\n Running in :dry_run mode. localhost $ #{scp_cmd} not executed."
-        return  NullResult.new(self, scp_cmd)
+        return NullResult.new(self, scp_cmd)
       end
 
       @logger.debug "localhost $ scp #{@name}:#{source} #{target}"
@@ -530,18 +484,16 @@ module Beaker
       rsync_args = []
       ssh_args = []
 
-      if not File.file?(from_path) and not File.directory?(from_path)
-        raise IOError, "No such file or directory - #{from_path}"
-      end
+      raise IOError, "No such file or directory - #{from_path}" if not File.file?(from_path) and not File.directory?(from_path)
 
       # We enable achieve mode and compression
       rsync_args << "-az"
 
-      if not self['user']
-        user = "root"
-      else
-        user = self['user']
-      end
+      user = if not self['user']
+               "root"
+             else
+               self['user']
+             end
       hostname_with_user = "#{user}@#{reachable_name}"
 
       Rsync.host = hostname_with_user
@@ -559,62 +511,53 @@ module Beaker
 
       if filesystem_ssh_config
         ssh_args << "-F #{filesystem_ssh_config}"
-      else
-        if ssh_opts.has_key?('keys') and
+      elsif ssh_opts.has_key?('keys') and
             ssh_opts.has_key?('auth_methods') and
             ssh_opts['auth_methods'].include?('publickey')
+        key = Array(ssh_opts['keys']).find do |k|
+          File.exist?(k)
+        end
 
-          # find the first SSH key that exists
-          key = Array(ssh_opts['keys']).find do |k|
-              File.exist?(k)
-          end
-
-          if key
-            # rsync doesn't always play nice with tilde, so be sure to expand first
-            ssh_args << "-i #{File.expand_path(key)}"
-          end
+        if key
+          # rsync doesn't always play nice with tilde, so be sure to expand first
+          ssh_args << "-i #{File.expand_path(key)}"
         end
-      end
 
-      if ssh_opts.has_key?(:port)
-        ssh_args << "-p #{ssh_opts[:port]}"
+        # find the first SSH key that exists
       end
 
+      ssh_args << "-p #{ssh_opts[:port]}" if ssh_opts.has_key?(:port)
+
       # We disable prompt when host isn't known
       ssh_args << "-o 'StrictHostKeyChecking no'"
 
-      if not ssh_args.empty?
-        rsync_args << "-e \"ssh #{ssh_args.join(' ')}\""
-      end
+      rsync_args << "-e \"ssh #{ssh_args.join(' ')}\"" if not ssh_args.empty?
 
-      if opts.has_key?(:ignore) and not opts[:ignore].empty?
-        rsync_args << opts[:ignore].map { |value| "--exclude '#{value}'" }.join(' ')
-      end
+      rsync_args << opts[:ignore].map { |value| "--exclude '#{value}'" }.join(' ') if opts.has_key?(:ignore) and not opts[:ignore].empty?
 
       # We assume that the *contents* of the directory 'from_path' needs to be
       # copied into the directory 'to_path'
-      if File.directory?(from_path) and not from_path.end_with?('/')
-        from_path += '/'
-      end
+      from_path += '/' if File.directory?(from_path) and not from_path.end_with?('/')
 
       @logger.notify "rsync: localhost:#{from_path} to #{hostname_with_user}:#{to_path} {:ignore => #{opts[:ignore]}}"
       result = Rsync.run(from_path, to_path, rsync_args)
       @logger.debug("rsync returned #{result.inspect}")
 
       return result if result.success?
+
       raise Beaker::Host::CommandFailure, result.error
     end
   end
 
-  [
-    'unix',
-    'aix',
-    'mac',
-    'freebsd',
-    'windows',
-    'pswindows',
-    'eos',
-    'cisco',
+  %w[
+    unix
+    aix
+    mac
+    freebsd
+    windows
+    pswindows
+    eos
+    cisco
   ].each do |lib|
     require "beaker/host/#{lib}"
   end