beaker 0.0.0

data/lib/beaker/dsl/structure.rb

@@ -0,0 +1,63 @@
+module Beaker
+  module DSL
+    # These are simple structural elements necessary for writing
+    # understandable tests and ensuring cleanup actions happen. If using a
+    # third party test runner they are unnecessary.
+    #
+    # To include this in your own test runner a method #logger should be
+    # available to yield a logger that implements
+    # {Beaker::Logger}'s interface. As well as a method
+    # #teardown_procs that yields an array.
+    #
+    # @example Structuring a test case.
+    #     test_name 'Look at me testing things!' do
+    #       teardown do
+    #         ...clean up actions...
+    #       end
+    #
+    #       step 'Prepare the things' do
+    #         ...setup steps...
+    #       end
+    #
+    #       step 'Test the things' do
+    #         ...tests...
+    #       end
+    #     end
+    #
+    module Structure
+
+      # Provides a method to help structure tests into coherent steps.
+      # @param [String] step_name The name of the step to be logged.
+      # @param [Proc] block The actions to be performed in this step.
+      # @api dsl
+      def step step_name, &block
+        logger.notify "\n  * #{step_name}\n"
+        yield if block_given?
+      end
+
+      # Provides a method to name tests.
+      #
+      # @param [String] my_name The name of the test to be logged.
+      # @param [Proc] block The actions to be performed during this test.
+      #
+      # @api dsl
+      def test_name my_name, &block
+        logger.notify "\n#{my_name}\n"
+        yield if block_given?
+      end
+
+      # Declare a teardown process that will be called after a test case is
+      # complete.
+      #
+      # @param block [Proc] block of code to execute during teardown
+      # @example Always remove /etc/puppet/modules
+      #   teardown do
+      #     on(master, puppet_resource('file', '/etc/puppet/modules',
+      #       'ensure=absent', 'purge=true'))
+      #   end
+      def teardown &block
+        @teardown_procs << block
+      end
+    end
+  end
+end

data/lib/beaker/dsl/wrappers.rb

@@ -0,0 +1,100 @@
+module Beaker
+  module DSL
+    # These are wrappers to equivalent {Beaker::Command} objects
+    # so that command line actions are executed within an appropriate and
+    # configurable environment.
+    #
+    # I find most of these adapters of suspicious value and have deprecated
+    # many of them.
+    module Wrappers
+
+      # This is hairy and because of legacy code it will take a bit more
+      # work to disentangle all of the things that are being passed into
+      # this catchall param.
+      #
+      # @api dsl
+      def facter(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        options['ENV'] ||= {}
+        options['ENV'] = options['ENV'].merge( Command::DEFAULT_GIT_ENV )
+        Command.new('facter', args, options )
+      end
+
+      # This is hairy and because of legacy code it will take a bit more
+      # work to disentangle all of the things that are being passed into
+      # this catchall param.
+      #
+      # @api dsl
+      def hiera(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        options['ENV'] ||= {}
+        options['ENV'] = options['ENV'].merge( Command::DEFAULT_GIT_ENV )
+        Command.new('hiera', args, options )
+      end
+
+      # @param [String] command_string A string of to be interpolated
+      #                                within the context of a host in
+      #                                question
+      # @example Usage
+      # @!visibility private
+      def host_command(command_string)
+        HostCommand.new(command_string)
+      end
+
+      # This is hairy and because of legacy code it will take a bit more
+      # work to disentangle all of the things that are being passed into
+      # this catchall param.
+      #
+      # @api dsl
+      def puppet(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        options['ENV'] ||= {}
+        options['ENV'] = options['ENV'].merge( Command::DEFAULT_GIT_ENV )
+        # we assume that an invocation with `puppet()` will have it's first argument
+        # a face or sub command
+        cmd = "puppet #{args.shift}"
+        Command.new( cmd, args, options )
+      end
+
+      # @!visibility private
+      def puppet_resource(*args)
+        puppet( 'resource', *args )
+      end
+
+      # @!visibility private
+      def puppet_doc(*args)
+        puppet( 'doc', *args )
+      end
+
+      # @!visibility private
+      def puppet_kick(*args)
+        puppet( 'kick', *args )
+      end
+
+      # @!visibility private
+      def puppet_cert(*args)
+        puppet( 'cert', *args )
+      end
+
+      # @!visibility private
+      def puppet_apply(*args)
+        puppet( 'apply', *args )
+      end
+
+      # @!visibility private
+      def puppet_master(*args)
+        puppet( 'master', *args )
+      end
+
+      # @!visibility private
+      def puppet_agent(*args)
+        puppet( 'agent', *args )
+      end
+
+      # @!visibility private
+      def puppet_filebucket(*args)
+        puppet( 'filebucket', *args )
+      end
+    end
+  end
+end

data/lib/beaker/host.rb

@@ -0,0 +1,193 @@
+require 'socket'
+require 'timeout'
+
+%w(command ssh_connection).each do |lib|
+  begin
+    require "beaker/#{lib}"
+  rescue LoadError
+    require File.expand_path(File.join(File.dirname(__FILE__), lib))
+  end
+end
+
+module Beaker
+  class Host
+
+    # This class providers array syntax for using puppet --configprint on a host
+    class PuppetConfigReader
+      def initialize(host, command)
+        @host = host
+        @command = command
+      end
+
+      def [](k)
+        cmd = PuppetCommand.new(@command, "--configprint #{k.to_s}")
+        @host.exec(cmd).stdout.strip
+      end
+    end
+
+    def self.create name, options, config
+      case config['HOSTS'][name]['platform']
+      when /windows/
+        Windows::Host.new name, options, config
+      when /aix/
+        Aix::Host.new name, options, config
+      else
+        Unix::Host.new name, options, config
+      end
+    end
+
+    attr_accessor :logger
+    attr_reader :name, :defaults
+    def initialize name, options, config
+      @logger = options[:logger]
+      @name, @options, @config = name, options.dup, config
+
+      # This is annoying and its because of drift/lack of enforcement/lack of having
+      # a explict relationship between our defaults, our setup steps and how they're
+      # related through 'type' and the differences between the assumption of our two
+      # configurations we have for many of our products
+      type = is_pe? ? :pe : :foss
+      @defaults = merge_defaults_for_type @config, type
+    end
+
+    def merge_defaults_for_type config, type
+      defaults = self.class.send "#{type}_defaults".to_sym
+      defaults.merge(config['CONFIG']).merge(config['HOSTS'][name])
+    end
+
+    def node_name
+      # TODO: might want to consider caching here; not doing it for now because
+      #  I haven't thought through all of the possible scenarios that could
+      #  cause the value to change after it had been cached.
+      result = puppet['node_name_value'].strip
+    end
+
+    def port_open? port
+      Timeout.timeout 1 do
+        begin
+          TCPSocket.new(reachable_name, port).close
+          return true
+        rescue Errno::ECONNREFUSED
+          return false
+        end
+      end
+    end
+
+    def up?
+      require 'socket'
+      begin
+        Socket.getaddrinfo( reachable_name, nil )
+        return true
+      rescue SocketError
+        return false
+      end
+    end
+
+    def reachable_name
+      self['ip'] || self['vmhostname'] || name
+    end
+
+    # Returning our PuppetConfigReader here allows users of the Host
+    # 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(command='agent')
+      PuppetConfigReader.new(self, command)
+    end
+
+    def []= k, v
+      @defaults[k] = v
+    end
+
+    def [] k
+      @defaults[k]
+    end
+
+    def has_key? k
+      @defaults.has_key?(k)
+    end
+
+    def to_str
+      @defaults['vmhostname'] || @name
+    end
+
+    def to_s
+      @defaults['vmhostname'] || @name
+    end
+
+    def + other
+      @name + other
+    end
+
+    def is_pe?
+      @config.is_pe?
+    end
+
+    def connection
+      @connection ||= SshConnection.connect( reachable_name,
+                                             self['user'],
+                                             self['ssh'] )
+    end
+
+    def close
+      @connection.close if @connection
+      @connection = nil
+    end
+
+    def exec command, options={}
+      # I've always found this confusing
+      cmdline = command.cmd_line(self)
+
+      if options[:silent]
+        output_callback = nil
+      else
+        if @defaults['vmhostname']
+          @logger.debug "\n#{self} (#{@name}) $ #{cmdline}"
+        else
+          @logger.debug "\n#{self} $ #{cmdline}"
+        end
+        output_callback = logger.method(:host_output)
+      end
+
+      unless $dry_run
+        # is this returning a result object?
+        # the options should come at the end of the method signature (rubyism)
+        # and they shouldn't be ssh specific
+        result = connection.execute(cmdline, options, output_callback)
+
+        unless options[:silent]
+          # What?
+          result.log(@logger)
+          # No, TestCase has the knowledge about whether its failed, checking acceptable
+          # exit codes at the host level and then raising...
+          # is it necessary to break execution??
+          unless result.exit_code_in?(options[:acceptable_exit_codes] || [0])
+            limit = 10
+            raise "Host '#{self}' exited with #{result.exit_code} running:\n #{cmdline}\nLast #{limit} lines of output were:\n#{result.formatted_output(limit)}"
+          end
+        end
+        # Danger, so we have to return this result?
+        result
+      end
+    end
+
+    def do_scp_to source, target, options
+
+      @logger.debug "localhost $ scp #{source} #{@name}:#{target} #{options.to_s}"
+      result = connection.scp_to(source, target, options, $dry_run)
+      return result
+    end
+
+    def do_scp_from source, target, options
+
+      @logger.debug "localhost $ scp #{@name}:#{source} #{target} #{options.to_s}"
+      result = connection.scp_from(source, target, options, $dry_run)
+      return result
+    end
+
+  end
+
+  require File.expand_path(File.join(File.dirname(__FILE__), 'host/windows'))
+  require File.expand_path(File.join(File.dirname(__FILE__), 'host/unix'))
+  require File.expand_path(File.join(File.dirname(__FILE__), 'host/aix'))
+end

data/lib/beaker/host/aix.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'host'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'command_factory'))
+
+module Aix
+  class Host < Unix::Host
+    require File.expand_path(File.join(File.dirname(__FILE__), 'aix', 'user'))
+    require File.expand_path(File.join(File.dirname(__FILE__), 'aix', 'group'))
+    require File.expand_path(File.join(File.dirname(__FILE__), 'aix', 'file'))
+
+    include Aix::User
+    include Aix::Group
+    include Aix::File
+
+  end
+end

data/lib/beaker/host/aix/file.rb

@@ -0,0 +1,16 @@
+module Aix::File
+  include Beaker::CommandFactory
+
+  def tmpfile(name)
+    execute("rndnum=${RANDOM} && touch /tmp/#{name}.${rndnum} && echo /tmp/#{name}.${rndnum}")
+  end
+
+  def tmpdir(name)
+    execute("rndnum=${RANDOM} && mkdir /tmp/#{name}.${rndnum} && echo /tmp/#{name}.${rndnum}")
+  end
+
+  def path_split(paths)
+    paths.split(':')
+  end
+
+end

data/lib/beaker/host/aix/group.rb

@@ -0,0 +1,35 @@
+module Aix::Group
+  include Beaker::CommandFactory
+
+  def group_list(&block)
+    execute("lsgroup -a ALL") do |result|
+      yield result if block_given?
+
+      result.stdout.lines.map(&:strip)
+    end
+  end
+
+  def group_get(name, &block)
+    execute("lsgroup #{name}") do |result|
+      fail_test "failed to get group #{name}" unless result.stdout =~ /^#{name} id/
+
+      yield result if block_given?
+    end
+  end
+
+  def group_gid(name)
+    execute("lsgroup -a id #{name}") do |result|
+      # Format is:
+      # staff id=500
+      result.stdout.split('=').last.strip
+    end
+  end
+
+  def group_present(name, &block)
+    execute("if ! lsgroup #{name}; then mkgroup #{name}; fi", {}, &block)
+  end
+
+  def group_absent(name, &block)
+    execute("if lsgroup #{name}; then rmgroup #{name}; fi", {}, &block)
+  end
+end

data/lib/beaker/host/aix/user.rb

@@ -0,0 +1,32 @@
+module Aix::User
+  include Beaker::CommandFactory
+
+  def user_list(&block)
+    execute("lsuser ALL") do |result|
+      users = []
+      result.stdout.each_line do |line|
+        users << line.split(' ')[0]
+      end
+
+      yield result if block_given?
+
+      users
+    end
+  end
+
+  def user_get(name, &block)
+    execute("lsuser #{name}") do |result|
+      fail_test "failed to get user #{name}" unless result.stdout =~  /^#{name} id/
+
+      yield result if block_given?
+    end
+  end
+
+  def user_present(name, &block)
+    execute("if ! lsuser #{name}; then mkuser #{name}; fi", {}, &block)
+  end
+
+  def user_absent(name, &block)
+    execute("if lsuser #{name}; then rmuser #{name}; fi", {}, &block)
+  end
+end