Module: Beaker::DSL::Helpers::PuppetHelpers

Included in:
BeakerPuppet::Helpers
Defined in:
lib/beaker-puppet/helpers/puppet_helpers.rb

Overview

Methods that help you interact with your puppet installation, puppet must be installed for these methods to execute correctly

Instance Method Summary collapse

Instance Method Details

#apply_manifest(manifest, opts = {}, &block) ⇒ Object

Runs ‘puppet apply’ on default host, piping manifest through stdin

See Also:



527
528
529
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 527

def apply_manifest(manifest, opts = {}, &block)
  apply_manifest_on(default, manifest, opts, &block)
end

#apply_manifest_on(host, manifest, opts = {}, &block) ⇒ Array<Result>, ...

Runs ‘puppet apply’ on a remote host, piping manifest through stdin

Parameters:

  • host (Host) —

    The host that this command should be run on

  • manifest (String) —

    The puppet manifest to apply

  • opts (Hash{Symbol=>String}) (defaults to: {}) —

    Options to alter execution.

  • block (Block) —

    This method will yield to a block of code passed by the caller; this can be used for additional validation, etc.

Options Hash (opts):

  • :silent (Boolean) — default: false —

    Do not produce log output

  • :acceptable_exit_codes (Array<Fixnum>) — default: [0] —

    An array (or range) of integer exit codes that should be considered acceptable. An error will be thrown if the exit code does not match one of the values in this list.

  • :accept_all_exit_codes (Boolean) — default: false —

    Consider all exit codes as passing.

  • :dry_run (Boolean) — default: false —

    Do not actually execute any commands on the SUT

  • :stdin (String) — default: nil —

    Input to be provided during command execution on the SUT.

  • :pty (Boolean) — default: false —

    Execute this command in a pseudoterminal.

  • :expect_connection_failure (Boolean) — default: false —

    Expect this command to result in a connection failure, reconnect and continue execution.

  • :environment (Hash{String=>String}) — default: {} —

    These will be treated as extra environment variables that should be set before running the command.

  • :parseonly (Boolean) — default: false —

    If this key is true, the “–parseonly” command line parameter will be passed to the ‘puppet apply’ command.

  • :trace (Boolean) — default: false —

    If this key exists in the Hash, the “–trace” command line parameter will be passed to the ‘puppet apply’ command.

  • :acceptable_exit_codes (Array<Integer>) — default: [0] —

    The list of exit codes that will NOT raise an error when found upon command completion. If provided, these values will be combined with those used in :catch_failures and :expect_failures to create the full list of passing exit codes.

  • :environment (Hash) —

    Additional environment variables to be passed to the ‘puppet apply’ command

  • :catch_failures (Boolean) — default: false —

    By default ‘puppet –apply` will exit with 0, which does not count as a test failure, even if there were errors or changes when applying the manifest. This option enables detailed exit codes and causes a test failure if `puppet –apply` indicates there was a failure during its execution.

  • :catch_changes (Boolean) — default: false —

    This option enables detailed exit codes and causes a test failure if ‘puppet –apply` indicates that there were changes or failures during its execution.

  • :expect_changes (Boolean) — default: false —

    This option enables detailed exit codes and causes a test failure if ‘puppet –apply` indicates that there were no resource changes during its execution.

  • :expect_failures (Boolean) — default: false —

    This option enables detailed exit codes and causes a test failure if ‘puppet –apply` indicates there were no failure during its execution.

  • :future_parser (Boolean) — default: false —

    This option enables the future parser option that is available from Puppet verion 3.2 By default it will use the ‘current’ parser.

  • :noop (Boolean) — default: false —

    If this option exists, the the “–noop” command line parameter will be passed to the ‘puppet apply’ command.

  • :modulepath (String) —

    The search path for modules, as a list of directories separated by the system path separator character. (The POSIX path separator is ‘:’, and the Windows path separator is ‘;’.)

  • :debug (String) — default: false —

    If this option exists, the “–debug” command line parameter will be passed to the ‘puppet apply’ command.

  • :run_in_parallel (Boolean) —

    Whether to run on each host in parallel.

Returns:

  • (Array<Result>, Result, nil) —

    An array of results, a result object, or nil. Check Shared::HostManager#run_block_on for more details on this.



449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 449

def apply_manifest_on(host, manifest, opts = {}, &block)
  block_on host, opts do | host |
    on_options = {}
    on_options[:acceptable_exit_codes] = Array(opts[:acceptable_exit_codes])

    puppet_apply_opts = {}
    if opts[:debug]
      puppet_apply_opts[:debug] = nil
    else
      puppet_apply_opts[:verbose] = nil
    end
    puppet_apply_opts[:parseonly] = nil if opts[:parseonly]
    puppet_apply_opts[:trace] = nil if opts[:trace]
    puppet_apply_opts[:parser] = 'future' if opts[:future_parser]
    puppet_apply_opts[:modulepath] = opts[:modulepath] if opts[:modulepath]
    puppet_apply_opts[:noop] = nil if opts[:noop]

    # From puppet help:
    # "... an exit code of '2' means there were changes, an exit code of
    # '4' means there were failures during the transaction, and an exit
    # code of '6' means there were both changes and failures."
    if [opts[:catch_changes],opts[:catch_failures],opts[:expect_failures],opts[:expect_changes]].compact.length > 1
      raise(ArgumentError,
            'Cannot specify more than one of `catch_failures`, ' +
            '`catch_changes`, `expect_failures`, or `expect_changes` ' +
            'for a single manifest')
    end

    if opts[:catch_changes]
      puppet_apply_opts['detailed-exitcodes'] = nil

      # We're after idempotency so allow exit code 0 only.
      on_options[:acceptable_exit_codes] |= [0]
    elsif opts[:catch_failures]
      puppet_apply_opts['detailed-exitcodes'] = nil

      # We're after only complete success so allow exit codes 0 and 2 only.
      on_options[:acceptable_exit_codes] |= [0, 2]
    elsif opts[:expect_failures]
      puppet_apply_opts['detailed-exitcodes'] = nil

      # We're after failures specifically so allow exit codes 1, 4, and 6 only.
      on_options[:acceptable_exit_codes] |= [1, 4, 6]
    elsif opts[:expect_changes]
      puppet_apply_opts['detailed-exitcodes'] = nil

      # We're after changes specifically so allow exit code 2 only.
      on_options[:acceptable_exit_codes] |= [2]
    else
      # Either use the provided acceptable_exit_codes or default to [0]
      on_options[:acceptable_exit_codes] |= [0]
    end

    # Not really thrilled with this implementation, might want to improve it
    # later. Basically, there is a magic trick in the constructor of
    # PuppetCommand which allows you to pass in a Hash for the last value in
    # the *args Array; if you do so, it will be treated specially. So, here
    # we check to see if our caller passed us a hash of environment variables
    # that they want to set for the puppet command. If so, we set the final
    # value of *args to a new hash with just one entry (the value of which
    # is our environment variables hash)
    if opts.has_key?(:environment)
      puppet_apply_opts['ENV'] = opts[:environment]
    end

    file_path = host.tmpfile('apply_manifest.pp')
    create_remote_file(host, file_path, manifest + "\n")

    if host[:default_apply_opts].respond_to? :merge
      puppet_apply_opts = host[:default_apply_opts].merge( puppet_apply_opts )
    end

    on host, puppet('apply', file_path, puppet_apply_opts), on_options, &block
  end
end

#create_tmpdir_for_user(host, name = '/tmp/beaker', user = nil) ⇒ String

Create a temp directory on remote host with a user. Default user is puppet master user.

the ownership of a temp directory. directory. Default value is ‘/tmp/beaker’ directory. If no username is specified, use ‘puppet config print user –section master` to obtain username from master. Raise RuntimeError if this puppet command returns a non-zero exit code.

Parameters:

  • host (Host) —

    A single remote host on which to create and adjust

  • name (String) (defaults to: '/tmp/beaker') —

    A remote path prefix for the new temp

  • user (String) (defaults to: nil) —

    The name of user that should own the temp

Returns:

  • (String) —

    Returns the name of the newly-created dir.



881
882
883
884
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 881

def create_tmpdir_for_user(host, name='/tmp/beaker', user=nil)
  user ||= puppet_config(host, 'user', section: 'master')
  create_tmpdir_on(host, name, user)
end

#ipv4_regex ⇒ Object

Return the regular expression pattern for an IPv4 address



14
15
16
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 14

def ipv4_regex
  return /(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)/
end

#puppet_config(host, setting, section: nil) ⇒ Object

Read a setting from the puppet master config

Parameters:

  • host (Host) —

    The host

  • setting (String) —

    The setting to read



56
57
58
59
60
61
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 56

def puppet_config(host, setting, section: nil)
  command = "config print #{setting}"
  command += " --section #{section}" if section

  on(host, puppet(command)).stdout.strip
end

#puppet_group(host) ⇒ Object

Note:

This method assumes puppet is installed on the host.

Return the name of the puppet group.

Parameters:

  • host (Host) —

    One object that acts like a Beaker::Host



79
80
81
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 79

def puppet_group(host)
  puppet_config(host, 'group', section: 'master')
end

#puppet_user(host) ⇒ Object

Note:

This method assumes puppet is installed on the host.

Return the name of the puppet user.

Parameters:

  • host (Host) —

    One object that acts like a Beaker::Host



69
70
71
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 69

def puppet_user(host)
  puppet_config(host, 'user', section: 'master')
end

#resolve_hostname_on(host, hostname) ⇒ String?

Return the IP address that given hostname returns when resolved on the given host.

@ param [Host] host One object that acts like a Beaker::Host @ param [String] hostname The hostname to perform a DNS resolution on

Returns:

  • (String, nil) —

    An IP address, or nil.



25
26
27
28
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 25

def resolve_hostname_on(host, hostname)
  match = curl_on(host, "--verbose #{hostname}", :accept_all_exit_codes => true).stderr.match(ipv4_regex)
  return match ? match[0] : nil
end

#run_agent_on(host, arg = '--no-daemonize --verbose --onetime --test', options = {}, &block) ⇒ Object

Deprecated. 


532
533
534
535
536
537
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 532

def run_agent_on(host, arg='--no-daemonize --verbose --onetime --test',
                 options={}, &block)
  block_on host do | host |
    on host, puppet_agent(arg), options, &block
  end
end

#sign_certificate ⇒ Object

prompt the master to sign certs then check to confirm the cert for the default host is signed

See Also:



864
865
866
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 864

def sign_certificate
  sign_certificate_for(default)
end

#sign_certificate_for(host = []) ⇒ Object

Ensure the host has requested a cert, then sign it

Parameters:

  • host (Host, Array<Host>, String, Symbol) (defaults to: []) —

    One or more hosts, or a role (String or Symbol) that identifies one or more hosts to validate certificate signing. No argument, or an empty array means no validation of success for specific hosts will be performed. This will always execute ‘cert –sign –all –allow-dns-alt-names’ even for a single host.

Returns:

  • nil

Raises:

  • (FailTest) —

    if process times out



822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 822

def sign_certificate_for(host = [])
  hostnames = []
  hosts = host.is_a?(Array) ? host : [host]
  hosts.each{ |current_host|
    if [master, dashboard, database].include? current_host

      on current_host, puppet( 'agent -t' ), :acceptable_exit_codes => [0,1,2]
      on master, puppet( "cert --allow-dns-alt-names sign #{current_host}" ), :acceptable_exit_codes => [0,24]

    else
      hostnames << Regexp.escape( current_host.node_name )
    end
  }
  if hostnames.size < 1
    on master, puppet("cert --sign --all --allow-dns-alt-names"),
       :acceptable_exit_codes => [0,24]
    return
  end
  while hostnames.size > 0
    last_sleep = 0
    next_sleep = 1
    (0..10).each do |i|
      if i == 10
        fail_test("Failed to sign cert for #{hostnames}")
        hostnames.clear
      end
      on master, puppet("cert --sign --all --allow-dns-alt-names"), :acceptable_exit_codes => [0,24]
      out = on(master, puppet("cert --list --all")).stdout
      if hostnames.all? { |hostname| out =~ /\+ "?#{hostname}"?/ }
        hostnames.clear
        break
      end

      sleep next_sleep
      (last_sleep, next_sleep) = next_sleep, last_sleep+next_sleep
    end
  end
  host
end

#sleep_until_nc_started(host, port = nil) ⇒ Result

Waits until a successful curl check has happaned against node classifier

Parameters:

  • host (Host) —

    Host node classifier is on

  • port (Fixnum) (defaults to: nil) —

    Port to make the HTTPS status check over

Returns:

  • (Result) —

    Result of the last HTTPS status check



743
744
745
746
747
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 743

def sleep_until_nc_started(host, port = nil)
  port = options[:nodeclassifier_port] if port.nil?
  curl_with_retries("start nodeclassifier (ssl)",
                    host, "https://#{host.node_name}:#{port}", [35, 60])
end

#sleep_until_puppetdb_started(host, nonssl_port = nil, ssl_port = nil) ⇒ Result

Waits until a successful curl check has happened against puppetdb

Parameters:

  • host (Host) —

    Host puppetdb is on

  • nonssl_port (Fixnum) (defaults to: nil) —

    Port to make the HTTP status check over

  • ssl_port (Fixnum) (defaults to: nil) —

    Port to make the HTTPS status check over

Returns:

  • (Result) —

    Result of the last HTTPS status check



705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 705

def sleep_until_puppetdb_started(host, nonssl_port = nil, ssl_port = nil)
  nonssl_port = options[:puppetdb_port_nonssl] if nonssl_port.nil?
  ssl_port = options[:puppetdb_port_ssl] if ssl_port.nil?
  pe_ver = host['pe_ver'] || '0'
  if version_is_less(pe_ver, '2016.1.0') then
    # the status endpoint was introduced in puppetdb 4.0. The earliest
    # PE release with the 4.x pdb version was 2016.1.0
    endpoint = 'pdb/meta/v1/version'
    expected_regex = '\"version\" \{0,\}: \{0,\}\"[0-9]\{1,\}\.[0-9]\{1,\}\.[0-9]\{1,\}\"'
  else
    endpoint = 'status/v1/services/puppetdb-status'
    expected_regex = '\"state\" \{0,\}: \{0,\}\"running\"'
  end
  retry_on(host,
           "curl -m 1 http://localhost:#{nonssl_port}/#{endpoint} | grep '#{expected_regex}'",
           {:max_retries => 120})
  curl_with_retries("start puppetdb (ssl)",
                    host, "https://#{host.node_name}:#{ssl_port}", [35, 60])
end

#sleep_until_puppetserver_started(host, port = nil) ⇒ Result

Waits until a successful curl check has happened against puppetserver

Parameters:

  • host (Host) —

    Host puppetserver is on

  • port (Fixnum) (defaults to: nil) —

    Port to make the HTTPS status check over

Returns:

  • (Result) —

    Result of the last HTTPS status check



731
732
733
734
735
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 731

def sleep_until_puppetserver_started(host, port = nil)
  port = options[:puppetserver_port] if port.nil?
  curl_with_retries("start puppetserver (ssl)",
                    host, "https://#{host.node_name}:#{port}", [35, 60])
end

#stop_agent ⇒ Object

stops the puppet agent running on the default host

See Also:



796
797
798
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 796

def stop_agent
  stop_agent_on(default)
end

#stop_agent_on(agent, opts = {}) ⇒ Object

stops the puppet agent running on the host

Parameters:

  • agent (Host, Array<Host>, String, Symbol) —

    One or more hosts to act upon, or a role (String or Symbol) that identifies one or more hosts.

  • opts (Hash{Symbol=>String}) (defaults to: {}) —

    Options to alter execution.

Options Hash (opts):

  • :run_in_parallel (Boolean) —

    Whether to run on each host in parallel.



754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 754

def stop_agent_on(agent, opts = {})
  block_on agent, opts do | host |
    vardir = host.puppet_configprint['vardir']

    # In 4.0 this was changed to just be `puppet`
    agent_service = 'puppet'
    if !aio_version?(host)
      # The agent service is `pe-puppet` everywhere EXCEPT certain linux distros on PE 2.8
      # In all the case that it is different, this init script will exist. So we can assume
      # that if the script doesn't exist, we should just use `pe-puppet`
      agent_service = 'pe-puppet-agent'
      agent_service = 'pe-puppet' unless host.file_exist?('/etc/init.d/pe-puppet-agent')
    end

    # Under a number of stupid circumstances, we can't stop the
    # agent using puppet.  This is usually because of issues with
    # the init script or system on that particular configuration.
    avoid_puppet_at_all_costs = false
    avoid_puppet_at_all_costs ||= host['platform'] =~ /el-4/
    avoid_puppet_at_all_costs ||= host['pe_ver'] && version_is_less(host['pe_ver'], '3.2') && host['platform'] =~ /sles/

    if avoid_puppet_at_all_costs
      # When upgrading, puppet is already stopped. On EL4, this causes an exit code of '1'
      on host, "/etc/init.d/#{agent_service} stop", :acceptable_exit_codes => [0, 1]
    else
      on host, puppet_resource('service', agent_service, 'ensure=stopped')
    end

    #Ensure that a puppet run that was started before the last lock check is completed
    agent_running = true
    while agent_running
      agent_running = host.file_exist?("#{vardir}/state/agent_catalog_run.lock")
      if agent_running
        sleep 2
      end
    end

  end
end

#stub_forge(forge_host = nil) ⇒ Object

Deprecated.

this method should not be used because stubbing the host

This wraps the method ‘stub_hosts` and makes the stub specific to the forge alias.

breaks TLS validation.

See Also:



692
693
694
695
696
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 692

def stub_forge(forge_host = nil)
  #use global options hash
  forge_host ||= options[:forge_host]
  stub_forge_on(default, forge_host)
end

#stub_forge_on(machine, forge_host = nil) ⇒ Object

Deprecated.

this method should not be used because stubbing the host

This wraps the method ‘stub_hosts_on` and makes the stub specific to the forge alias.

forge api v1 canonical source is forge.puppetlabs.com forge api v3 canonical source is forgeapi.puppetlabs.com

breaks TLS validation.

Parameters:

  • machine (String) —

    the host to perform the stub on

  • forge_host (String) (defaults to: nil) —

    The URL to use as the forge alias, will default to using :forge_host in the global options hash



642
643
644
645
646
647
648
649
650
651
652
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 642

def stub_forge_on(machine, forge_host = nil)
  #use global options hash
  primary_forge_name = 'forge.puppetlabs.com'
  forge_host ||= options[:forge_host]
  forge_ip = resolve_hostname_on(machine, forge_host)
  raise "Failed to resolve forge host '#{forge_host}'" unless forge_ip
  @forge_ip ||= forge_ip
  block_on machine do | host |
    stub_hosts_on(host, {primary_forge_name => @forge_ip}, {primary_forge_name => ['forge.puppet.com','forgeapi.puppetlabs.com','forgeapi.puppet.com']})
  end
end

#stub_hosts(ip_spec) ⇒ Object

This method accepts a block and using the puppet resource ‘host’ will setup host aliases before and after that block on the default host

Examples:

Stub puppetlabs.com on the default host to 127.0.0.1

stub_hosts('puppetlabs.com' => '127.0.0.1')

See Also:



626
627
628
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 626

def stub_hosts(ip_spec)
  stub_hosts_on(default, ip_spec)
end

#stub_hosts_on(machine, ip_spec, alias_spec = {}) ⇒ Object

This method using the puppet resource ‘host’ will setup host aliases and register the remove of host aliases via Beaker::TestCase#teardown

A teardown step is also added to make sure unstubbing of the host is removed always.

Examples:

Stub puppetlabs.com on the master to 127.0.0.1 with an alias example.com

stub_hosts_on(master, {'puppetlabs.com' => '127.0.0.1'}, {'puppetlabs.com' => ['example.com']})

Parameters:

  • machine (Host, Array<Host>, String, Symbol) —

    One or more hosts to act upon, or a role (String or Symbol) that identifies one or more hosts.

  • ip_spec (Hash{String=>String}) —

    a hash containing the host to ip mappings

  • alias_spec (Hash{String=>Array[String]] an hash containing the host to alias(es) mappings to apply) (defaults to: {}) —

    lias_spec [Hash{String=>Array] an hash containing the host to alias(es) mappings to apply



552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 552

def stub_hosts_on(machine, ip_spec, alias_spec={})
  block_on machine do | host |
    ip_spec.each do |address, ip|
      aliases = alias_spec[address] || []
      manifest =<<-EOS.gsub /^\s+/, ""
        host { '#{address}':
          \tensure       => present,
          \tip           => '#{ip}',
          \thost_aliases => #{aliases},
        }
      EOS
      logger.notify("Stubbing address #{address} to IP #{ip} on machine #{host}")
      apply_manifest_on( host, manifest )
    end

    teardown do
      ip_spec.each do |address, ip|
        logger.notify("Unstubbing address #{address} to IP #{ip} on machine #{host}")
        on( host, puppet('resource', 'host', address, 'ensure=absent') )
      end
    end
  end
end

#wait_for_host_in_dashboard(host) ⇒ Object

Deprecated.

this method should be removed in the next release since we don’t believe the check is necessary.

wait for a given host to appear in the dashboard



802
803
804
805
806
807
808
809
810
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 802

def wait_for_host_in_dashboard(host)

  hostname = host.node_name
  hostcert = dashboard.puppet['hostcert']
  key = dashboard.puppet['hostprivkey']
  cacert = dashboard.puppet['localcacert']
  retry_on(dashboard, "curl --cert #{hostcert} --key #{key} --cacert #{cacert}\
                      https://#{dashboard}:4433/classifier-api/v1/nodes | grep '\"name\":\"#{hostname}\"'")
end

#with_forge_stubbed(forge_host = nil, &block) ⇒ Object

Deprecated.

this method should not be used because stubbing the host

This wraps ‘with_forge_stubbed_on` and provides it the default host breaks TLS validation.

See Also:



681
682
683
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 681

def with_forge_stubbed( forge_host = nil, &block )
  with_forge_stubbed_on( default, forge_host, &block )
end

#with_forge_stubbed_on(host, forge_host = nil, &block) ⇒ Object

Deprecated.

this method should not be used because stubbing the host

This wraps the method ‘with_host_stubbed_on` and makes the stub specific to the forge alias.

forge api v1 canonical source is forge.puppetlabs.com forge api v3 canonical source is forgeapi.puppetlabs.com

breaks TLS validation.

Parameters:

  • host (String) —

    the host to perform the stub on

  • forge_host (String) (defaults to: nil) —

    The URL to use as the forge alias, will default to using :forge_host in the global options hash



666
667
668
669
670
671
672
673
674
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 666

def with_forge_stubbed_on( host, forge_host = nil, &block )
  #use global options hash
  primary_forge_name = 'forge.puppetlabs.com'
  forge_host ||= options[:forge_host]
  forge_ip = resolve_hostname_on(host, forge_host)
  raise "Failed to resolve forge host '#{forge_host}'" unless forge_ip
  @forge_ip ||= forge_ip
  with_host_stubbed_on( host, {primary_forge_name => @forge_ip}, {primary_forge_name => ['forge.puppet.com','forgeapi.puppetlabs.com','forgeapi.puppet.com']}, &block )
end

#with_host_stubbed_on(host, ip_spec, alias_spec = {}, &block) ⇒ Object

This method accepts a block and using the puppet resource ‘host’ will setup host aliases before and after that block.

Examples:

Stub forgeapi.puppetlabs.com on the master to 127.0.0.1 with an alias forgeapi.example.com

with_host_stubbed_on(master, {'forgeapi.puppetlabs.com' => '127.0.0.1'}, {'forgeapi.puppetlabs.com' => ['forgeapi.example.com']}) do
  puppet( "module install puppetlabs-stdlib" )
end

Parameters:

  • host (Host, Array<Host>, String, Symbol) —

    One or more hosts to act upon, or a role (String or Symbol) that identifies one or more hosts.

  • ip_spec (Hash{String=>String}) —

    a hash containing the host to ip mappings

  • alias_spec (Hash{String=>Array[String]] an hash containing the host to alias(es) mappings to apply) (defaults to: {}) —

    lias_spec [Hash{String=>Array] an hash containing the host to alias(es) mappings to apply



588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 588

def with_host_stubbed_on(host, ip_spec, alias_spec={}, &block)
  begin
    block_on host do |host|
      # this code is duplicated from the `stub_hosts_on` method. The
      # `stub_hosts_on` method itself is not used here because this
      # method is used by modules tests using `beaker-rspec`. Since
      # the `stub_hosts_on` method contains a `teardown` step, it is
      # incompatible with `beaker_rspec`.
      ip_spec.each do |address, ip|
        aliases = alias_spec[address] || []
        manifest =<<-EOS.gsub /^\s+/, ""
          host { '#{address}':
            \tensure       => present,
            \tip           => '#{ip}',
            \thost_aliases => #{aliases},
          }
        EOS
        logger.notify("Stubbing address #{address} to IP #{ip} on machine #{host}")
        apply_manifest_on( host, manifest )
      end
    end

    block.call

  ensure
    ip_spec.each do |address, ip|
      logger.notify("Unstubbing address #{address} to IP #{ip} on machine #{host}")
      on( host, puppet('resource', 'host', address, 'ensure=absent') )
    end
  end
end

#with_puppet_running(conf_opts, testdir = host.tmpdir(File.basename(@path)), &block) ⇒ Object

Test Puppet running in a certain run mode with specific options, on the default host

See Also:



263
264
265
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 263

def with_puppet_running conf_opts, testdir = host.tmpdir(File.basename(@path)), &block
  with_puppet_running_on(default, conf_opts, testdir, &block)
end

#with_puppet_running_on(host, conf_opts, testdir = host.tmpdir(File.basename(@path)), &block) ⇒ Object

Note:

Whether Puppet is started or restarted depends on what kind of server you’re running. Passenger and puppetserver are restarted before. Webrick is started before and stopped after yielding, unless you’re using service scripts, then it’ll behave like passenger & puppetserver. Passenger and puppetserver (or webrick using service scripts) restart after yielding by default. You can stop this from happening by setting the :restart_when_done flag of the conf_opts argument.

Test Puppet running in a certain run mode with specific options. This ensures the following steps are performed:

  1. The pre-test Puppet configuration is backed up

  2. A new Puppet configuraton file is layed down

  3. Puppet is started or restarted in the specified run mode

  4. Ensure Puppet has started correctly

  5. Further tests are yielded to

  6. Revert Puppet to the pre-test state

  7. Testing artifacts are saved in a folder named for the test

Examples:

A simple use case to ensure a master is running

with_puppet_running_on( master ) do
    ...tests that require a master...
end

Fully utilizing the possiblities of config options

with_puppet_running_on( master,
                        :main => {:logdest => '/var/blah'},
                        :master => {:masterlog => '/elswhere'},
                        :agent => {:server => 'localhost'} ) do

  ...tests to be run...
end

Parameters:

  • host (Host) —

    One object that act like Host

  • conf_opts (Hash{Symbol=>String}) —

    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]

  • testdir (File) (defaults to: host.tmpdir(File.basename(@path))) —

    The temporary directory which will hold backup configuration, and other test artifacts.

  • block (Block) —

    The point of this method, yields so tests may be ran. After the block is finished puppet will revert to a previous state.

Options Hash (conf_opts):

  • :__commandline_args__ (String) —

    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.

  • :__service_args__ (Hash) —

    A special setting of options for controlling how the puppet master service is handled. The only setting currently is :bypass_service_script, which if set true will force stopping and starting a webrick master using the start_puppet_from_source_* methods, even if it seems the host has passenger. This is needed in FOSS tests to initialize SSL.

  • :restart_when_done (Boolean) —

    determines whether a restart should be run after the test has been yielded to. Will stop puppet if false. Default behavior is to restart, but you can override this on the host or with this option. (Note: only works for passenger & puppetserver masters (or webrick using the service scripts))

Raises:

  • (ArgumentError) 


154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
 
# File 'lib/beaker-puppet/helpers/puppet_helpers.rb', line 154

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[:__commandline_args__]
  service_args = conf_opts[:__service_args__] || {}
  restart_when_done = true
  restart_when_done = host[:restart_when_done] if host.has_key?(:restart_when_done)
  restart_when_done = conf_opts.fetch(:restart_when_done, restart_when_done)
  conf_opts = conf_opts.reject { |k,v| [:__commandline_args__, :__service_args__, :restart_when_done].include?(k) }

  curl_retries = host['master-start-curl-retries'] || options['master-start-curl-retries']
  logger.debug "Setting curl retries to #{curl_retries}"

  if options[:is_puppetserver] || host[:is_puppetserver]
    confdir = puppet_config(host, 'confdir', section: 'master')
    vardir = puppet_config(host, 'vardir', section: 'master')

    if cmdline_args
      split_args = cmdline_args.split()

      split_args.each do |arg|
        case arg
        when /--confdir=(.*)/
          confdir = $1
        when /--vardir=(.*)/
          vardir = $1
        end
      end
    end

    puppetserver_opts = { "jruby-puppet" => {
      "master-conf-dir" => confdir,
      "master-var-dir" => vardir,
    }}

    puppetserver_conf = File.join("#{host['puppetserver-confdir']}", "puppetserver.conf")
    modify_tk_config(host, puppetserver_conf, puppetserver_opts)
  end
  begin
    backup_file = backup_the_file(host,
                                  puppet_config(host, 'confdir', section: 'master'),
                                  testdir,
                                  'puppet.conf')
    lay_down_new_puppet_conf host, conf_opts, testdir

    if host.use_service_scripts? && !service_args[:bypass_service_script]
      bounce_service( host, host['puppetservice'], curl_retries )
    else
      puppet_master_started = start_puppet_from_source_on!( host, cmdline_args )
    end

    yield self if block_given?

  # FIXME: these test-flow-control exceptions should be using throw
    # they can be caught in test_case.  current layout dows not allow it
  rescue Beaker::DSL::Outcomes::PassTest => early_assertion
    pass_test(early_assertion)
  rescue Beaker::DSL::Outcomes::FailTest => early_assertion
    fail_test(early_assertion)
  rescue Beaker::DSL::Outcomes::PendingTest => early_assertion
    pending_test(early_assertion)
  rescue Beaker::DSL::Outcomes::SkipTest => early_assertion
    skip_test(early_assertion)
  rescue Beaker::DSL::Assertions, Minitest::Assertion => early_assertion
    fail_test(early_assertion)
  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
    begin

      if host.use_service_scripts? && !service_args[:bypass_service_script]
        restore_puppet_conf_from_backup( host, backup_file )
        if restart_when_done
          bounce_service( host, host['puppetservice'], curl_retries )
        else
          host.exec puppet_resource('service', host['puppetservice'], 'ensure=stopped')
        end
      else
        if puppet_master_started
          stop_puppet_from_source_on( host )
        else
          dump_puppet_log(host)
        end
        restore_puppet_conf_from_backup( host, backup_file )
      end

    rescue Exception => teardown_exception
      begin
        if !host.is_pe?
          dump_puppet_log(host)
        end
      rescue Exception => dumping_exception
        logger.error("Raised during attempt to dump puppet logs: #{dumping_exception}")
      end

      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