ACIL FM

Pilih semua

Nama	Ukuran	Aksi
__pycache__	-	Open
aix.py	10.26 MB	View DL Edit
base.py	2.74 MB	View DL Edit
darwin.py	5.75 MB	View DL Edit
dragonfly.py	1.06 MB	View DL Edit
freebsd.py	8.65 MB	View DL Edit
hpux.py	8.16 MB	View DL Edit
hurd.py	1.71 MB	View DL Edit
linux.py	33.97 MB	View DL Edit
netbsd.py	6.09 MB	View DL Edit
openbsd.py	6.75 MB	View DL Edit
sunos.py	10.34 MB	View DL Edit
__init__.py	0 B	View DL Edit

Edit file: /usr/lib/python3.9/site-packages/ansible/module_utils/facts/hardware/hpux.py

# 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'])

Batal

Isi Zip:

Create