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

Included in:
Beaker::DSL::Helpers
Defined in:
lib/beaker/dsl/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:



486
487
488
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 486

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 #run_block_on for more details on this.



408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
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
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 408

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 master –configprint user` 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.



787
788
789
790
791
792
793
794
795
796
797
798
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 787

def create_tmpdir_for_user(host, name='/tmp/beaker', user=nil)
  if not user
    result = on host, puppet("master --configprint user")
    if not result.exit_code == 0
      raise "`puppet master --configprint` failed, check that puppet is installed on #{host} or explicitly pass in a user name."
    end
    user = result.stdout.strip
  end

  create_tmpdir_on(host, name, user)

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



49
50
51
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 49

def puppet_group(host)
  return host.puppet('master')['group']
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



39
40
41
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 39

def puppet_user(host)
  return host.puppet('master')['user']
end

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

Deprecated. 


491
492
493
494
495
496
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 491

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:



770
771
772
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 770

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:



728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 728

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



653
654
655
656
657
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 653

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



627
628
629
630
631
632
633
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 627

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?
  curl_with_retries("start puppetdb", host, "http://localhost:#{nonssl_port}", 0, 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



641
642
643
644
645
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 641

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:



703
704
705
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 703

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.



664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 664

def stop_agent_on(agent, opts = {})
  block_on agent, opts do | host |
    vardir = host.puppet_configprint['vardir']
    agent_running = true
    while agent_running
      agent_running = host.file_exist?("#{vardir}/state/agent_catalog_run.lock")
      if agent_running
        sleep 2
      end
    end

    # 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
  end
end

#stub_forge(forge_host = nil) ⇒ Object

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

See Also:



614
615
616
617
618
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 614

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

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

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



575
576
577
578
579
580
581
582
583
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 575

def stub_forge_on(machine, forge_host = nil)
  #use global options hash
  forge_host ||= options[:forge_host]
  @forge_ip ||= Resolv.getaddress(forge_host)
  block_on machine do | host |
    stub_hosts_on(host, 'forge.puppetlabs.com' => @forge_ip)
    stub_hosts_on(host, 'forgeapi.puppetlabs.com' => @forge_ip)
  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:



562
563
564
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 562

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

#stub_hosts_on(machine, ip_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

stub_hosts_on(master, 'puppetlabs.com' => '127.0.0.1')

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



510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 510

def stub_hosts_on(machine, ip_spec)
  block_on machine do | host |
    ip_spec.each do |address, ip|
      logger.notify("Stubbing address #{address} to IP #{ip} on machine #{host}")
      on( host, puppet('resource', 'host', address, 'ensure=present', "ip=#{ip}") )
    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

wait for a given host to appear in the dashboard



708
709
710
711
712
713
714
715
716
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 708

def wait_for_host_in_dashboard(host)
  hostname = host.node_name
  if host['platform'] =~ /aix/ then
    curl_opts = '--tlsv1 -I'
  else
    curl_opts = '--tlsv1 -k -I'
  end
  retry_on(dashboard, "! curl #{curl_opts} https://#{dashboard}/nodes/#{hostname} | grep '404 Not Found'")
end

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

This wraps ‘with_forge_stubbed_on` and provides it the default host

See Also:



606
607
608
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 606

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

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

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



594
595
596
597
598
599
600
601
602
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 594

def with_forge_stubbed_on( host, forge_host = nil, &block )
  #use global options hash
  forge_host ||= options[:forge_host]
  @forge_ip ||= Resolv.getaddress(forge_host)
  with_host_stubbed_on( host,
                        {'forge.puppetlabs.com'  => @forge_ip,
                       'forgeapi.puppetlabs.com' => @forge_ip},
                        &block                                    )
end

#with_host_stubbed_on(host, ip_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 puppetlabs.com on the master to 127.0.0.1

with_host_stubbed_on(master, 'forgeapi.puppetlabs.com' => '127.0.0.1') 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



537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 537

def with_host_stubbed_on(host, ip_spec, &block)
  begin
    block_on host do |host|
      ip_spec.each_pair do |address, ip|
        logger.notify("Stubbing address #{address} to IP #{ip} on machine #{host}")
        on( host, puppet('resource', 'host', address, 'ensure=present', "ip=#{ip}") )
      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:



230
231
232
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 230

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 ran...
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) 


124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
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
 
# File 'lib/beaker/dsl/helpers/puppet_helpers.rb', line 124

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 = host.puppet('master')['confdir']
    vardir = host.puppet('master')['vardir']

    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, host.puppet('master')['confdir'], 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