Module: Beaker::DSL::InstallUtils::PEUtils

Includes:
AIODefaults, PEDefaults, PuppetUtils, WindowsUtils
Included in:
PE
Defined in:
lib/beaker-pe/install/pe_utils.rb

Overview

This module contains methods to help installing/upgrading PE builds - including Higgs installs

To mix this is into a class you need the following:

  • a method hosts that yields any hosts implementing Host‘s interface to act upon.

  • a method options that provides an options hash, see Options::OptionsHash

  • the module Roles that provides access to the various hosts implementing Host‘s interface to act upon

  • the module Wrappers the provides convenience methods for Command creation

Constant Summary collapse

MEEP_CUTOVER_VERSION =

Version of PE when we switched from legacy installer to MEEP.

'2016.2.0'
MEEP_CLASSIFICATION_VERSION =

Version of PE when we switched to using meep for classification instead of PE node groups

'2017.2.0'
DEFAULT_MEEP_CLASSIFICATION =

PE-18799 temporary default used for meep classification check while we navigate the switchover. PE-18718 switch flag to true once beaker-pe, beaker-answers, beaker-pe-large-environments and pe_acceptance_tests are ready

false
MEEP_DATA_DIR = 
'/etc/puppetlabs/enterprise'
PE_CONF_FILE = 
"#{MEEP_DATA_DIR}/conf.d/pe.conf"
NODE_CONF_PATH = 
"#{MEEP_DATA_DIR}/conf.d/nodes"
BEAKER_MEEP_TMP = 
"pe_conf"

Instance Method Summary collapse

Instance Method Details

#check_console_status_endpoint(host) ⇒ Object

Note:

Uses the global option’s :pe_console_status_attempts value to determine how many times it’s going to retry the check with fibonacci back offs.

Checks Console Status Endpoint, failing the test if the endpoints don’t report a running state.

Parameters:

  • host (Host) —

    Host to check status on

Returns:

  • nil



1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1183

def check_console_status_endpoint(host)
  return true if version_is_less(host['pe_ver'], '2015.2.0')

  attempts_limit = options[:pe_console_status_attempts] || 9
  # Workaround for PE-14857. The classifier status service at the
  # default level is broken in 2016.1.1. Instead we need to query
  # the classifier service at critical level and check for service
  # status
  query_params = (host['pe_ver'] == '2016.1.1' ? '?level=critical' : '')
  step 'Check Console Status Endpoint' do
    match = repeat_fibonacci_style_for(attempts_limit) do
      output = on(host, "curl -s -k https://localhost:4433/status/v1/services#{query_params} --cert /etc/puppetlabs/puppet/ssl/certs/#{host}.pem --key /etc/puppetlabs/puppet/ssl/private_keys/#{host}.pem --cacert /etc/puppetlabs/puppet/ssl/certs/ca.pem", :accept_all_exit_codes => true)
      begin
        output = JSON.parse(output.stdout)
        match = output['classifier-service']['state'] == 'running'
        match = match && output['rbac-service']['state'] == 'running'
        match && output['activity-service']['state'] == 'running'
      rescue JSON::ParserError
        false
      end
    end
    fail_test 'Console services took too long to start' if !match
  end
end

#check_puppetdb_status_endpoint(host) ⇒ Object 



1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1157

def check_puppetdb_status_endpoint(host)
  if version_is_less(host['pe_ver'], '2016.1.0')
    return true
  end
  Timeout.timeout(60) do
    match = nil
    while not match
      output = on(host, "curl -s http://localhost:8080/pdb/meta/v1/version", :accept_all_exit_codes => true)
      match = output.stdout =~ /version.*\d+\.\d+\.\d+/
      sleep 1
    end
  end
rescue Timeout::Error
  fail_test "PuppetDB took too long to start"
end

#config_master_for_proxy_access ⇒ Object

Configure the master to use a proxy and drop unproxied connections



630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 630

def config_master_for_proxy_access
  step "configuring master to use proxy" do
    @osmirror_host = "osmirror.delivery.puppetlabs.net"
    @osmirror_host_ip = IPSocket.getaddress(@osmirror_host)
    @delivery_host = "enterprise.delivery.puppetlabs.net"
    @delivery_host_ip = IPSocket.getaddress(@delivery_host)
    @proxy_ip = @options[:proxy_ip]
    @proxy_hostname = @options[:proxy_hostname]
    @master_ip = on master, "hostname -I | tr '\n' ' '"
    on master, "echo \"#{@proxy_ip}  #{@proxy_hostname}\" >> /etc/hosts"
    on master, "echo \"#{@master_ip.stdout}  #{master.connection.vmhostname}\" >> /etc/hosts"
    on master, "echo \"#{@osmirror_host_ip}    #{@osmirror_host}\" >> /etc/hosts"
    on master, "echo \"#{@delivery_host_ip}    #{@delivery_host}\" >> /etc/hosts"
    on master, "iptables -A OUTPUT -p tcp -d #{master.connection.vmhostname} -j ACCEPT"
    # the next two lines clear the internal puppet lan
    on master, "iptables -A OUTPUT -p tcp -d 10.16.0.0/16 -j ACCEPT"
    on master, "iptables -A OUTPUT -p tcp -d 10.32.0.0/16 -j ACCEPT"
    on master, "iptables -A OUTPUT -p tcp --dport 3128 -d #{@proxy_hostname} -j ACCEPT"
    on master, "iptables -A OUTPUT -p tcp -d #{@osmirror_host_ip} -j DROP"
    on master, "iptables -A OUTPUT -p tcp -d #{@delivery_host_ip} -j DROP"
    on master, "iptables -P OUTPUT DROP"
    on master, "curl --proxy #{@proxy_hostname}:3128 http://#{@osmirror_host}", :acceptable_exit_codes => [0]
    on master, "curl -k https://#{@osmirror_host}", :acceptable_exit_codes => [1,7]
    if master.host_hash[:platform].include?("ubuntu")
      on master, "echo 'Acquire::http::Proxy \"http://'#{@proxy_hostname}':3128/\";' >> /etc/apt/apt.conf"
      on master, "echo 'Acquire::https::Proxy \"http://'#{@proxy_hostname}':3128/\";' >> /etc/apt/apt.conf"
    else
      on master, "echo \"proxy=http://#{@proxy_hostname}:3128\" >> /etc/yum.conf"
    end
  end
end

#configure_puppet_agent_service(parameters) ⇒ Object

In PE versions >= 2017.1.0, allows you to configure the puppet agent service for all nodes.

Parameters:

  • parameters (Hash) —

    • agent profile parameters

Options Hash (parameters):

  • :managed (Boolean) —

    • whether or not to manage the

    agent resource at all (Optional, defaults to true).

  • :ensure (String) —

    • ‘stopped’, ‘running’

  • :enabled (Boolean) —

    • whether the service will be

    enabled (for restarts)

Raises:

  • (StandardError) —

    if master version is less than 2017.1.0



1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1519

def configure_puppet_agent_service(parameters)
  raise(StandardError, "Can only manage puppet service in PE versions >= 2017.1.0; tried for #{master['pe_ver']}") if version_is_less(master['pe_ver'], '2017.1.0')
  puppet_managed = parameters.include?(:managed) ? parameters[:managed] : true
  puppet_ensure = parameters[:ensure]
  puppet_enabled = parameters[:enabled]

  msg = puppet_managed ?
    "Configure agents '#{puppet_ensure}' and #{puppet_enabled ? 'enabled' : 'disabled'}" :
    "Do not manage agents"

  step msg do
    # PE-18799 and remove this conditional
    if use_meep_for_classification?(master[:pe_ver], options)
      group_name = 'Puppet Enterprise Agent'
      class_name = 'pe_infrastructure::agent'
    else
      group_name = 'PE Agent'
      class_name = 'puppet_enterprise::profile::agent'
    end

    # update pe conf
    # only the pe_infrastructure::agent parameters are relevant in pe.conf
    update_pe_conf({
      "pe_infrastructure::agent::puppet_service_managed" => puppet_managed,
      "pe_infrastructure::agent::puppet_service_ensure" => puppet_ensure,
      "pe_infrastructure::agent::puppet_service_enabled" => puppet_enabled,
    })

    if _console_dispatcher = get_console_dispatcher_for_beaker_pe
      agent_group = _console_dispatcher.get_node_group_by_name(group_name)
      agent_class = agent_group['classes'][class_name]
      agent_class['puppet_service_managed'] = puppet_managed
      agent_class['puppet_service_ensure'] = puppet_ensure
      agent_class['puppet_service_enabled'] = puppet_enabled

      _console_dispatcher.update_node_group(agent_group['id'], agent_group)
    end
  end
end

#create_agent_specified_arrays(hosts) ⇒ Array<Host>

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Note:

should only be called against versions 4.0+, as this method assumes AIO packages will be required.

Note:

agent_only hosts with the :pe_ver setting < 4.0 will not be included in the agent_only array, as AIO install can only happen in versions > 4.0

Builds the agent_only and not_agent_only arrays needed for installation.

Parameters:

  • hosts (Array<Host>) —

    hosts to split up into the arrays

Returns:

  • (Array<Host>, Array<Host>) —

    the array of hosts to do an agent_only install on and the array of hosts to do our usual install methods on



1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1117

def create_agent_specified_arrays(hosts)
  hosts_agent_only = []
  hosts_not_agent_only = []
  non_agent_only_roles = %w(master database dashboard console frictionless)
  hosts.each do |host|
    if host['roles'].none? {|role| non_agent_only_roles.include?(role) }
      if !aio_version?(host)
        hosts_not_agent_only << host
      else
        hosts_agent_only << host
      end
    else
      hosts_not_agent_only << host
    end
  end
  return hosts_agent_only, hosts_not_agent_only
end

#create_or_update_node_conf(host, parameters, node_conf_path = NODE_CONF_PATH) ⇒ Object

Creates a new /etc/puppetlabs/enterprise/conf.d/nodes/*.conf file for the given host’s certname, and adds the passed parameters, or updates with the passed parameters if the file already exists.

Does not remove an empty file.

Parameters:

  • host (Beaker::Host) —

    to create a node file for

  • parameters (Hash) —

    of key value pairs to add to the nodes conf file

  • node_conf_path (String) (defaults to: NODE_CONF_PATH) —

    defaults to /etc/puppetlabs/enterprise/conf.d/nodes



1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1683

def create_or_update_node_conf(host, parameters, node_conf_path = NODE_CONF_PATH)
  node_conf_file = "#{node_conf_path}/#{host.node_name}.conf"
  step "Create or Update #{node_conf_file} with #{parameters}" do
    if !master.file_exist?(node_conf_file)
      if !master.file_exist?(node_conf_path)
        # potentially create the nodes directory
        on(master, "mkdir #{node_conf_path}")
      end
      # The hocon gem will create a list of comma separated parameters
      # on the same line unless we start with something in the file.
      create_remote_file(master, node_conf_file, %Q|{\n}\n|)
      on(master, "chown pe-puppet #{node_conf_file}")
    end
    update_pe_conf(parameters, node_conf_file)
  end
end

#deploy_frictionless_to_master(host) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Classify the master so that it can deploy frictionless packages for a given host. This function does nothing when using meep for classification.

Parameters:

  • host (Host) —

    The host to install pacakges for



394
395
396
397
398
399
400
401
402
403
404
405
406
407
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
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 394

def deploy_frictionless_to_master(host)
  return if use_meep_for_classification?(master[:pe_ver], options)

  platform = host['platform']

  # We don't have a separate AIX 7.2 build, so it is
  # classified as 7.1 for pe_repo purposes
  if platform == "aix-7.2-power"
    platform = "aix-7.1-power"
  end
  klass = platform.gsub(/-/, '_').gsub(/\./,'')
  if host['platform'] =~ /windows/
    if host['template'] =~ /i386/
      klass = "pe_repo::platform::windows_i386"
    else
      klass = "pe_repo::platform::windows_x86_64"
    end
  else
    klass = "pe_repo::platform::#{klass}"
  end
  if version_is_less(host['pe_ver'], '3.8')
    # use the old rake tasks
    on dashboard, "cd /opt/puppet/share/puppet-dashboard && /opt/puppet/bin/bundle exec /opt/puppet/bin/rake nodeclass:add[#{klass},skip]"
    on dashboard, "cd /opt/puppet/share/puppet-dashboard && /opt/puppet/bin/bundle exec /opt/puppet/bin/rake node:add[#{master},,,skip]"
    on dashboard, "cd /opt/puppet/share/puppet-dashboard && /opt/puppet/bin/bundle exec /opt/puppet/bin/rake node:addclass[#{master},#{klass}]"
    on master, puppet("agent -t"), :acceptable_exit_codes => [0,2]
  else
    _console_dispatcher = get_console_dispatcher_for_beaker_pe!

    # Add pe_repo packages to 'PE Master' group
    node_group = _console_dispatcher.get_node_group_by_name('PE Master')

    # add the pe_repo platform class if it's not already present
    if node_group
      if !node_group['classes'].include?(klass)
        node_group['classes'][klass] = {}
        _console_dispatcher.create_new_node_group_model(node_group)

        # The puppet agent run that will download the agent tarballs to the master can sometimes fail with
        # curl errors if there is a network hiccup. Use beakers `retry_on` method to retry up to
        # three times to avoid failing the entire test pipeline due to a network blip
        retry_opts = {
          :desired_exit_codes => [0,2],
          :max_retries => 3,
          # Beakers retry_on method wants the verbose value to be a string, not a bool.
          :verbose => 'true'
        }
        retry_on(master, puppet("agent -t"), retry_opts)

        # If we are connecting through loadbalancer, download the agent tarballs to compile masters
        if lb_connect_loadbalancer_exists?
          hosts.each do |h|
            if h['roles'].include?('compile_master')
              retry_on(h, puppet("agent -t"), retry_opts)
            end
          end
        end
      end
    else
      raise "Failed to add pe_repo packages, PE Master node group is not available"
    end
  end
end

#determine_install_type(hosts, opts) ⇒ Symbol

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Determine what kind of install is being performed

Examples:

determine_install_type(hosts, {:type => :install, :pe_ver => '2017.2.0'})

Parameters:

  • hosts (Array<Host>) —

    The sorted hosts to install or upgrade PE on

  • opts (Hash{Symbol=>Symbol, String}) —

    The options for how to install or upgrade PE

Returns:

  • (Symbol) —

    One of :generic, :simple_monolithic, :simple_split, :pe_managed_postgres :simple_monolithic

    returned when installing >=2016.4 with a monolithic master and
any number of frictionless agents

    :simple_split

    returned when installing >=2016.4 with a split install and any
number of frictionless agents

    :pe_managed_postgres

    returned when installing PE with postgres being managed on a node
that is different then the database node

    :generic

    returned for any other install or upgrade



567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 567

def determine_install_type(hosts, opts)
  # Do a generic install if this is masterless, not all the same PE version, an upgrade, or earlier than 2016.4
  return :generic if opts[:masterless]
  return :generic if hosts.map {|host| host['pe_ver']}.uniq.length > 1
  return :generic if (opts[:type] == :upgrade) && (hosts.none? {|host| host['roles'].include?('pe_postgres')})
  return :generic if version_is_less(opts[:pe_ver] || hosts.first['pe_ver'], '2016.4')
  #PE-20610 Do a generic install for old versions on windows that needs msi install because of PE-18351
  return :generic if hosts.any? {|host| host['platform'] =~ /windows/ && install_via_msi?(host)}

  mono_roles = ['master', 'database', 'dashboard']
  if has_all_roles?(hosts.first, mono_roles) && hosts.drop(1).all? {|host| host['roles'].include?('frictionless')}
    :simple_monolithic
  elsif hosts[0]['roles'].include?('master') && hosts[1]['roles'].include?('database') && hosts[2]['roles'].include?('dashboard') && hosts.drop(3).all? {|host| host['roles'].include?('frictionless')}
    :simple_split
  elsif hosts.any? {|host| host['roles'].include?('pe_postgres')}
    :pe_managed_postgres
  else
    :generic
  end
end

#do_higgs_install(host, opts) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Perform a Puppet Enterprise Higgs install up until web browser interaction is required, runs on linux hosts only.

Examples:

do_higgs_install(master, {:pe_dir => path, :pe_ver => version})

Parameters:

  • host (Host) —

    The host to install higgs on

  • opts (Hash{Symbol=>Symbol, String}) —

    The options

Options Hash (opts):

  • :pe_dir (String) —

    Default directory or URL to pull PE package from (Otherwise uses individual hosts pe_dir)

  • :pe_ver (String) —

    Default PE version to install (Otherwise uses individual hosts pe_ver)

  • :fetch_local_then_push_to_host (Boolean) —

    determines whether you use Beaker as the middleman for this (true), or curl the file from the host (false; default behavior)

Raises:

  • (StandardError) —

    When installation times out



1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1338

def do_higgs_install host, opts
  use_all_tar = ENV['PE_USE_ALL_TAR'] == 'true'
  platform = use_all_tar ? 'all' : host['platform']
  version = host['pe_ver'] || opts[:pe_ver]
  host['dist'] = "puppet-enterprise-#{version}-#{platform}"

  use_all_tar = ENV['PE_USE_ALL_TAR'] == 'true'
  host['pe_installer'] ||= 'puppet-enterprise-installer'
  host['working_dir'] = host.tmpdir(Time.new.strftime("%Y-%m-%d_%H.%M.%S"))

  fetch_pe([host], opts)

  host['higgs_file'] = "higgs_#{File.basename(host['working_dir'])}.log"

  prepare_host_installer_options(host)
  on host, higgs_installer_cmd(host), opts

  #wait for output to host['higgs_file']
  #we're all done when we find this line in the PE installation log
  if version_is_less(opts[:pe_ver] || host['pe_ver'], '2016.3')
    higgs_re = /Please\s+go\s+to\s+https:\/\/.*\s+in\s+your\s+browser\s+to\s+continue\s+installation/m
  else
    higgs_re = /o\s+to\s+https:\/\/.*\s+in\s+your\s+browser\s+to\s+continue\s+installation/m
  end
  res = Result.new(host, 'tmp cmd')
  tries = 10
  attempts = 0
  prev_sleep = 0
  cur_sleep = 1
  while (res.stdout !~ higgs_re) and (attempts < tries)
    res = on host, "cd #{host['working_dir']}/#{host['dist']} && cat #{host['higgs_file']}", :accept_all_exit_codes => true
    attempts += 1
    sleep( cur_sleep )
    prev_sleep = cur_sleep
    cur_sleep = cur_sleep + prev_sleep
  end

  if attempts >= tries
    raise "Failed to kick off PE (Higgs) web installation"
  end
end

#do_install(hosts, opts = {}) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Note:

on windows, the :ruby_arch host parameter can determine in addition

Note:

for puppet-agent install options, refer to FOSSUtils#install_puppet_agent_pe_promoted_repo_on

Perform a Puppet Enterprise upgrade or install to other settings whether the 32 or 64bit install is used

Examples:

do_install(hosts, {:type => :upgrade, :pe_dir => path, :pe_ver => version, :pe_ver_win =>  version_win})

Parameters:

  • hosts (Array<Host>) —

    The hosts to install or upgrade PE on

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

    The options

Options Hash (opts):

  • :pe_dir (String) —

    Default directory or URL to pull PE package from (Otherwise uses individual hosts pe_dir)

  • :pe_ver (String) —

    Default PE version to install or upgrade to (Otherwise uses individual hosts pe_ver)

  • :pe_ver_win (String) —

    Default PE version to install or upgrade to on Windows hosts (Otherwise uses individual Windows hosts pe_ver)

  • :type (Symbol) — default: :install —

    One of :upgrade or :install

  • :set_console_password (Boolean) —

    Should we set the PE console password in the answers file? Used during upgrade only.

  • :answers (Hash<String>) —

    Pre-set answers based upon ENV vars and defaults (See Options::Presets.env_vars)

  • :fetch_local_then_push_to_host (Boolean) —

    determines whether you use Beaker as the middleman for this (true), or curl the file from the host (false; default behavior)

  • :masterless (Boolean) —

    Are we performing a masterless installation?



520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 520

def do_install hosts, opts = {}
  # detect the kind of install we're doing
  install_type = determine_install_type(hosts, opts)
  verify_network_resources(hosts, options[:net_diag_hosts])
  if opts[:use_proxy]
    config_master_for_proxy_access
  end
  case install_type
  when :pe_managed_postgres
    do_install_pe_with_pe_managed_external_postgres(hosts,opts)
  when :simple_monolithic
    simple_monolithic_install(hosts.first, hosts.drop(1), opts)
  when :simple_split
    # This isn't implemented yet, so just do a generic install instead
    #simple_split_install(hosts, opts)
    generic_install(hosts, opts)
  else
    generic_install(hosts, opts)
  end
end

#do_install_pe_with_pe_managed_external_postgres(hosts, opts) ⇒ Object

Installs PE with a PE managed external postgres



1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1402

def do_install_pe_with_pe_managed_external_postgres(hosts, opts)
  pe_infrastructure = select_hosts({:roles => ['master', 'compile_master', 'dashboard', 'database', 'pe_postgres']}, hosts)
  non_infrastructure = hosts.reject{|host| pe_infrastructure.include? host}

  is_upgrade = (original_pe_ver(hosts[0]) != hosts[0][:pe_ver])
  step "Setup tmp installer directory and pe.conf" do

    prepare_hosts(pe_infrastructure,opts)
    register_feature_flags!(opts)
    fetch_pe(pe_infrastructure,opts)

    [master, database, dashboard, pe_postgres].uniq.each do |host|
      prepare_host_installer_options(host)

      unless is_upgrade
        setup_pe_conf(host, hosts, opts)
      end
    end
  end

  unless is_upgrade
    step "Initial master install, expected to fail due to RBAC database not being initialized" do
      begin
        execute_installer_cmd(master, opts)
      rescue Beaker::Host::CommandFailure => e
        installer_log_dir = '/var/log/puppetlabs/installer'
        latest_installer_log_file = on(master, "ls -1t #{installer_log_dir} | head -n1").stdout.chomp
        #Check the lastest install log to confirm the expected failure is there
        unless on(master, "grep 'The operation could not be completed because RBACs database has not been initialized' #{installer_log_dir}/#{latest_installer_log_file}")
          raise "Install on master failed in an unexpected manner"
        end
      end
    end
  end

  step "Install/Upgrade postgres service on pe-postgres node" do
    execute_installer_cmd(pe_postgres, opts)
  end

  step "Finish install/upgrade on infrastructure" do
      [master, database, dashboard].uniq.each do |host|
        execute_installer_cmd(host, opts)
      end
  end

  step "Final puppet run on infrastructure + postgres node" do
    [master, database, dashboard, pe_postgres].uniq.each do |host|
      on host, 'puppet agent -t', :acceptable_exit_codes => [0,2]
    end
  end

  if(non_infrastructure.size > 0)
    install_agents_only_on(non_infrastructure, opts)

    step "Run puppet to setup mcollective and pxp-agent" do
      on master, 'puppet agent -t', :acceptable_exit_codes => [0,2]
      run_puppet_on_non_infrastructure_nodes(non_infrastructure)
    end

    step "Run puppet a second time on the primary to populate services.conf (PE-19054)" do
      on master, 'puppet agent -t', :acceptable_exit_codes => [0,2]
    end
  end
end

#download_pe_conf_if_master(host) ⇒ Object 



1727
1728
1729
1730
1731
1732
1733
1734
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1727

def download_pe_conf_if_master(host)
  if host['roles'].include?('master')
    step "Downloading generated #{MEEP_DATA_DIR}/conf.d locally" do
      # scp conf.d over from master
      scp_from(host, "#{MEEP_DATA_DIR}/conf.d", BEAKER_MEEP_TMP)
    end
  end
end

#execute_installer_cmd(host, opts) ⇒ Object

This calls the installer command on the host in question



235
236
237
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 235

def execute_installer_cmd(host, opts)
  on host, installer_cmd(host, opts)
end

#feature_flag?(flag, opts) ⇒ Boolean

Tests if a feature flag has been set in the answers hash provided to beaker options. Assumes a ‘feature_flags’ hash is present in the answers and looks for flag within it.

Parameters:

  • flag —

    String flag to lookup

  • opts —

    Hash options hash to inspect

Returns:

  • (Boolean) —

    true if flag is true or ‘true’ in the feature_flags hash, false otherwise. However, returns nil if there is no flag in the answers hash at all



934
935
936
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 934

def feature_flag?(flag, opts)
  Beaker::DSL::InstallUtils::FeatureFlags.new(opts).flag?(flag)
end

#fetch_and_push_pe(host, path, filename, extension, local_dir = 'tmp/pe') ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Grabs the pe file from a remote host to the machine running Beaker, then scp’s the file out to the host.

Parameters:

  • host (Host) —

    The host to install on

  • path (String) —

    path to the install file

  • filename (String) —

    the filename of the pe file (without the extension)

  • extension (String) —

    the extension of the pe file

  • local_dir (String) (defaults to: 'tmp/pe') —

    the directory to store the pe file in on the Beaker-running-machine

Returns:

  • nil



1479
1480
1481
1482
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1479

def fetch_and_push_pe(host, path, filename, extension, local_dir='tmp/pe')
  fetch_http_file("#{path}", "#{filename}#{extension}", local_dir)
  scp_to host, "#{local_dir}/#{filename}#{extension}", host['working_dir']
end

#fetch_pe(hosts, opts) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Determine the PE package to download/upload per-host, download/upload that package onto the host and unpack it.

Parameters:

  • hosts (Array<Host>) —

    The hosts to download/upload and unpack PE onto

  • opts (Hash{Symbol=>Symbol, String}) —

    The options

Options Hash (opts):

  • :pe_dir (String) —

    Default directory or URL to pull PE package from (Otherwise uses individual hosts pe_dir)

  • :pe_ver (String) —

    Default PE version to install or upgrade to (Otherwise uses individual hosts pe_ver)

  • :pe_ver_win (String) —

    Default PE version to install or upgrade to on Windows hosts (Otherwise uses individual Windows hosts pe_ver)

  • :fetch_local_then_push_to_host (Boolean) —

    determines whether you use Beaker as the middleman for this (true), or curl the file from the host (false; default behavior)



375
376
377
378
379
380
381
382
383
384
385
386
387
388
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 375

def fetch_pe(hosts, opts)
  hosts.each do |host|
    # We install Puppet from the master for frictionless installs, so we don't need to *fetch* anything
    next if host['roles'].include?('frictionless') && (! version_is_less(opts[:pe_ver] || host['pe_ver'], '3.2.0'))

    if host['platform'] =~ /windows/
      fetch_pe_on_windows(host, opts)
    elsif host['platform'] =~ /osx/
      fetch_pe_on_mac(host, opts)
    else
      fetch_pe_on_unix(host, opts)
    end
  end
end

#fetch_pe_on_mac(host, opts) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Determine the PE package to download/upload on a mac host, download/upload that package onto the host. Assumed file name format: puppet-enterprise-3.3.0-rc1-559-g97f0833-osx-10.9-x86_64.dmg.

Parameters:

  • host (Host) —

    The mac host to download/upload and unpack PE onto

  • opts (Hash{Symbol=>Symbol, String}) —

    The options

Options Hash (opts):

  • :pe_dir (String) —

    Default directory or URL to pull PE package from (Otherwise uses individual hosts pe_dir)

  • :fetch_local_then_push_to_host (Boolean) —

    determines whether you use Beaker as the middleman for this (true), or curl the file from the host (false; default behavior)



249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 249

def fetch_pe_on_mac(host, opts)
  path = host['pe_dir'] || opts[:pe_dir]
  local = File.directory?(path)
  filename = "#{host['dist']}"
  extension = ".dmg"
  if local
    if not File.exists?("#{path}/#{filename}#{extension}")
      raise "attempting installation on #{host}, #{path}/#{filename}#{extension} does not exist"
    end
    scp_to host, "#{path}/#{filename}#{extension}", "#{host['working_dir']}/#{filename}#{extension}"
  else
    if not link_exists?("#{path}/#{filename}#{extension}")
      raise "attempting installation on #{host}, #{path}/#{filename}#{extension} does not exist"
    end
    if opts[:fetch_local_then_push_to_host]
      fetch_and_push_pe(host, path, filename, extension)
    else
      on host, "cd #{host['working_dir']}; curl -O #{path}/#{filename}#{extension}"
    end
  end
end

#fetch_pe_on_unix(host, opts) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Determine the PE package to download/upload on a unix style host, download/upload that package onto the host and unpack it.

Parameters:

  • host (Host) —

    The unix style host to download/upload and unpack PE onto

  • opts (Hash{Symbol=>Symbol, String}) —

    The options

Options Hash (opts):

  • :pe_dir (String) —

    Default directory or URL to pull PE package from (Otherwise uses individual hosts pe_dir)

  • :fetch_local_then_push_to_host (Boolean) —

    determines whether you use Beaker as the middleman for this (true), or curl the file from the host (false; default behavior)



318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 318

def fetch_pe_on_unix(host, opts)
  path = host['pe_dir'] || opts[:pe_dir]
  local = File.directory?(path)
  filename = "#{host['dist']}"
  if local
    extension = File.exists?("#{path}/#{filename}.tar.gz") ? ".tar.gz" : ".tar"
    if not File.exists?("#{path}/#{filename}#{extension}")
      raise "attempting installation on #{host}, #{path}/#{filename}#{extension} does not exist"
    end
    scp_to host, "#{path}/#{filename}#{extension}", "#{host['working_dir']}/#{filename}#{extension}"
    if extension =~ /gz/
      on host, "cd #{host['working_dir']}; gunzip #{filename}#{extension}"
    end
    if extension =~ /tar/
      on host, "cd #{host['working_dir']}; tar -xvf #{filename}.tar"
    end
  else
    if host['platform'] =~ /eos/
      extension = '.swix'
    else
      extension = link_exists?("#{path}/#{filename}.tar.gz") ? ".tar.gz" : ".tar"
    end
    if not link_exists?("#{path}/#{filename}#{extension}")
      raise "attempting installation on #{host}, #{path}/#{filename}#{extension} does not exist"
    end

    if host['platform'] =~ /eos/
      host.get_remote_file("#{path}/#{filename}#{extension}")
    else
      unpack = 'tar -xvf -'
      unpack = extension =~ /gz/ ? 'gunzip | ' + unpack  : unpack
      if opts[:fetch_local_then_push_to_host]
        fetch_and_push_pe(host, path, filename, extension)
        command_file_push = 'cat '
      else
        command_file_push = "curl #{path}/"
      end
      on host, "cd #{host['working_dir']}; #{command_file_push}#{filename}#{extension} | #{unpack}"

    end
  end
end

#fetch_pe_on_windows(host, opts) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Determine the PE package to download/upload on a windows host, download/upload that package onto the host. Assumed file name format: puppet-enterprise-3.3.0-rc1-559-g97f0833.msi

Parameters:

  • host (Host) —

    The windows host to download/upload and unpack PE onto

  • opts (Hash{Symbol=>Symbol, String}) —

    The options

Options Hash (opts):

  • :pe_dir (String) —

    Default directory or URL to pull PE package from (Otherwise uses individual hosts pe_dir)

  • :pe_ver_win (String) —

    Default PE version to install or upgrade to (Otherwise uses individual hosts pe_ver)

  • :fetch_local_then_push_to_host (Boolean) —

    determines whether you use Beaker as the middleman for this (true), or curl the file from the host (false; default behavior)



283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 283

def fetch_pe_on_windows(host, opts)
  path = host['pe_dir'] || opts[:pe_dir]
  local = File.directory?(path)
  filename = "#{host['dist']}"
  extension = ".msi"
  if local
    if not File.exists?("#{path}/#{filename}#{extension}")
      raise "attempting installation on #{host}, #{path}/#{filename}#{extension} does not exist"
    end
    scp_to host, "#{path}/#{filename}#{extension}", "#{host['working_dir']}/#{filename}#{extension}"
  else
    if not link_exists?("#{path}/#{filename}#{extension}")
      raise "attempting installation on #{host}, #{path}/#{filename}#{extension} does not exist"
    end
    if opts[:fetch_local_then_push_to_host]
      fetch_and_push_pe(host, path, filename, extension)
      on host, "cd #{host['working_dir']}; chmod 644 #{filename}#{extension}"
    elsif host.is_cygwin?
      on host, "cd #{host['working_dir']}; curl -O #{path}/#{filename}#{extension}"
    else
      on host, powershell("$webclient = New-Object System.Net.WebClient;  $webclient.DownloadFile('#{path}/#{filename}#{extension}','#{host['working_dir']}\\#{filename}#{extension}')")
    end
  end
end

#frictionless_agent_installer_cmd(host, opts, pe_version) ⇒ String

Generate the command line string needed to from a frictionless puppet-agent install on this host in a PE environment.

Parameters:

  • host (Host) —

    The host to install puppet-agent onto

  • opts (Hash) —

    The full beaker options

  • pe_version (String) —

    The PE version string for capabilities testing

Options Hash (opts):

  • :use_puppet_ca_cert (Boolean) — default: false —

    if true the command will reference the local puppet ca cert to verify the master when obtaining the installation script

Returns:

  • (String) —

    of the commands to be executed for the install



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
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 138

def frictionless_agent_installer_cmd(host, opts, pe_version)
  # PE 3.4 introduced the ability to pass in config options to the bash
  # script in the form of <section>:<key>=<value>
  frictionless_install_opts = []
  if host.has_key?('frictionless_options') and !  version_is_less(pe_version, '3.4.0')
    # since we have options to pass in, we need to tell the bash script
    host['frictionless_options'].each do |section, settings|
      settings.each do |key, value|
        frictionless_install_opts << "#{section}:#{key}=#{value}"
      end
    end
  end

  # pe_repo also supports flags that will determine what happens during the frictionless install
  # Current support in beaker-pe is for:
  # --puppet-service-debug, when running puppet service enable, the debug flag is passed into puppt service
  if host[:puppet_service_debug_flag] == true
    frictionless_install_opts << '--puppet-service-debug'
  end

  # If this is an agent node configured to connect to the loadbalancer
  # using 'lb_connect' role, then use loadbalancer in the download url
  # instead of master
  downloadhost = master
  if host['roles'].include?('lb_connect')
    downloadhost = get_lb_downloadhost(host)
  end

  pe_debug = host[:pe_debug] || opts[:pe_debug] ? ' -x' : ''
  use_puppet_ca_cert = host[:use_puppet_ca_cert] || opts[:use_puppet_ca_cert]

  if host['platform'] =~ /windows/ then
    if use_puppet_ca_cert
      frictionless_install_opts << '-UsePuppetCA'
      cert_validator = %Q{\\$callback = {param(\\$sender,[System.Security.Cryptography.X509Certificates.X509Certificate]\\$certificate,[System.Security.Cryptography.X509Certificates.X509Chain]\\$chain,[System.Net.Security.SslPolicyErrors]\\$sslPolicyErrors);\\$CertificateType=[System.Security.Cryptography.X509Certificates.X509Certificate2];\\$CACert=\\$CertificateType::CreateFromCertFile('#{host['puppetpath']}/ssl/certs/ca.pem') -as \\$CertificateType;\\$chain.ChainPolicy.ExtraStore.Add(\\$CACert);return \\$chain.Build(\\$certificate)};[Net.ServicePointManager]::ServerCertificateValidationCallback = \\$callback}
    else
      cert_validator = '[Net.ServicePointManager]::ServerCertificateValidationCallback = {\\$true}'
    end

    cmd = %Q{powershell -c "cd #{host['working_dir']};#{cert_validator};\\$webClient = New-Object System.Net.WebClient;\\$webClient.DownloadFile('https://#{downloadhost}:8140/packages/current/install.ps1', '#{host['working_dir']}/install.ps1');#{host['working_dir']}/install.ps1 -verbose #{frictionless_install_opts.join(' ')}"}
  else
    curl_opts = %w{--tlsv1 -O}
    if use_puppet_ca_cert
      curl_opts << '--cacert /etc/puppetlabs/puppet/ssl/certs/ca.pem'
    elsif host['platform'] !~ /aix/
      curl_opts << '-k'
    end

    cmd = "FRICTIONLESS_TRACE='true'; export FRICTIONLESS_TRACE; cd #{host['working_dir']} && curl #{curl_opts.join(' ')} https://#{downloadhost}:8140/packages/current/install.bash && bash#{pe_debug} install.bash #{frictionless_install_opts.join(' ')}".strip
  end

  return cmd
end

#generate_installer_conf_file_for(host, hosts, opts) ⇒ BeakerAnswers::Answers

Generates a Beaker Answers object for the passed host and creates the answer or pe.conf configuration file on the host needed for installation.

Expects the host to have been set, which is where the configuration will be written to, and will run MEEP or legacy depending on host

Parameters:

  • host (Beaker::Host) —

    The host to create a configuration file on

  • hosts (Array<Beaker::Host]) —

    All of the hosts to be configured

  • opts (Hash) —

    The Beaker options hash

Returns:

  • (BeakerAnswers::Answers) —

    the generated answers object



1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1087

def generate_installer_conf_file_for(host, hosts, opts)
  beaker_answers_opts = setup_beaker_answers_opts(host, opts)
  answers = BeakerAnswers::Answers.create(
    opts[:pe_ver] || host['pe_ver'], hosts, beaker_answers_opts
  )
  configuration = answers.installer_configuration_string(host)

  step "Generate the #{host['pe_installer_conf_file']} on #{host}" do
    logger.debug(configuration)
    create_remote_file(host, host['pe_installer_conf_file'], configuration)
  end

  answers
end

#generic_install(hosts, opts = {}) ⇒ Object 



663
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
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
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
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
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 663

def generic_install hosts, opts = {}
  step "Installing PE on a generic set of hosts"

  masterless = opts[:masterless]
  opts[:type] = opts[:type] || :install
  unless masterless
    pre30database = version_is_less(opts[:pe_ver] || database['pe_ver'], '3.0')
    pre30master = version_is_less(opts[:pe_ver] || master['pe_ver'], '3.0')
  end

  pe_versions = ( [] << opts['pe_ver'] << hosts.map{ |host| host['pe_ver'] } ).flatten.compact
  agent_only_check_needed = version_is_less('3.99', max_version(pe_versions, '3.8'))
  if agent_only_check_needed
    hosts_agent_only, hosts_not_agent_only = create_agent_specified_arrays(hosts)
  else
    hosts_agent_only, hosts_not_agent_only = [], hosts.dup
  end

  # On January 5th, 2017, the extended GPG key has expired. Rather then
  # every few months updating this gem to point to a new key for PE versions
  # less then PE 2016.4.0 we are going to just ignore the warning when installing
  ignore_gpg_key_warning_on_hosts(hosts, opts)

  # Set PE distribution for all the hosts, create working dir
  prepare_hosts(hosts_not_agent_only, opts)

  fetch_pe(hosts_not_agent_only, opts)

  install_hosts = hosts.dup
  unless masterless
    # If we're installing a database version less than 3.0, ignore the database host
    install_hosts.delete(database) if pre30database and database != master and database != dashboard
  end

  install_hosts.each do |host|

    if agent_only_check_needed && hosts_agent_only.include?(host) || install_via_msi?(host)
      host['type'] = 'aio'
      install_params = {
        :puppet_agent_version => get_puppet_agent_version(host, opts),
        :puppet_agent_sha => host[:puppet_agent_sha] || opts[:puppet_agent_sha],
        :pe_ver => host[:pe_ver] || opts[:pe_ver],
        :puppet_collection => host[:puppet_collection] || opts[:puppet_collection],
        :pe_promoted_builds_url => host[:pe_promoted_builds_url] || opts[:pe_promoted_builds_url]
      }
      install_params.delete(:pe_promoted_builds_url) if install_params[:pe_promoted_builds_url].nil?
      install_puppet_agent_pe_promoted_repo_on(host, install_params)
      # 1 since no certificate found and waitforcert disabled
      acceptable_exit_codes = [0, 1]
      acceptable_exit_codes << 2 if opts[:type] == :upgrade
      if masterless
        configure_type_defaults_on(host)
        on host, puppet_agent('-t'), :acceptable_exit_codes => acceptable_exit_codes
      else
        setup_defaults_and_config_helper_on(host, master, acceptable_exit_codes)
      end
    #Windows allows frictionless installs starting with PE Davis, if frictionless we need to skip this step
    elsif (host['platform'] =~ /windows/ && !(host['roles'].include?('frictionless')) || install_via_msi?(host))
      opts = { :debug => host[:pe_debug] || opts[:pe_debug] }
      msi_path = "#{host['working_dir']}\\#{host['dist']}.msi"
      install_msi_on(host, msi_path, {}, opts)

      # 1 since no certificate found and waitforcert disabled
      acceptable_exit_codes = 1
      if masterless
        configure_type_defaults_on(host)
        on host, puppet_agent('-t'), :acceptable_exit_codes => acceptable_exit_codes
      else
        setup_defaults_and_config_helper_on(host, master, acceptable_exit_codes)
      end
    else
      # We only need answers if we're using the classic installer
      version = host['pe_ver'] || opts[:pe_ver]
      if host['roles'].include?('frictionless') &&  (! version_is_less(version, '3.2.0'))
        # If We're *not* running the classic installer, we want
        # to make sure the master has packages for us.
        if host['platform'] != master['platform'] # only need to do this if platform differs
          deploy_frictionless_to_master(host)
        end
        install_ca_cert_on(host, opts)
        on host, installer_cmd(host, opts)
        configure_type_defaults_on(host)
      elsif host['platform'] =~ /osx|eos/
        # If we're not frictionless, we need to run the OSX special-case
        on host, installer_cmd(host, opts)
        acceptable_codes = host['platform'] =~ /osx/ ? [1] : [0, 1]
        setup_defaults_and_config_helper_on(host, master, acceptable_codes)
      else
        prepare_host_installer_options(host)
        register_feature_flags!(opts)
        setup_pe_conf(host, hosts, opts)

        on host, installer_cmd(host, opts)
        configure_type_defaults_on(host)
        download_pe_conf_if_master(host)
      end
    end
    # On each agent, we ensure the certificate is signed
    if !masterless
      if [master, database, dashboard].include?(host) && use_meep?(host['pe_ver'])
        # This step is not necessary for the core pe nodes when using meep
      else
        step "Sign certificate for #{host}" do
          sign_certificate_for(host)
        end
      end
    end
    # then shut down the agent
    step "Shutting down agent for #{host}" do
      stop_agent_on(host)
    end
  end

  unless masterless
    # Wait for PuppetDB to be totally up and running (post 3.0 version of pe only)
    sleep_until_puppetdb_started(database) unless pre30database

    step "First puppet agent run" do
      # Run the agent once to ensure everything is in the dashboard
      install_hosts.each do |host|
        on host, puppet_agent('-t'), :acceptable_exit_codes => [0,2]

        # Workaround for PE-1105 when deploying 3.0.0
        # The installer did not respect our database host answers in 3.0.0,
        # and would cause puppetdb to be bounced by the agent run. By sleeping
        # again here, we ensure that if that bounce happens during an upgrade
        # test we won't fail early in the install process.
        if host == database && ! pre30database
          sleep_until_puppetdb_started(database)
          check_puppetdb_status_endpoint(database)
        end
        if host == dashboard
          check_console_status_endpoint(host)
        end
        #Workaround for windows frictionless install, see BKR-943 for the reason
        if (host['platform'] =~ /windows/) and (host['roles'].include? 'frictionless')
          client_datadir = host.puppet['client_datadir']
          on(host , puppet("resource file \"#{client_datadir}\" ensure=absent force=true"))
        end
      end
    end

    # only appropriate for pre-3.9 builds
    if version_is_less(master[:pe_ver], '3.99')
      if pre30master
        task = 'nodegroup:add_all_nodes group=default'
      else
        task = 'defaultgroup:ensure_default_group'
      end
      on dashboard, "/opt/puppet/bin/rake -sf /opt/puppet/share/puppet-dashboard/Rakefile #{task} RAILS_ENV=production"
    end

    # PE-18799 replace the version_is_less with a use_meep_for_classification? test
    if use_meep_for_classification?(master[:pe_ver], options)
      configure_puppet_agent_service(:ensure => 'stopped', :enabled => false)
    end

    step "Final puppet agent run" do
      # Now that all hosts are in the dashbaord, run puppet one more
      # time to configure mcollective
      install_hosts.each do |host|
        on host, puppet_agent('-t'), :acceptable_exit_codes => [0,2]
        # To work around PE-14318 if we just ran puppet agent on the
        # database node we will need to wait until puppetdb is up and
        # running before continuing
        if host == database && ! pre30database
          sleep_until_puppetdb_started(database)
          check_puppetdb_status_endpoint(database)
        end
        if host == dashboard
          check_console_status_endpoint(host)
        end
      end
    end
  end
end

#get_console_dispatcher_for_beaker_pe(raise_exception = false) ⇒ Object

Being able to modify PE’s classifier requires the Scooter gem and helpers which are in beaker-pe-large-environments.



1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1486

def get_console_dispatcher_for_beaker_pe(raise_exception = false)
  # XXX RE-8616, once scooter is public, we can remove this and just
  # reference ConsoleDispatcher directly.
  if !respond_to?(:get_dispatcher)
    begin
      require 'scooter'
      Scooter::HttpDispatchers::ConsoleDispatcher.new(dashboard)
    rescue LoadError => e
      logger.notify('WARNING: gem scooter is required for frictionless installation post 3.8')
      raise e if raise_exception

      return nil
    end
  else
    get_dispatcher
  end
end

#get_console_dispatcher_for_beaker_pe! ⇒ Object

Will raise a LoadError if unable to require Scooter.



1505
1506
1507
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1505

def get_console_dispatcher_for_beaker_pe!
  get_console_dispatcher_for_beaker_pe(true)
end

#get_lb_downloadhost(host) ⇒ Object

Returns loadbalancer if host is an agent and loadbalancer has lb_connect role

Parameters:

  • agent (Host) —

    host with lb_connect role



120
121
122
123
124
125
126
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 120

def get_lb_downloadhost(host)
  downloadhost = master
  if !host['roles'].include?('loadbalancer') &&  lb_connect_loadbalancer_exists?
    downloadhost = loadbalancer
  end
  downloadhost
end

#get_puppet_agent_version(host, local_options = {}) ⇒ String

Note:

This method does have a side-effect: if it reads the ‘aio_agent_version` property from master, it will store it in the local options hash so that it won’t have to do this more than once.

Gets the puppet-agent version, hopefully from the host or local options. Will fall back to reading the ‘aio_agent_version` property on the master if neither of those two options are passed

Parameters:

  • host (Beaker::Host) —

    Host to get puppet-agent for

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

    local method options hash

Returns:

  • (String) —

    puppet-agent version to install

Raises:

  • (ArgumentError) 


901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 901

def get_puppet_agent_version(host, local_options={})
  puppet_agent_version = host[:puppet_agent_version] || local_options[:puppet_agent_version]
  return puppet_agent_version if puppet_agent_version
  log_prefix = "No :puppet_agent_version in host #{host} or local options."
  fail_message = "#{log_prefix} Could not read facts from master to determine puppet_agent_version"
  # we can query the master because do_install is called passing
  # the {#sorted_hosts}, so we know the master will be installed
  # before the agents
  facts_result = on(master, 'puppet facts')
  raise ArgumentError, fail_message if facts_result.exit_code != 0
  facts_hash = JSON.parse(facts_result.stdout.chomp)
  puppet_agent_version = facts_hash['values']['aio_agent_version']
  raise ArgumentError, fail_message if puppet_agent_version.nil?
  logger.warn("#{log_prefix} Read puppet-agent version #{puppet_agent_version} from master")
  # saving so that we don't have to query the master more than once
  local_options[:puppet_agent_version] = puppet_agent_version
  puppet_agent_version
end

#get_unwrapped_pe_conf_value(key, pe_conf_path = PE_CONF_FILE) ⇒ Object

Returns a Ruby object of any root key in pe.conf.

Parameters:

  • key (String) —

    to lookup

  • pe_conf_path (String) (defaults to: PE_CONF_FILE) —

    defaults to /etc/puppetlabs/enterprise/conf.d/pe.conf

Returns:

  • a Ruby object of any root key in pe.conf.



1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1663

def get_unwrapped_pe_conf_value(key, pe_conf_path = PE_CONF_FILE)
  file_contents = on(master, "cat #{pe_conf_path}").stdout
  # Seem to need to use ConfigFactory instead of ConfigDocumentFactory
  # to get something that we can read values from?
  doc = Hocon::ConfigFactory.parse_string(file_contents)
  hocon_key = quoted_hocon_key(key)
  doc.has_path?(hocon_key) ?
    doc.get_value(hocon_key).unwrapped :
    nil
end

#has_all_roles?(host, roles) ⇒ Boolean

Returns:

  • (Boolean) 


541
542
543
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 541

def has_all_roles?(host, roles)
  roles.all? {|role| host['roles'].include?(role)}
end

#higgs_installer_cmd(host) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Create the Higgs install command string based upon the host and options settings. Installation command will be run as a background process. The output of the command will be stored in the provided host.

Parameters:

  • host (Host) —

    The host that Higgs is to be installed on The host object must have the ‘working_dir’, ‘dist’ and ‘pe_installer’ field set correctly.



1316
1317
1318
1319
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1316

def higgs_installer_cmd host
  higgs_answer = use_meep?(host['pe_ver']) ? '1' : 'Y'
  "cd #{host['working_dir']}/#{host['dist']} ; nohup ./#{host['pe_installer']} <<<#{higgs_answer} > #{host['higgs_file']} 2>&1 &"
end

#ignore_gpg_key_warning_on_hosts(hosts, opts) ⇒ Object

For PE 3.8.5 to PE 2016.1.2 they have an expired gpg key. This method is for deb nodes to ignore the gpg-key expiration warning



985
986
987
988
989
990
991
992
993
994
995
996
997
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 985

def ignore_gpg_key_warning_on_hosts(hosts, opts)
  hosts.each do |host|
    # RPM based platforms do not seem to be effected by an expired GPG key,
    # while deb based platforms are failing.
    if host['platform'] =~ /debian|ubuntu/
      host_ver = host['pe_ver'] || opts['pe_ver']

      if version_is_less(host_ver, '3.8.7') || (!version_is_less(host_ver, '2015.2.0') && version_is_less(host_ver, '2016.4.0'))
        on(host, "echo 'APT { Get { AllowUnauthenticated \"1\"; }; };' >> /etc/apt/apt.conf")
      end
    end
  end
end

#install_agents_only_on(agent_nodes, opts) ⇒ Object

Method to install just the agent nodes This method can be called only after installing PE on infrastructure nodes

Parameters:

  • agent (Array) —

    only nodes from Beaker hosts

  • opts (Hash) —

    The Beaker options hash



1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1740

def install_agents_only_on(agent_nodes, opts)
  unless agent_nodes.empty?
    configure_type_defaults_on(agent_nodes)

     step "Setup frictionless installer on the master" do
       agent_nodes.each do |agent|
         # If We're *not* running the classic installer, we want
         # to make sure the master has packages for us.
         if agent['platform'] != master['platform'] # only need to do this if platform differs
           deploy_frictionless_to_master(agent)
         end
       end
     end

     step "Install agents" do
       block_on(agent_nodes, {:run_in_parallel => true}) do |host|
         install_ca_cert_on(host, opts)
         on(host, installer_cmd(host, opts))
       end
     end

     step "Sign agent certificates" do
       # This will sign all cert requests
       sign_certificate_for(agent_nodes)
     end

     step "Stop puppet agents to avoid interfering with tests" do
       stop_agent_on(agent_nodes, :run_in_parallel => true)
     end

     step "Run puppet on all agent nodes" do
       on agent_nodes, puppet_agent('-t'), :acceptable_exit_codes => [0,2], :run_in_parallel => true
     end

     #Workaround for windows frictionless install, see BKR-943
     agent_nodes.select {|agent| agent['platform'] =~ /windows/}.each do |agent|
       client_datadir = agent.puppet['client_datadir']
       on(agent, puppet("resource file \"#{client_datadir}\" ensure=absent force=true"))
     end
  end
end

#install_ca_cert_on(host, opts) ⇒ Object

If host or opts has the :use_puppet_ca_cert flag set, then push the master’s ca cert onto the given host at /etc/puppetlabs/puppet/ssl/certs/ca.pem.

This in turn allows frictionless_agent_installer_cmd to generate an install which references the cert to verify the master when downloading resources.



90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 90

def install_ca_cert_on(host, opts)
  if host[:use_puppet_ca_cert] || opts[:use_puppet_ca_cert]
    @cert_cache_dir ||= Dir.mktmpdir("master_ca_cert")
    local_cert_copy = "#{@cert_cache_dir}/ca.pem"
    step "Copying master ca.pem to agent for secure frictionless install" do
      agent_ca_pem_dir = "#{host['puppetpath']}/ssl/certs"
      master_ca_pem_path = "/etc/puppetlabs/puppet/ssl/certs/ca.pem"
      scp_from(master, master_ca_pem_path , @cert_cache_dir) unless File.exist?(local_cert_copy)
      on(host, "mkdir -p #{agent_ca_pem_dir}")
      scp_to(host, local_cert_copy, agent_ca_pem_dir)
    end
  end
end

#install_higgs(higgs_host = master) ⇒ Object

Note:

Either pe_ver and pe_dir should be set in the ENV or each host should have pe_ver and pe_dir set individually. Install file names are assumed to be of the format puppet-enterprise-VERSION-PLATFORM.(tar)|(tar.gz).

Install Higgs up till the point where you need to continue installation in a web browser, defaults to execution on the master node.

Examples:

install_higgs

Parameters:

  • higgs_host (Host) (defaults to: master) —

    The host to install Higgs on (supported on linux platform only)



1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1389

def install_higgs( higgs_host = master )
  #process the version files if necessary
  master['pe_dir'] ||= options[:pe_dir]
  master['pe_ver'] = master['pe_ver'] || options['pe_ver'] ||
    Beaker::Options::PEVersionScraper.load_pe_version(master[:pe_dir] || options[:pe_dir], options[:pe_version_file])
  if higgs_host['platform'] =~ /osx|windows/
    raise "Attempting higgs installation on host #{higgs_host.name} with unsupported platform #{higgs_host['platform']}"
  end
  #send in the global options hash
  do_higgs_install higgs_host, options
end

#install_pe ⇒ Object

Install PE based on global hosts with global options

See Also:



1153
1154
1155
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1153

def install_pe
  install_pe_on(hosts, options)
end

#install_pe_on(install_hosts, opts) ⇒ Object

Note:

Either pe_ver and pe_dir should be set in the ENV or each host should have pe_ver and pe_dir set individually. Install file names are assumed to be of the format puppet-enterprise-VERSION-PLATFORM.(tar)|(tar.gz) for Unix like systems and puppet-enterprise-VERSION.msi for Windows systems.

Note:

For further installation parameters (such as puppet-agent install) options, refer to #do_install documentation

Install PE based upon host configuration and options

Examples:

install_pe_on(hosts, {})

Parameters:

  • install_hosts (Host, Array<Host>) —

    One or more hosts to act upon

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

    Options to alter execution.

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.

  • :masterless (Boolean) —

    Are we performing a masterless installation?

  • :puppet_agent_version (String) —

    Version of puppet-agent to install. Required for PE agent only hosts on 4.0+

  • :puppet_agent_sha (String) —

    The sha of puppet-agent to install, defaults to puppet_agent_version. Required for PE agent only hosts on 4.0+

  • :pe_ver (String) —

    The version of PE (will also use host), defaults to ‘4.0’

  • :puppet_collection (String) —

    The puppet collection for puppet-agent install.



1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1230

def install_pe_on(install_hosts, opts)
  confine_block(:to, {}, install_hosts) do
    sorted_hosts.each do |host|
      #process the version files if necessary
      host['pe_dir'] ||= opts[:pe_dir]
      if host['platform'] =~ /windows/
        # we don't need the pe_version if:
        # * master pe_ver > 4.0
        if not (!opts[:masterless] && master[:pe_ver] && !version_is_less(master[:pe_ver], '3.99'))
          host['pe_ver'] ||= Beaker::Options::PEVersionScraper.load_pe_version(host[:pe_dir] || opts[:pe_dir], opts[:pe_version_file_win])
        else
          # inherit the master's version
          host['pe_ver'] ||= master[:pe_ver]
        end
      else
        host['pe_ver'] ||= Beaker::Options::PEVersionScraper.load_pe_version(host[:pe_dir] || opts[:pe_dir], opts[:pe_version_file])
      end
    end
    do_install sorted_hosts, opts
  end
end

#install_via_msi?(host) ⇒ Boolean

Deprecated.

the !version_is_less(host, ‘3.99’) can be removed once we no longer support pre 2015.2.0 PE versions

Check if windows host is able to frictionlessly install puppet

Parameters:

  • host (Beaker::Host) —

    that we are checking if it is possible to install frictionlessly to

Returns:

  • (Boolean) —

    true if frictionless is supported and not affected by known bugs



942
943
944
945
946
947
948
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 942

def install_via_msi?(host)
  #windows agents from 4.0 -> 2016.1.2 were only installable via the aio method
  #powershell2 bug was fixed in PE 2016.4.3, and PE 2017.1.0, but not 2016.5.z.
  (host['platform'] =~ /windows/ && (version_is_less(host['pe_ver'], '2016.4.0') && !version_is_less(host['pe_ver'], '3.99'))) ||
    (host['platform'] =~ /windows-2008r2/ && (version_is_less(host['pe_ver'], '2016.4.3') && !version_is_less(host['pe_ver'], '3.99'))) ||
    (host['platform'] =~ /windows-2008r2/ && (!version_is_less(host['pe_ver'], '2016.4.99') && version_is_less(host['pe_ver'], '2016.5.99') && !version_is_less(host['pe_ver'], '3.99')))
end

#installer_cmd(host, opts) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Create the PE install command string based upon the host and options settings

Examples:

on host, "#{installer_cmd(host, opts)} -a #{host['working_dir']}/answers"

Parameters:

  • host (Host) —

    The host that PE is to be installed on For UNIX machines using the full PE installer, the host object must have the ‘pe_installer’ field set correctly.

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

    The options

Options Hash (opts):

  • :pe_ver (String) —

    Default PE version to install or upgrade to (Otherwise uses individual hosts pe_ver)

  • :pe_debug (Boolean) — default: false —

    Should we run the installer in debug mode?



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
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 202

def installer_cmd(host, opts)
  version = host['pe_ver'] || opts[:pe_ver]
  # Frictionless install didn't exist pre-3.2.0, so in that case we fall
  # through and do a regular install.
  if host['roles'].include? 'frictionless' and ! version_is_less(version, '3.2.0')
    frictionless_agent_installer_cmd(host, opts, version)
  elsif host['platform'] =~ /osx/
    version = host['pe_ver'] || opts[:pe_ver]
    pe_debug = host[:pe_debug] || opts[:pe_debug] ? ' -verboseR' : ''
    "cd #{host['working_dir']} && hdiutil attach #{host['dist']}.dmg && installer#{pe_debug} -pkg /Volumes/puppet-enterprise-#{version}/puppet-enterprise-installer-#{version}.pkg -target /"
  elsif host['platform'] =~ /eos/
    host.install_from_file("puppet-enterprise-#{version}-#{host['platform']}.swix")
  else
    pe_debug = host[:pe_debug] || opts[:pe_debug]  ? ' -D' : ''
    pe_cmd = "cd #{host['working_dir']}/#{host['dist']} && ./#{host['pe_installer']}#{pe_debug}"
    if ! version_is_less(host['pe_ver'], '2016.2.1')
      # -y option sets "assume yes" mode where yes or whatever default will be assumed
      pe_cmd += " -y"
    end

    # If we are doing an upgrade from 2016.2.0,
    # we can assume there will be a valid pe.conf in /etc that we can re-use.
    # We also expect that any custom_answers specified to beaker have been
    # added to the pe.conf in /etc.
    if opts[:type] == :upgrade && use_meep?(host[:previous_pe_ver])
      "#{pe_cmd}"
    else
      "#{pe_cmd} #{host['pe_installer_conf_setting']}"
    end
  end
end

#lb_connect_loadbalancer_exists? ⇒ Boolean

Returns true if loadbalncer exists and is configured with ‘lb_connect’ role

Returns:

  • (Boolean) 


111
112
113
114
115
116
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 111

def lb_connect_loadbalancer_exists?
  if any_hosts_as?('loadbalancer')
    lb_node = select_hosts(roles: ['loadbalancer'])
    lb_node.first['roles'].include?('lb_connect')
  end
end

#loadbalancer_connecting_agents ⇒ Object

Return agent nodes with ‘lb_connect’ role that are not loadbalancers



105
106
107
108
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 105

def loadbalancer_connecting_agents
  lb_connect_nodes = select_hosts(roles: ['lb_connect'])
  lb_connect_agents = lb_connect_nodes.reject { |h| h['roles'].include?('loadbalancer')}
end

#original_pe_ver(host) ⇒ Object

Return the original pe_ver setting for the passed host. Beaker resets pe_ver to the value of pe_upgrade_ver during its upgrade process. If the hosts’s original configuration did not have a pe_ver, return the value of pe_ver set directly in options. It’s the Host that gets overwritten by Beaker on upgrade. So if the original host config did not have a pe_ver set, there should be a pe_ver set in options and we can use that.



1649
1650
1651
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1649

def original_pe_ver(host)
  options[:HOSTS][host.name][:pe_ver] || options[:pe_ver]
end

#prep_host_for_upgrade(host, opts = {}, path = '') ⇒ Object

Prep a host object for upgrade; used inside upgrade_pe_on !macro common_opts

Examples:

prep_host_for_upgrade(master, {}, "http://neptune.puppetlabs.lan/3.0/ci-ready/")

Parameters:

  • host (Host) —

    A single host object to prepare for upgrade

  • path (String) (defaults to: '') —

    A path (either local directory or a URL to a listing of PE builds). Will contain a LATEST file indicating the latest build to install. This is ignored if a pe_upgrade_ver and pe_upgrade_dir are specified in the host configuration file.



1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1296

def prep_host_for_upgrade(host, opts={}, path='')
  host['pe_dir'] = host['pe_upgrade_dir'] || path
  host['previous_pe_ver'] = host['pe_ver']
  if host['platform'] =~ /windows/
    host['pe_ver'] = host['pe_upgrade_ver'] || opts['pe_upgrade_ver'] ||
      Options::PEVersionScraper.load_pe_version(host['pe_dir'], opts[:pe_version_file_win])
  else
    host['pe_ver'] = host['pe_upgrade_ver'] || opts['pe_upgrade_ver'] ||
      Options::PEVersionScraper.load_pe_version(host['pe_dir'], opts[:pe_version_file])
  end
  if version_is_less(host['pe_ver'], '3.0')
    host['pe_installer'] ||= 'puppet-enterprise-upgrader'
  end
end

#prepare_host_installer_options(host) ⇒ Beaker::Host

Set installer options on the passed host according to current version.

Sets:

* 'pe_installer_conf_file'
* 'pe_installer_conf_setting'

Parameters:

  • host (Beaker::Host) —

    The host object to configure

Returns:

  • (Beaker::Host) —

    The same host object passed in



1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1008

def prepare_host_installer_options(host)
  if use_meep?(host['pe_ver'])
    conf_file = "#{host['working_dir']}/pe.conf"
    host['pe_installer_conf_file'] = conf_file
    host['pe_installer_conf_setting'] = "-c #{conf_file}"
  else
    conf_file = "#{host['working_dir']}/answers"
    host['pe_installer_conf_file'] = conf_file
    host['pe_installer_conf_setting'] = "-a #{conf_file}"
  end
  host
end

#prepare_hosts(hosts, local_options = {}) ⇒ Object

Note:

that these steps aren’t necessary for all hosts. Specifically, ‘agent_only’ hosts do not require these steps to be executed.

Prepares hosts for rest of #do_install operations. This includes doing these tasks:

  • setting ‘pe_installer’ property on hosts

  • setting ‘dist’ property on hosts

  • creating and setting ‘working_dir’ property on hosts

Parameters:

  • hosts (Array<Host>) —

    Hosts to prepare

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

    Local options, used to pass misc configuration required for the prep steps

Returns:

  • nil



854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 854

def prepare_hosts(hosts, local_options={})
  use_all_tar = ENV['PE_USE_ALL_TAR'] == 'true'
  hosts.each do |host|
    host['pe_installer'] ||= 'puppet-enterprise-installer'
    if host['platform'] !~ /windows|osx/
      platform = use_all_tar ? 'all' : host['platform']
      version = host['pe_ver'] || local_options[:pe_ver]
      host['dist'] = "puppet-enterprise-#{version}-#{platform}"
    elsif host['platform'] =~ /osx/
      version = host['pe_ver'] || local_options[:pe_ver]
      host['dist'] = "puppet-enterprise-#{version}-#{host['platform']}"
    elsif host['platform'] =~ /windows/
      version = host[:pe_ver] || local_options['pe_ver_win']
      is_config_32 = true == (host['ruby_arch'] == 'x86') || host['install_32'] || local_options['install_32']
      should_install_64bit = !(version_is_less(version, '3.4')) && host.is_x86_64? && !is_config_32
      #only install 64bit builds if
      # - we are on pe version 3.4+
      # - we do not have install_32 set on host
      # - we do not have install_32 set globally
      if !(version_is_less(version, '3.99'))
        if should_install_64bit
          host['dist'] = "puppet-agent-#{version}-x64"
        else
          host['dist'] = "puppet-agent-#{version}-x86"
        end
      elsif should_install_64bit
        host['dist'] = "puppet-enterprise-#{version}-x64"
      else
        host['dist'] = "puppet-enterprise-#{version}"
      end
    end
    host['working_dir'] = host.tmpdir(Time.new.strftime("%Y-%m-%d_%H.%M.%S"))
  end
end

#quoted_hocon_key(key) ⇒ Object

If the key is unquoted and does not contain pathing (‘.’), quote to ensure that puppet namespaces are protected

Examples:

quoted_hocon_key("puppet_enterprise::database_host")
# => '"puppet_enterprise::database_host"'


1634
1635
1636
1637
1638
1639
1640
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1634

def quoted_hocon_key(key)
  case key
  when /^[^"][^.]+/
    then %Q{"#{key}"}
  else key
  end
end

#register_feature_flags!(opts) ⇒ Object

The pe-modules-next package is being used for isolating large scale feature development of PE module code. The feature flag is a pe.conf setting ‘feature_flags::pe_modules_next’, which if set true will cause the installer shim to install the pe-modules-next package instead of pe-modules.

This answer can be explicitly added to Beaker’s cfg file by adding it to the :answers section.

But it can also be picked up transparently from CI via the PE_MODULES_NEXT environment variable. If this is set ‘true’, then the opts will be set with feature_flags::pe_modules_next.

Answers set in Beaker’s config file will take precedence over the environment variable.

NOTE: This has implications for upgrades, because upgrade testing will need the flag, but upgrades from different pe.conf schema (or no pe.conf) will need to generate a pe.conf, and that workflow is likely to happen in the installer shim. If we simply supply a good pe.conf via beaker-answers, then we have bypassed the pe.conf generation aspect of the upgrade workflow. (See PE-19438)



1071
1072
1073
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1071

def register_feature_flags!(opts)
  Beaker::DSL::InstallUtils::FeatureFlags.new(opts).register_flags!
end

#run_puppet_on_non_infrastructure_nodes(all_hosts) ⇒ Object

Runs puppet on all nodes, unless they have the roles: master,database,console/dashboard

Parameters:

  • hosts (Array<Host>) —

    The sorted hosts to install or upgrade PE on



952
953
954
955
956
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 952

def run_puppet_on_non_infrastructure_nodes(all_hosts)
  pe_infrastructure = select_hosts({:roles => ['master', 'compile_master', 'dashboard', 'database']}, all_hosts)
  non_infrastructure = all_hosts.reject{|host| pe_infrastructure.include? host}
  on non_infrastructure, puppet_agent('-t'), :acceptable_exit_codes => [0,2], :run_in_parallel => true
end

#setup_beaker_answers_opts(host, opts) ⇒ Hash

Adds in settings needed by BeakerAnswers:

  • :format => :bash or :hiera depending on which legacy or meep format we need

  • :include_legacy_database_defaults => true or false. True indicates that we are upgrading from a legacy version and BeakerAnswers should include the database defaults for user which were set for the legacy install.

Parameters:

  • host (Beaker::Host) —

    that we are generating answers for

  • opts (Hash) —

    The Beaker options hash

Returns:

  • (Hash) —

    a dup of the opts hash with additional settings for BeakerAnswers



1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1032

def setup_beaker_answers_opts(host, opts)
  beaker_answers_opts = use_meep?(host['pe_ver']) ?
    { :format => :hiera } :
    { :format => :bash }

  beaker_answers_opts[:include_legacy_database_defaults] =
    opts[:type] == :upgrade && !use_meep?(host['previous_pe_ver'])

  modified_opts = opts.merge(beaker_answers_opts)

  if feature_flag?('pe_modules_next', opts) && !modified_opts.include?(:meep_schema_version)
    modified_opts[:meep_schema_version] = '2.0'
  end

  modified_opts
end

#setup_defaults_and_config_helper_on(host, master, acceptable_exit_codes = nil) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Helper for setting up pe_defaults & setting up the cert on the host

Parameters:

  • host (Host) —

    host to setup

  • master (Host) —

    the master host, for setting up the relationship

  • acceptable_exit_codes (Array<Fixnum>) (defaults to: nil) —

    The exit codes that we want to ignore

Returns:

  • nil



1142
1143
1144
1145
1146
1147
1148
1149
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1142

def setup_defaults_and_config_helper_on(host, master, acceptable_exit_codes=nil)
  configure_type_defaults_on(host)
  #set the certname and master
  on host, puppet("config set server #{master}")
  on host, puppet("config set certname #{host}")
  #run once to request cert
  on host, puppet_agent('-t'), :acceptable_exit_codes => acceptable_exit_codes
end

#setup_pe_conf(host, hosts, opts = {}) ⇒ Object 



1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1700

def setup_pe_conf(host, hosts, opts={})
  if opts[:type] == :upgrade && use_meep?(host['previous_pe_ver'])
    # In this scenario, Beaker runs the installer such that we make
    # use of recovery code in the configure face of the installer.
    if host['roles'].include?('master')
      step "Updating #{MEEP_DATA_DIR}/conf.d with answers/custom_answers" do
        # merge answers into pe.conf
        if opts[:answers] && !opts[:answers].empty?
          update_pe_conf(opts[:answers])
        end

        if opts[:custom_answers] && !opts[:custom_answers].empty?
          update_pe_conf(opts[:custom_answers])
        end
      end
    else
      step "Uploading #{BEAKER_MEEP_TMP}/conf.d that was generated on the master" do
        # scp conf.d to host
        scp_to(host, "#{BEAKER_MEEP_TMP}/conf.d", MEEP_DATA_DIR)
      end
    end
  else
    # Beaker creates a fresh pe.conf using beaker-answers, as if we were doing an install
    generate_installer_conf_file_for(host, hosts, opts)
  end
end

#simple_monolithic_install(master, agents, opts = {}) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Install PE on a monolithic master and some number of frictionless agents.

Examples:

simple_monolithic_install(master, agents, {:type => :install, :pe_ver => '2017.2.0'})

Parameters:

  • master (Host) —

    The node to install the master on

  • agents (Array<Host>) —

    The nodes to install agents on

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

    The options for how to install or upgrade PE

Returns:

  • nil



599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 599

def simple_monolithic_install(master, agents, opts={})
  step "Performing a standard monolithic install with frictionless agents"
  all_hosts = [master, *agents]
  configure_type_defaults_on([master])

  # Set PE distribution on the agents, creates working directories
  prepare_hosts(all_hosts, opts)
  fetch_pe([master], opts)
  prepare_host_installer_options(master)
  generate_installer_conf_file_for(master, all_hosts, opts)
  step "Install PE on master" do
    on master, installer_cmd(master, opts)
  end

  step "Stop agent on master" do
    stop_agent_on(master)
  end

  step "Run puppet to setup mcollective and pxp-agent" do
    on(master, puppet_agent('-t'), :acceptable_exit_codes => [0,2])
  end

  install_agents_only_on(agents, opts)

  step "Run puppet a second time on the primary to populate services.conf (PE-19054)" do
    on(master, puppet_agent('-t'), :acceptable_exit_codes => [0,2])
  end
end

#update_pe_conf(parameters, pe_conf_file = PE_CONF_FILE) ⇒ Object

Given a hash of parameters, updates the primary master’s pe.conf, adding or replacing, or removing the given parameters.

To remove a parameter, pass a nil as its value

Handles stringifying and quoting namespaced keys, and also preparing non string values using Hocon::ConfigValueFactory.

Logs the state of pe.conf before and after.

Examples:

# Assuming pe.conf looks like:
# {
# "bar": "baz"
# "old": "item"
# }

update_pe_conf(
  {
    "foo" => "a",
    "bar" => "b",
    "old" => nil,
  }
)

# Will produce a pe.conf like:
# {
# "bar": "b"
# "foo": "a"
# }

Parameters:

  • parameters (Hash) —

    Hash of parameters to be included in pe.conf.

  • pe_conf_file (String) (defaults to: PE_CONF_FILE) —

    The file to update (/etc/puppetlabs/enterprise/conf.d/pe.conf by default)



1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1593

def update_pe_conf(parameters, pe_conf_file = PE_CONF_FILE)
  step "Update #{pe_conf_file} with #{parameters}" do
    hocon_file_edit_in_place_on(master, pe_conf_file) do |host,doc|
      updated_doc = parameters.reduce(doc) do |pe_conf,param|
        key, value = param

        hocon_key = quoted_hocon_key(key)

        hocon_value = case value
        when String
          # ensure unquoted string values are quoted for uniformity
          then value.match(/^[^"]/) ? %Q{"#{value}"} : value
        else Hocon::ConfigValueFactory.from_any_ref(value, nil)
        end

        updated = case value
        when String
          pe_conf.set_value(hocon_key, hocon_value)
        when nil
          pe_conf.remove_value(hocon_key)
        else
          pe_conf.set_config_value(hocon_key, hocon_value)
        end

        updated
      end

      # return the modified document
      updated_doc
    end
    on(master, "cat #{pe_conf_file}")
  end
end

#upgrade_pe(path = nil) ⇒ Object

Upgrade PE based upon global host configuration and global options

See Also:



1254
1255
1256
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1254

def upgrade_pe path=nil
  upgrade_pe_on(hosts, options, path)
end

#upgrade_pe_on(upgrade_hosts, opts, path = nil) ⇒ Object

Note:

Install file names are assumed to be of the format puppet-enterprise-VERSION-PLATFORM.(tar)|(tar.gz) for Unix like systems and puppet-enterprise-VERSION.msi for Windows systems.

Upgrade PE based upon host configuration and options

Examples:

upgrade_pe_on(agents, {}, "http://neptune.puppetlabs.lan/3.0/ci-ready/")

Parameters:

  • upgrade_hosts (Host, Array<Host>) —

    One or more hosts to act upon

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

    Options to alter execution.

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

    A path (either local directory or a URL to a listing of PE builds). Will contain a LATEST file indicating the latest build to install. This is ignored if a pe_upgrade_ver and pe_upgrade_dir are specified in the host configuration file.

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.



1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1270

def upgrade_pe_on upgrade_hosts, opts, path=nil
  confine_block(:to, {}, upgrade_hosts) do
    set_console_password = false
    # if we are upgrading from something lower than 3.4 then we need to set the pe console password
    if (dashboard[:pe_ver] ? version_is_less(dashboard[:pe_ver], "3.4.0") : true)
      set_console_password = true
    end
    # get new version information
    hosts.each do |host|
      prep_host_for_upgrade(host, opts, path)
    end

    do_install(sorted_hosts, opts.merge({:type => :upgrade, :set_console_password => set_console_password}))
    opts['upgrade'] = true
  end
end

#upgrading_to_pe_ver(host) ⇒ Object

Returns the version of PE that the host will be upgraded to If no upgrade is planned then just the version of PE to install is returned



1655
1656
1657
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 1655

def upgrading_to_pe_ver(host)
  options[:HOSTS][host.name][:pe_upgrade_ver] || options[:pe_ver]
end

#use_meep?(version) ⇒ Boolean

True if version is greater than or equal to MEEP_CUTOVER_VERSION (2016.2.0)

Returns:

  • (Boolean) 


921
922
923
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 921

def use_meep?(version)
  !version_is_less(version, MEEP_CUTOVER_VERSION)
end

#use_meep_for_classification?(version, opts) ⇒ Boolean

True if version is greater than or equal to MEEP_CLASSIFICATION_VERSION (PE-18718) AND the temporary feature flag is true.

The temporary feature flag is pe_modules_next and can be set in the :answers hash given in beaker’s host.cfg, inside a feature_flags hash. It will also be picked up from the environment as PE_MODULES_NEXT. (See register_feature_flags!())

The :answers hash value will take precedence over the env variable.

Parameters:

  • version —

    String the current PE version

  • opts —

    Hash options hash to inspect for :answers

Returns:

  • (Boolean) —

    Boolean true if version and flag allows for meep classification feature.



972
973
974
975
976
977
978
979
980
981
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 972

def use_meep_for_classification?(version, opts)
  # PE-19470 remove vv
  register_feature_flags!(opts)

  temporary_flag = feature_flag?('pe_modules_next', opts)
  temporary_flag = DEFAULT_MEEP_CLASSIFICATION if temporary_flag.nil?
  # ^^

  !version_is_less(version, MEEP_CLASSIFICATION_VERSION) && temporary_flag
end

#verify_network_resources(hosts, network_resources) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Check for availability of required network resources

Examples:

verify_network_resources(hosts, network_resources)

Parameters:

  • hosts (Array<Host>)
  • network_resources (Array<String>)

Returns:

  • nil



468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
 
# File 'lib/beaker-pe/install/pe_utils.rb', line 468

def verify_network_resources(hosts, network_resources)
  logger.notify("Checking the availability of network resources.")
  hosts.each do |host|
    # if options[:net_diag_hosts] isn't set, skip this check
    if network_resources != nil
      network_resources.each do |resource|
        # curl the network resource silently (-s), only connect (-I), and don't print the output
        on host, "curl -I -s #{resource} > /dev/null", :accept_all_exit_codes => true
        if host.connection.logger.last_result.exit_code != 0
          logger.warn("Connection error: #{host.host_hash[:vmhostname]} was unable to connect to #{resource}. Please ensure that your test does not require this resource.")
        end
      end
    end
    hosts.each do |target_host|
      ping_opts = host['platform'] =~ /windows/ ? "-n 1" : "-c1"
      on host, "ping #{ping_opts} #{target_host.host_hash[:vmhostname]} > /dev/null", :accept_all_exit_codes => true
      if host.connection.logger.last_result.exit_code != 0
        logger.warn("Connection error: #{host.host_hash[:vmhostname]} was unable to connect to #{target_host.host_hash[:vmhostname]} in your testing infrastructure.")
      end
    end
  end
end