mirror of
https://github.com/ansible-collections/community.general.git
synced 2025-04-25 20:01:25 -07:00
6e585bdf24
Add deps/requires for fact collectors
Fact collectors can now set a required_facts
class attribute that will be a set of the names
of fact collectors they require to be run first.
ie, if a collector needs to know the ansible_distribution,
it should set it's required_facts to include 'distribution'
required_facts = set(['distribution'])
If a collector requires another collector, it gets added
to the selected collector names.
We then topological sort the ordering of the collectors
so that deps work out (ie, 'distribution' will run before
'service_mgr')
required_facts were added to the collectors for:
- network (requires 'distribution', 'platform')
- hardware (requires 'platform')
- service_mgr (requires 'distribution', 'platform')
Fix name references for facts (need 'ansible_' prefix)
is service_mgr
Fixes #30753
165 lines
8.2 KiB
Python
165 lines
8.2 KiB
Python
# This file is part of Ansible
|
|
#
|
|
# Ansible is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# Ansible is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from __future__ import (absolute_import, division, print_function)
|
|
__metaclass__ = type
|
|
|
|
import os
|
|
import re
|
|
|
|
from ansible.module_utils.facts.hardware.base import Hardware, HardwareCollector
|
|
|
|
|
|
class HPUXHardware(Hardware):
|
|
"""
|
|
HP-UX-specific subclass of Hardware. Defines memory and CPU facts:
|
|
- memfree_mb
|
|
- memtotal_mb
|
|
- swapfree_mb
|
|
- swaptotal_mb
|
|
- processor
|
|
- processor_cores
|
|
- processor_count
|
|
- model
|
|
- firmware
|
|
"""
|
|
|
|
platform = 'HP-UX'
|
|
|
|
def populate(self, collected_facts=None):
|
|
hardware_facts = {}
|
|
|
|
cpu_facts = self.get_cpu_facts(collected_facts=collected_facts)
|
|
memory_facts = self.get_memory_facts()
|
|
hw_facts = self.get_hw_facts()
|
|
|
|
hardware_facts.update(cpu_facts)
|
|
hardware_facts.update(memory_facts)
|
|
hardware_facts.update(hw_facts)
|
|
|
|
return hardware_facts
|
|
|
|
def get_cpu_facts(self, collected_facts=None):
|
|
cpu_facts = {}
|
|
collected_facts = collected_facts or {}
|
|
|
|
if collected_facts.get('ansible_architecture') in ['9000/800', '9000/785']:
|
|
rc, out, err = self.module.run_command("ioscan -FkCprocessor | wc -l", use_unsafe_shell=True)
|
|
cpu_facts['processor_count'] = int(out.strip())
|
|
# Working with machinfo mess
|
|
elif collected_facts.get('ansible_architecture') == 'ia64':
|
|
if collected_facts.get('ansible_distribution_version') == "B.11.23":
|
|
rc, out, err = self.module.run_command("/usr/contrib/bin/machinfo | grep 'Number of CPUs'", use_unsafe_shell=True)
|
|
if out:
|
|
cpu_facts['processor_count'] = int(out.strip().split('=')[1])
|
|
rc, out, err = self.module.run_command("/usr/contrib/bin/machinfo | grep 'processor family'", use_unsafe_shell=True)
|
|
if out:
|
|
cpu_facts['processor'] = re.search('.*(Intel.*)', out).groups()[0].strip()
|
|
rc, out, err = self.module.run_command("ioscan -FkCprocessor | wc -l", use_unsafe_shell=True)
|
|
cpu_facts['processor_cores'] = int(out.strip())
|
|
if collected_facts.get('ansible_distribution_version') == "B.11.31":
|
|
# if machinfo return cores strings release B.11.31 > 1204
|
|
rc, out, err = self.module.run_command("/usr/contrib/bin/machinfo | grep core | wc -l", use_unsafe_shell=True)
|
|
if out.strip() == '0':
|
|
rc, out, err = self.module.run_command("/usr/contrib/bin/machinfo | grep Intel", use_unsafe_shell=True)
|
|
cpu_facts['processor_count'] = int(out.strip().split(" ")[0])
|
|
# If hyperthreading is active divide cores by 2
|
|
rc, out, err = self.module.run_command("/usr/sbin/psrset | grep LCPU", use_unsafe_shell=True)
|
|
data = re.sub(' +', ' ', out).strip().split(' ')
|
|
if len(data) == 1:
|
|
hyperthreading = 'OFF'
|
|
else:
|
|
hyperthreading = data[1]
|
|
rc, out, err = self.module.run_command("/usr/contrib/bin/machinfo | grep logical", use_unsafe_shell=True)
|
|
data = out.strip().split(" ")
|
|
if hyperthreading == 'ON':
|
|
cpu_facts['processor_cores'] = int(data[0]) / 2
|
|
else:
|
|
if len(data) == 1:
|
|
cpu_facts['processor_cores'] = cpu_facts['processor_count']
|
|
else:
|
|
cpu_facts['processor_cores'] = int(data[0])
|
|
rc, out, err = self.module.run_command("/usr/contrib/bin/machinfo | grep Intel |cut -d' ' -f4-", use_unsafe_shell=True)
|
|
cpu_facts['processor'] = out.strip()
|
|
else:
|
|
rc, out, err = self.module.run_command("/usr/contrib/bin/machinfo | egrep 'socket[s]?$' | tail -1", use_unsafe_shell=True)
|
|
cpu_facts['processor_count'] = int(out.strip().split(" ")[0])
|
|
rc, out, err = self.module.run_command("/usr/contrib/bin/machinfo | grep -e '[0-9] core' | tail -1", use_unsafe_shell=True)
|
|
cpu_facts['processor_cores'] = int(out.strip().split(" ")[0])
|
|
rc, out, err = self.module.run_command("/usr/contrib/bin/machinfo | grep Intel", use_unsafe_shell=True)
|
|
cpu_facts['processor'] = out.strip()
|
|
|
|
return cpu_facts
|
|
|
|
def get_memory_facts(self, collected_facts=None):
|
|
memory_facts = {}
|
|
collected_facts = collected_facts or {}
|
|
|
|
pagesize = 4096
|
|
rc, out, err = self.module.run_command("/usr/bin/vmstat | tail -1", use_unsafe_shell=True)
|
|
data = int(re.sub(' +', ' ', out).split(' ')[5].strip())
|
|
memory_facts['memfree_mb'] = pagesize * data // 1024 // 1024
|
|
if collected_facts.get('ansible_architecture') in ['9000/800', '9000/785']:
|
|
try:
|
|
rc, out, err = self.module.run_command("grep Physical /var/adm/syslog/syslog.log")
|
|
data = re.search('.*Physical: ([0-9]*) Kbytes.*', out).groups()[0].strip()
|
|
memory_facts['memtotal_mb'] = int(data) // 1024
|
|
except AttributeError:
|
|
# For systems where memory details aren't sent to syslog or the log has rotated, use parsed
|
|
# adb output. Unfortunately /dev/kmem doesn't have world-read, so this only works as root.
|
|
if os.access("/dev/kmem", os.R_OK):
|
|
rc, out, err = self.module.run_command("echo 'phys_mem_pages/D' | adb -k /stand/vmunix /dev/kmem | tail -1 | awk '{print $2}'",
|
|
use_unsafe_shell=True)
|
|
if not err:
|
|
data = out
|
|
memory_facts['memtotal_mb'] = int(data) / 256
|
|
else:
|
|
rc, out, err = self.module.run_command("/usr/contrib/bin/machinfo | grep Memory", use_unsafe_shell=True)
|
|
data = re.search(r'Memory[\ :=]*([0-9]*).*MB.*', out).groups()[0].strip()
|
|
memory_facts['memtotal_mb'] = int(data)
|
|
rc, out, err = self.module.run_command("/usr/sbin/swapinfo -m -d -f -q")
|
|
memory_facts['swaptotal_mb'] = int(out.strip())
|
|
rc, out, err = self.module.run_command("/usr/sbin/swapinfo -m -d -f | egrep '^dev|^fs'", use_unsafe_shell=True)
|
|
swap = 0
|
|
for line in out.strip().splitlines():
|
|
swap += int(re.sub(' +', ' ', line).split(' ')[3].strip())
|
|
memory_facts['swapfree_mb'] = swap
|
|
|
|
return memory_facts
|
|
|
|
def get_hw_facts(self, collected_facts=None):
|
|
hw_facts = {}
|
|
collected_facts = collected_facts or {}
|
|
|
|
rc, out, err = self.module.run_command("model")
|
|
hw_facts['model'] = out.strip()
|
|
if collected_facts.get('ansible_architecture') == 'ia64':
|
|
separator = ':'
|
|
if collected_facts.get('ansible_distribution_version') == "B.11.23":
|
|
separator = '='
|
|
rc, out, err = self.module.run_command("/usr/contrib/bin/machinfo |grep -i 'Firmware revision' | grep -v BMC", use_unsafe_shell=True)
|
|
hw_facts['firmware_version'] = out.split(separator)[1].strip()
|
|
rc, out, err = self.module.run_command("/usr/contrib/bin/machinfo |grep -i 'Machine serial number' ", use_unsafe_shell=True)
|
|
if rc == 0 and out:
|
|
hw_facts['product_serial'] = out.split(separator)[1].strip()
|
|
|
|
return hw_facts
|
|
|
|
|
|
class HPUXHardwareCollector(HardwareCollector):
|
|
_fact_class = HPUXHardware
|
|
_platform = 'HP-UX'
|
|
|
|
required_facts = set(['platform', 'distribution'])
|