Common functionality

Each of the dynamic methods has a simple rest_action method to perform the RESTful call to Satellite:

def rest_action(uri, verb, payload=nil)
  headers = {
    :content_type  => 'application/json',
    :accept        => 'application/json;version=2',
    :authorization => 
                   "Basic #{Base64.strict_encode64("#{@username}:#{@password}")}"
  }
  response = RestClient::Request.new(
    :method      => verb,
    :url         => uri,
    :headers     => headers,
    :payload     => payload,
    verify_ssl: false
  ).execute
  return JSON.parse(response.to_str)
end

They each pull the credentials from the instance schema and define the base URI and an empty values_hash:

servername = $evm.object['servername']
@username  = $evm.object['username']
@password  = $evm.object.decrypt('password')

uri_base = "https://#{servername}/api/v2"
values_hash = {}

ListHostGroups

The list_hostgroups method does not need to connect to the Satellite RESTful API, as the Satellite server is registered as a configuration management provider. The method performs a simple VMDB lookup of all configuration profiles:

hostgroups = $evm.vmdb(:configuration_profile).all

if hostgroups.length > 0
  if hostgroups.length > 1
    values_hash['!'] = '-- select from list --'
  end
  hostgroups.each do |hostgroup|
    $evm.log(:info, "Found Host Group '#{hostgroup.name}' 
                                       with ID: #{hostgroup.manager_ref}")
    values_hash[hostgroup.manager_ref] = hostgroup.name
  end
else
  values_hash['!'] = 'No hostgroups are available'
end

ListActivationKeys

The list_activationkeys method retrieves the hostgroup_id from the Host Group element and makes a Satellite API call to get the hostgroup parameters:

hg_id = $evm.object['dialog_hostgroup_id']

if hg_id.nil?
  values_hash['!'] = "Select a Host Group and click 'Refresh'"
else
  rest_return = rest_action("#{uri_base}/hostgroups/#{hg_id}/parameters", :get)
  rest_return['results'].each do |hostgroup_parameter|
    if hostgroup_parameter['name'].to_s == "kt_activation_keys"
      hostgroup_parameter['value'].split(',').each do |activationkey|
        values_hash[activationkey] = activationkey
      end
    end
  end
  if values_hash.length > 0
    if values_hash.length > 1
      values_hash['!'] = '-- select from list --'
    end
  else
    values_hash['!'] = 'This Host Group has no Activation Keys'
  end
end

ListPuppetClasses

The list_puppetclasses method retrieves the hostgroup_id from the Host Group element and makes a Satellite API call to get the Puppet classes associated with the host group:

hg_id = $evm.object['dialog_hostgroup_id']

if hg_id.nil?
  values_hash['!'] = "Select a Host Group and click 'Refresh'"
else
  rest_return = rest_action("#{uri_base}/hostgroups/#{hg_id}/puppetclasses",:get)
  if rest_return['total'] > 0
    if rest_return['total'] > 1
      values_hash['!'] = '-- select from list --'
    end
    rest_return['results'].each do |classname, classinfo|
      values_hash[classinfo[0]['id'].to_s] = classname
    end
  else
    values_hash['!'] = 'No Puppet Classes are defined for this Hostgroup'
  end
end

ListSmartClassParameters

The list_smart_class_parameters method retrieves the hostgroup_id and puppetclass_id from previous elements and makes a Satellite API call to get the Puppet smart class parameters associated with the host group. For each parameter returned it then makes a further Satellite API call to cross-reference against the requested Puppet class:

hg_id           = $evm.object['dialog_hostgroup_id']
puppet_class_id = $evm.object['dialog_puppet_class_id']

if puppet_class_id.nil?
  values_hash['!'] = "Select a Puppet Class and click 'Refresh'"
else
  call_string = "#{uri_base}/hostgroups/#{hg_id}/smart_class_parameters"
  rest_return = rest_action(call_string, :get)
  rest_return['results'].each do |parameter|
    #
    # Retrieve the details of this smart class parameter
    # to find out which puppet class it's associated with
    #
    call_string = "#{uri_base}/hostgroups/#{hg_id}/"
    call_string += "smart_class_parameters/#{parameter['id']}"
    parameter_details = rest_action(call_string, :get)
    if parameter_details['puppetclass']['id'].to_s == puppet_class_id
      values_hash[parameter['id'].to_s] = parameter_details['parameter']
    end
  end
  if values_hash.length > 0
    if values_hash.length > 1
      values_hash['!'] = '-- select from list --'
    end
  else
    values_hash['!'] = 'This Puppet class has no Smart Class Parameters'
  end
end

Making several cross-referencing API calls to Satellite in this way can be slow if many Puppet classes with smart class variables are defined in our host group, but this technique is suitable for our example.

RegisterSatellite

We edit the register_satellite method from Chapter 28 to take out the hardcoded selection of host group. We also bypass Satellite registration entirely if we don’t find the hostgroup_id:

#
# Only register if the provisioning template is linux
#
if template.platform == "linux"
  #
  # Only register with Satellite if we've been passed a
  # hostgroup ID from a service dialog
  #
  hg_id = $evm.root['miq_provision'].get_option(:dialog_hostgroup_id)
  unless hg_id.nil?
    ...

ActivateSatellite

We edit the activate_satellite method from Chapter 28 to take out the hardcoded selection of activation key. We also bypass Satellite activation entirely if we don’t find the activation key name:

#
# Only register if the provisioning template is linux
#
prov = $evm.root['miq_provision']
if template.platform == "linux"
  #
  # Only register and activate with Satellite if we've been passed an
  # activation key from a service dialog
  #
  activationkey = prov.get_option(:dialog_activationkey_name)
  unless activationkey.nil?
    ...

SetConfiguration

The set_configuration method will be called from two completely different state machines, once to perform an initial configuration during provisioning and possibly again during a service reconfigure request. The method must retrieve the service dialog values from either of two different places:

  if $evm.root['vmdb_object_type'] == 'miq_provision'
    prov = $evm.root['miq_provision']
    parameter_id    = prov.get_option(:dialog_parameter_id)
    parameter_value = prov.get_option(:dialog_parameter_value)
    hg_id           = prov.get_option(:dialog_hostgroup_id)
    hostname        = prov.get_option(:dialog_vm_name)
  elsif $evm.root['vmdb_object_type'] == 'service_reconfigure_task'
    parameter_id    = $evm.root['dialog_parameter_id']
    parameter_value = $evm.root['dialog_parameter_value']
    hg_id           = $evm.root['dialog_hostgroup_id']
    hostname        = $evm.root['dialog_vm_name']
  end

If a smart class parameter override value has not been input, the method simply exits:

  #
  # Only set the smart class parameter if we've been passed a
  # parameter value from a service dialog
  #
  unless parameter_value.nil?
     ...

The method must fetch the default domain name from the host group to assemble the correct FQDN for the match:

rest_return = rest_action("#{uri_base}/hostgroups/#{hg_id}", :get)
domain_name = rest_return['domain_name']
match = "fqdn=#{hostname}.#{domain_name}"

The method must also determine whether the override match already exists. If it doesn’t exist, it must be created with a POST action; if it does exist, it must be updated with a PUT action:

call_string = "#{uri_base}/smart_class_parameters/"
call_string += "#{parameter_id}/override_values"
rest_return = rest_action(call_string, :get)
override_value_id = 0
if rest_return['total'] > 0
  rest_return['results'].each do |override_value|
    if override_value['match'] == match
      override_value_id = override_value['id']
    end
  end
end
if override_value_id.zero?
  payload = {
    :match => match,
    :value => parameter_value
  }
  call_string = "#{uri_base}/smart_class_parameters/"
  call_string += "#{parameter_id}/override_values"
  rest_return = rest_action(call_string, :post, JSON.generate(payload))
else
  payload = {
    :value => parameter_value
  }
  call_string = "#{uri_base}/smart_class_parameters/"
  call_string =+ "#{parameter_id}/override_values/#{override_value_id}"
  rest_return = rest_action(call_string, :put, JSON.generate(payload))
end

Here we see that match is the FQDN of the server. If an override match doesn’t exist for this smart class parameter, we create one using the server FQDN and the value to override. If an override match based on the FQDN does exist, we simply update the override value.

The full code for the methods is available on GitHub.