mirror of
https://github.com/thegeeklab/ansible-later.git
synced 2024-07-06 09:00:58 +02:00
166 lines
8.2 KiB
Python
166 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'])
|