# # Copyright (c) 2017 Wind River Systems, Inc. # # SPDX-License-Identifier: Apache-2.0 # import copy import itertools import os import operator from sysinv.common import constants from sysinv.common import exception from sysinv.common import utils from tsconfig import tsconfig from . import base HOSTNAME_INFRA_SUFFIX = '-infra' NOVA_UPGRADE_LEVEL_PIKE = 'pike' NOVA_UPGRADE_LEVELS = {'18.03': NOVA_UPGRADE_LEVEL_PIKE} class PlatformPuppet(base.BasePuppet): """Class to encapsulate puppet operations for platform configuration""" def get_static_config(self): config = {} config.update(self._get_static_software_config()) return config def get_secure_static_config(self): config = {} config.update(self._get_secure_amqp_config()) return config def get_system_config(self): config = {} config.update(self._get_system_config()) config.update(self._get_hosts_config()) config.update(self._get_amqp_config()) config.update(self._get_resolv_config()) config.update(self._get_haproxy_config()) config.update(self._get_sdn_config()) config.update(self._get_region_config()) config.update(self._get_distributed_cloud_role()) config.update(self._get_sm_config()) config.update(self._get_firewall_config()) config.update(self._get_drbd_sync_config()) config.update(self._get_nfs_config()) config.update(self._get_remotelogging_config()) config.update(self._get_snmp_config()) return config def get_secure_system_config(self): config = {} config.update(self._get_user_config()) return config def get_host_config(self, host): config = {} config.update(self._get_host_platform_config(host, self.config_uuid)) config.update(self._get_host_ntp_config(host)) config.update(self._get_host_ptp_config(host)) config.update(self._get_host_sysctl_config(host)) config.update(self._get_host_drbd_config(host)) config.update(self._get_host_upgrade_config(host)) config.update(self._get_host_tpm_config(host)) config.update(self._get_host_cpu_config(host)) config.update(self._get_host_memory_config(host)) config.update(self._get_host_lldp_config(host)) return config def _get_static_software_config(self): return { 'platform::params::software_version': self.quoted_str(tsconfig.SW_VERSION), } def _get_secure_amqp_config(self): return { 'platform::amqp::params::auth_password': self._generate_random_password(), } def _get_system_config(self): system = self._get_system() return { 'platform::params::controller_upgrade': False, 'platform::params::config_path': tsconfig.CONFIG_PATH, 'platform::params::security_profile': system.security_profile, 'platform::params::security_feature': system.security_feature, 'platform::config::params::timezone': system.timezone, 'platform::params::vswitch_type': self._vswitch_type(), } def _get_hosts_config(self): # list of host tuples (host name, address name, newtork type) that need # to be populated in the /etc/hosts file hostnames = [ # management network hosts (constants.CONTROLLER_HOSTNAME, constants.CONTROLLER_HOSTNAME, constants.NETWORK_TYPE_MGMT), (constants.CONTROLLER_0_HOSTNAME, constants.CONTROLLER_0_HOSTNAME, constants.NETWORK_TYPE_MGMT), (constants.CONTROLLER_1_HOSTNAME, constants.CONTROLLER_1_HOSTNAME, constants.NETWORK_TYPE_MGMT), (constants.CONTROLLER_PLATFORM_NFS, constants.CONTROLLER_PLATFORM_NFS, constants.NETWORK_TYPE_MGMT), (constants.CONTROLLER_CGCS_NFS, constants.CONTROLLER_CGCS_NFS, constants.NETWORK_TYPE_MGMT), # pxeboot network hosts (constants.PXECONTROLLER_HOSTNAME, constants.CONTROLLER_HOSTNAME, constants.NETWORK_TYPE_PXEBOOT), # oam network hosts (constants.OAMCONTROLLER_HOSTNAME, constants.CONTROLLER_HOSTNAME, constants.NETWORK_TYPE_OAM), # cinder storage hosts (constants.CONTROLLER_CINDER, constants.CONTROLLER_CINDER, constants.NETWORK_TYPE_MGMT), (constants.CONTROLLER_CINDER, constants.CONTROLLER_CINDER, constants.NETWORK_TYPE_INFRA), # ceph storage hosts (constants.STORAGE_0_HOSTNAME, constants.STORAGE_0_HOSTNAME, constants.NETWORK_TYPE_MGMT), (constants.STORAGE_1_HOSTNAME, constants.STORAGE_1_HOSTNAME, constants.NETWORK_TYPE_MGMT), # infrastructure network hosts (constants.CONTROLLER_0_HOSTNAME + HOSTNAME_INFRA_SUFFIX, constants.CONTROLLER_0_HOSTNAME, constants.NETWORK_TYPE_INFRA), (constants.CONTROLLER_1_HOSTNAME + HOSTNAME_INFRA_SUFFIX, constants.CONTROLLER_1_HOSTNAME, constants.NETWORK_TYPE_INFRA), (constants.STORAGE_0_HOSTNAME + HOSTNAME_INFRA_SUFFIX, constants.STORAGE_0_HOSTNAME, constants.NETWORK_TYPE_INFRA), (constants.STORAGE_1_HOSTNAME + HOSTNAME_INFRA_SUFFIX, constants.STORAGE_1_HOSTNAME, constants.NETWORK_TYPE_INFRA), (constants.CONTROLLER_CGCS_NFS, constants.CONTROLLER_CGCS_NFS, constants.NETWORK_TYPE_INFRA), ] hosts = {} for hostname, name, networktype in hostnames: try: address = self._get_address_by_name(name, networktype) hosts.update({hostname: {'ip': address.address}}) except exception.AddressNotFoundByName: pass return { 'platform::config::params::hosts': hosts } def _get_host_upgrade_config(self, host): config = {} try: upgrade = self.dbapi.software_upgrade_get_one() except exception.NotFound: return config upgrade_states = [constants.UPGRADE_ACTIVATING, constants.UPGRADE_ACTIVATION_FAILED, constants.UPGRADE_ACTIVATION_COMPLETE, constants.UPGRADE_COMPLETED] # we don't need compatibility mode after we activate if upgrade.state in upgrade_states: return config upgrade_load_id = upgrade.to_load host_upgrade = self.dbapi.host_upgrade_get_by_host(host['id']) if host_upgrade.target_load == upgrade_load_id: from_load = self.dbapi.load_get(upgrade.from_load) sw_version = from_load.software_version nova_level = NOVA_UPGRADE_LEVELS.get(sw_version) if not nova_level: raise exception.SysinvException( ("No matching upgrade level found for version %s") % sw_version) config.update({ 'nova::upgrade_level_compute': nova_level }) return config def _get_amqp_config(self): return { 'platform::amqp::params::host': self._get_management_address(), 'platform::amqp::params::host_url': self._format_url_address(self._get_management_address()), } def _get_resolv_config(self): servers = [self._get_management_address()] dns = self.dbapi.idns_get_one() if dns.nameservers: servers += dns.nameservers.split(',') return { 'platform::dns::resolv::servers': servers } def _get_user_config(self): user = self.dbapi.iuser_get_one() return { 'platform::users::params::wrsroot_password': user.passwd_hash, 'platform::users::params::wrsroot_password_max_age': user.passwd_expiry_days, } def _get_haproxy_config(self): public_address = self._get_address_by_name( constants.CONTROLLER, constants.NETWORK_TYPE_OAM) private_address = self._get_address_by_name( constants.CONTROLLER, constants.NETWORK_TYPE_MGMT) https_enabled = self._https_enabled() config = { 'platform::haproxy::params::public_ip_address': public_address.address, 'platform::haproxy::params::private_ip_address': private_address.address, 'platform::haproxy::params::enable_https': https_enabled, } try: tpmconfig = self.dbapi.tpmconfig_get_one() if tpmconfig.tpm_path: config.update({ 'platform::haproxy::params::tpm_object': tpmconfig.tpm_path }) except exception.NotFound: pass return config def _get_sdn_config(self): return { 'platform::params::sdn_enabled': self._sdn_enabled() } def _get_region_config(self): if not self._region_config(): return {} region_1_name = self._operator.keystone.get_region_name() region_2_name = self._region_name() return { 'platform::params::region_config': self._region_config(), 'platform::params::region_1_name': region_1_name, 'platform::params::region_2_name': region_2_name, } def _get_distributed_cloud_role(self): if self._distributed_cloud_role() is None: return {} return { 'platform::params::distributed_cloud_role': self._distributed_cloud_role(), } def _get_sm_config(self): multicast_address = self._get_address_by_name( constants.SM_MULTICAST_MGMT_IP_NAME, constants.NETWORK_TYPE_MULTICAST) return { 'platform::sm::params::mgmt_ip_multicast': multicast_address.address, 'platform::sm::params::infra_ip_multicast': multicast_address.address, } def _get_firewall_config(self): config = {} rules_filepath = os.path.join(tsconfig.PLATFORM_CONF_PATH, 'iptables.rules') if os.path.isfile(rules_filepath): config.update({ 'platform::firewall::oam::rules_file': rules_filepath }) return config def _get_host_platform_config(self, host, config_uuid): if not config_uuid: config_uuid = host.config_target # required parameters config = { 'platform::params::hostname': host.hostname, 'platform::params::software_version': self.quoted_str(host.software_load), } # optional parameters if config_uuid: config.update({ 'platform::config::params::config_uuid': config_uuid }) if host.personality == constants.CONTROLLER: controller0_address = self._get_address_by_name( constants.CONTROLLER_0_HOSTNAME, constants.NETWORK_TYPE_MGMT) controller1_address = self._get_address_by_name( constants.CONTROLLER_1_HOSTNAME, constants.NETWORK_TYPE_MGMT) if host.hostname == constants.CONTROLLER_0_HOSTNAME: mate_hostname = constants.CONTROLLER_1_HOSTNAME mate_address = controller1_address else: mate_hostname = constants.CONTROLLER_0_HOSTNAME mate_address = controller0_address config.update({ 'platform::params::controller_0_ipaddress': controller0_address.address, 'platform::params::controller_1_ipaddress': controller1_address.address, 'platform::params::controller_0_hostname': constants.CONTROLLER_0_HOSTNAME, 'platform::params::controller_1_hostname': constants.CONTROLLER_1_HOSTNAME, 'platform::params::mate_hostname': mate_hostname, 'platform::params::mate_ipaddress': mate_address.address, }) system = self._get_system() config.update({ 'platform::params::system_name': system.name, 'platform::params::system_mode': system.system_mode, 'platform::params::system_type': system.system_type, }) cpu_count = self._get_platform_cpu_count(host) config.update({ 'platform::params::platform_cpu_count': cpu_count, }) return config def _get_host_ntp_config(self, host): ntp = self.dbapi.intp_get_one() if host.personality == constants.CONTROLLER: servers = ntp.ntpservers.split(',') if ntp.ntpservers else [] else: controller0_address = self._get_address_by_name( constants.CONTROLLER_0_HOSTNAME, constants.NETWORK_TYPE_MGMT) controller1_address = self._get_address_by_name( constants.CONTROLLER_1_HOSTNAME, constants.NETWORK_TYPE_MGMT) # All other hosts use the controller management IP addresses servers = [controller0_address.address, controller1_address.address] # Logic behind setting the ntpdate_timeout: # If no servers are datafilled, the only one in # the list is the other controller. When the first # controller is brought up, the other one doesn't # exist to respond, so we will always wait and timeout. # When the second controller is brought up, it will # always go to the active controller which should be # there and respond quickly. So the compromise between # these two controller situations is a 30 second timeout. # # The 180 second timeout is used to cover for a 3 server + # peer controller situation where 2 DNS servers are # provided and neither DNS server responds to queries. The # longer timeout here will allow access to all 3 servers to # timeout and yet still have enough time to talk to and get # a useable response out of the peer controller. # # Also keep in mind that ntpdate's role is to bring # errant system clocks that are more than 1000 seconds from # reality back into line. If the system clock is under 1000 # seconds out, the ntpd will bring it back in line anyway, # and 11 minute mode will keep it accurate. It also helps # minimize system clock stepping by ntpd, the likes of which # may occur 15-20 minutes after reboot when ntpd finally # decides what to do after analyzing all servers available # to it. This clock stepping can be disruptive to the # system and thus we have ntpdate in place to minimize that. if servers: ntpdate_timeout = "180" else: ntpdate_timeout = "30" return { 'platform::ntp::enabled': ntp.enabled, 'platform::ntp::servers': servers, 'platform::ntp::ntpdate_timeout': ntpdate_timeout, } def _get_host_ptp_config(self, host): ptp = self.dbapi.ptp_get_one() return { 'platform::ptp::enabled': ptp.enabled, 'platform::ptp::mode': ptp.mode, 'platform::ptp::transport': ptp.transport, 'platform::ptp::mechanism': ptp.mechanism, } def _get_host_sysctl_config(self, host): config = {} if host.personality == constants.CONTROLLER: remotelogging = self.dbapi.remotelogging_get_one() ip_forwarding = (self._region_config() or self._sdn_enabled() or remotelogging.enabled) # The forwarding IP version is based on the OAM network version address = self._get_address_by_name( constants.CONTROLLER_HOSTNAME, constants.NETWORK_TYPE_OAM) ip_version = address.family config.update({ 'platform::sysctl::params::ip_forwarding': ip_forwarding, 'platform::sysctl::params::ip_version': ip_version, }) if constants.LOWLATENCY in host.subfunctions: config.update({ 'platform::sysctl::params::low_latency': True }) return config def _get_drbd_sync_config(self): drbdconfig = self.dbapi.drbdconfig_get_one() return { 'platform::drbd::params::link_util': str(drbdconfig.link_util), 'platform::drbd::params::num_parallel': str(drbdconfig.num_parallel), 'platform::drbd::params::rtt_ms': str(drbdconfig.rtt_ms), } def _get_host_drbd_config(self, host): config = {} system = self._get_system() if system.system_type == constants.TIS_AIO_BUILD: # restrict DRBD syncing to platform cores/threads platform_cpus = self._get_host_cpu_list( host, function=constants.PLATFORM_FUNCTION, threads=True) # build a hex bitmap of the platform cores platform_cpumask = 0 for cpu in platform_cpus: platform_cpumask |= 1 << cpu.cpu drbd_cpumask = '%x' % platform_cpumask config.update({ 'platform::drbd::params::cpumask': drbd_cpumask }) return config def _get_host_tpm_config(self, host): config = {} if host.personality == constants.CONTROLLER: try: tpmdevice = self.dbapi.tpmdevice_get_by_host(host.id) if tpmdevice and len(tpmdevice) == 1: tpm_data = tpmdevice[0].tpm_data # some of the TPM certs may be base64 encoded # for transmission over RPC and storage in DB, # convert these back to their native encoding encoded_files = tpm_data.pop("base64_encoded_files", []) for binary in encoded_files: tpm_data[binary] = tpm_data[binary].decode('base64') config.update({ 'platform::tpm::tpm_data': tpm_data }) except exception.NotFound: # No TPM device found pass return config def _get_host_cpu_config(self, host): config = {} if constants.WORKER in utils.get_personalities(host): host_cpus = self._get_host_cpu_list(host, threads=True) if not host_cpus: return config # Define the full range of CPUs for the compute host max_cpu = max(host_cpus, key=operator.attrgetter('cpu')) worker_cpu_list = "\"0-%d\"" % max_cpu.cpu platform_cpus_no_threads = self._get_platform_cpu_list(host) vswitch_cpus_no_threads = self._get_vswitch_cpu_list(host) platform_cpu_list_with_quotes = \ "\"%s\"" % ','.join([str(c.cpu) for c in platform_cpus_no_threads]) platform_numa_cpus = utils.get_numa_index_list(platform_cpus_no_threads) vswitch_numa_cpus = utils.get_numa_index_list(vswitch_cpus_no_threads) # build a list of platform reserved cpus per numa node platform_cores = [] for node, cpus in platform_numa_cpus.items(): cpu_list = ','.join([str(c.cpu) for c in cpus]) platform_node = "\"node%d:%s\"" % (node, cpu_list) platform_cores.append(platform_node) # build a list of vswitch reserved cpu counts per numa node vswitch_cores = [] for node, cpus in vswitch_numa_cpus.items(): cpu_count = len(cpus) vswitch_node = "\"node%d:%d\"" % (node, cpu_count) vswitch_cores.append(vswitch_node) reserved_platform_cores = "(%s)" % ' '.join(platform_cores) reserved_vswitch_cores = "(%s)" % ' '.join(vswitch_cores) host_cpus = sorted(host_cpus, key=lambda c: c.cpu) n_cpus = len(host_cpus) host_cpu_list = [c.cpu for c in host_cpus] platform_cpus = self._get_host_cpu_list( host, function=constants.PLATFORM_FUNCTION, threads=True) platform_cpus = sorted(platform_cpus, key=lambda c: c.cpu) platform_cpu_list = \ "%s" % ','.join([str(c.cpu) for c in platform_cpus]) vswitch_cpus = self._get_host_cpu_list( host, constants.VSWITCH_FUNCTION, threads=True) vswitch_cpus = sorted(vswitch_cpus, key=lambda c: c.cpu) vswitch_cpu_list = \ "%s" % ','.join([str(c.cpu) for c in vswitch_cpus]) # rcu_nocbs = all cores - platform cores rcu_nocbs = copy.deepcopy(host_cpu_list) for i in [int(s) for s in platform_cpu_list.split(',')]: rcu_nocbs.remove(i) # change the CPU list to ranges rcu_nocbs_ranges = "" for key, group in itertools.groupby(enumerate(rcu_nocbs), lambda (x, y): y - x): group = list(group) rcu_nocbs_ranges += "%s-%s," % (group[0][1], group[-1][1]) rcu_nocbs_ranges = rcu_nocbs_ranges.rstrip(',') # non-vswitch CPUs = all cores - vswitch cores non_vswitch_cpus = host_cpu_list for i in [c.cpu for c in vswitch_cpus]: non_vswitch_cpus.remove(i) # change the CPU list to ranges non_vswitch_cpus_ranges = "" for key, group in itertools.groupby(enumerate(non_vswitch_cpus), lambda (x, y): y - x): group = list(group) non_vswitch_cpus_ranges += "\"%s-%s\"," % (group[0][1], group[-1][1]) cpu_options = "" if constants.LOWLATENCY in host.subfunctions: vswitch_cpu_list_with_quotes = \ "\"%s\"" % ','.join([str(c.cpu) for c in vswitch_cpus]) config.update({ 'platform::compute::pmqos::low_wakeup_cpus': vswitch_cpu_list_with_quotes, 'platform::compute::pmqos::hight_wakeup_cpus': non_vswitch_cpus_ranges.rstrip(',')}) vswitch_cpu_list = rcu_nocbs_ranges cpu_options += "nohz_full=%s " % vswitch_cpu_list cpu_options += "isolcpus=%s rcu_nocbs=%s kthread_cpus=%s " \ "irqaffinity=%s" % (vswitch_cpu_list, rcu_nocbs_ranges, platform_cpu_list, platform_cpu_list) config.update({ 'platform::compute::params::worker_cpu_list': worker_cpu_list, 'platform::compute::params::platform_cpu_list': platform_cpu_list_with_quotes, 'platform::compute::params::reserved_vswitch_cores': reserved_vswitch_cores, 'platform::compute::params::reserved_platform_cores': reserved_platform_cores, 'platform::compute::grub::params::n_cpus': n_cpus, 'platform::compute::grub::params::cpu_options': cpu_options, }) return config def _get_host_memory_config(self, host): config = {} if constants.WORKER in utils.get_personalities(host): host_memory = self.dbapi.imemory_get_by_ihost(host.id) memory_numa_list = utils.get_numa_index_list(host_memory) platform_cpus = self._get_platform_cpu_list(host) platform_cpu_count = len(platform_cpus) platform_nodes = [] vswitch_nodes = [] hugepages_2Ms = [] hugepages_1Gs = [] vswitch_2M_pages = [] vswitch_1G_pages = [] vm_4K_pages = [] vm_2M_pages = [] vm_1G_pages = [] for node, memory_list in memory_numa_list.items(): memory = memory_list[0] vswitch_2M_page = 0 vswitch_1G_page = 0 platform_size = memory.platform_reserved_mib platform_node = "\"node%d:%dMB:%d\"" % ( node, platform_size, platform_cpu_count) platform_nodes.append(platform_node) vswitch_size = memory.vswitch_hugepages_size_mib vswitch_pages = memory.vswitch_hugepages_nr vswitch_node = "\"node%d:%dkB:%d\"" % ( node, vswitch_size * 1024, vswitch_pages) vswitch_nodes.append(vswitch_node) vm_hugepages_nr_2M = memory.vm_hugepages_nr_2M_pending \ if memory.vm_hugepages_nr_2M_pending is not None \ else memory.vm_hugepages_nr_2M vm_hugepages_nr_1G = memory.vm_hugepages_nr_1G_pending \ if memory.vm_hugepages_nr_1G_pending is not None \ else memory.vm_hugepages_nr_1G vm_hugepages_nr_4K = memory.vm_hugepages_nr_4K \ if memory.vm_hugepages_nr_4K is not None else 0 total_hugepages_2M = vm_hugepages_nr_2M total_hugepages_1G = vm_hugepages_nr_1G if memory.vswitch_hugepages_size_mib == constants.MIB_2M: total_hugepages_2M += memory.vswitch_hugepages_nr vswitch_2M_page += memory.vswitch_hugepages_nr elif memory.vswitch_hugepages_size_mib == constants.MIB_1G: total_hugepages_1G += memory.vswitch_hugepages_nr vswitch_1G_page += memory.vswitch_hugepages_nr vswitch_2M_pages.append(vswitch_2M_page) vswitch_1G_pages.append(vswitch_1G_page) hugepages_2M = "\"node%d:%dkB:%d\"" % ( node, constants.MIB_2M * 1024, total_hugepages_2M) hugepages_1G = "\"node%d:%dkB:%d\"" % ( node, constants.MIB_1G * 1024, total_hugepages_1G) hugepages_2Ms.append(hugepages_2M) hugepages_1Gs.append(hugepages_1G) vm_4K_pages.append(vm_hugepages_nr_4K) vm_2M_pages.append(vm_hugepages_nr_2M) vm_1G_pages.append(vm_hugepages_nr_1G) platform_reserved_memory = "(%s)" % ' '.join(platform_nodes) vswitch_reserved_memory = "(%s)" % ' '.join(vswitch_nodes) nr_hugepages_2Ms = "(%s)" % ' '.join(hugepages_2Ms) nr_hugepages_1Gs = "(%s)" % ' '.join(hugepages_1Gs) vswitch_2M = "\"%s\"" % ','.join([str(i) for i in vswitch_2M_pages]) vswitch_1G = "\"%s\"" % ','.join([str(i) for i in vswitch_1G_pages]) vm_4K = "\"%s\"" % ','.join([str(i) for i in vm_4K_pages]) vm_2M = "\"%s\"" % ','.join([str(i) for i in vm_2M_pages]) vm_1G = "\"%s\"" % ','.join([str(i) for i in vm_1G_pages]) config.update({ 'platform::compute::params::worker_base_reserved': platform_reserved_memory, 'platform::compute::params::compute_vswitch_reserved': vswitch_reserved_memory, 'platform::compute::hugepage::params::nr_hugepages_2M': nr_hugepages_2Ms, 'platform::compute::hugepage::params::nr_hugepages_1G': nr_hugepages_1Gs, 'platform::compute::hugepage::params::vswitch_2M_pages': vswitch_2M, 'platform::compute::hugepage::params::vswitch_1G_pages': vswitch_1G, 'platform::compute::hugepage::params::vm_4K_pages': vm_4K, 'platform::compute::hugepage::params::vm_2M_pages': vm_2M, 'platform::compute::hugepage::params::vm_1G_pages': vm_1G, }) return config def _get_nfs_config(self): # Calculate the optimal NFS r/w size based on the network mtu based # on the configured network(s) mtu = constants.DEFAULT_MTU try: interfaces = self.dbapi.iinterface_get_by_network( constants.NETWORK_TYPE_INFRA) for interface in interfaces: mtu = interface.imtu except exception.InvalidParameterValue: try: interfaces = self.dbapi.iinterface_get_by_network( constants.NETWORK_TYPE_MGMT) for interface in interfaces: mtu = interface.imtu except exception.InvalidParameterValue: pass if self._get_address_by_name( constants.CONTROLLER_PLATFORM_NFS, constants.NETWORK_TYPE_MGMT).family == constants.IPV6_FAMILY: nfs_proto = 'udp6' else: nfs_proto = 'udp' # round to the nearest 1k of the MTU nfs_rw_size = (mtu / 1024) * 1024 return { 'platform::params::nfs_rw_size': nfs_rw_size, 'platform::params::nfs_proto': nfs_proto, } def _get_remotelogging_config(self): remotelogging = self.dbapi.remotelogging_get_one() return { 'platform::remotelogging::params::enabled': remotelogging.enabled, 'platform::remotelogging::params::ip_address': remotelogging.ip_address, 'platform::remotelogging::params::port': remotelogging.port, 'platform::remotelogging::params::transport': remotelogging.transport, } def _get_snmp_config(self): system = self.dbapi.isystem_get_one() comm_strs = self.dbapi.icommunity_get_list() trapdests = self.dbapi.itrapdest_get_list() config = { 'platform::snmp::params::system_name': system.name, 'platform::snmp::params::system_location': system.location, 'platform::snmp::params::system_contact': system.contact, } if comm_strs is not None: comm_list = [] for i in comm_strs: comm_list.append(i.community) config.update({'platform::snmp::params::community_strings': comm_list}) if trapdests is not None: trap_list = [] for e in trapdests: trap_list.append(e.ip_address + ' ' + e.community) config.update({'platform::snmp::params::trap_destinations': trap_list}) return config def _get_platform_cpu_count(self, host): cpus = self._get_host_cpu_list(host, constants.PLATFORM_FUNCTION, True) return len(cpus) def _get_host_lldp_config(self, host): driver_list = [] # Default is lldpd driver_list.append('lldpd') self.context['_lldp_drivers'] = driver_list return { 'sysinv::agent::lldp_drivers': driver_list }