| Dir : /proc/self/root/opt/saltstack/salt/lib/python3.10/site-packages/salt/grains/ |
| Server: Linux ngx353.inmotionhosting.com 4.18.0-553.22.1.lve.1.el8.x86_64 #1 SMP Tue Oct 8 15:52:54 UTC 2024 x86_64 IP: 209.182.202.254 |
| Dir : //proc/self/root/opt/saltstack/salt/lib/python3.10/site-packages/salt/grains/smartos.py |
"""
SmartOS grain provider
:maintainer: Jorge Schrauwen <sjorge@blackdot.be>
:maturity: new
:depends: salt.utils, salt.module.cmdmod
:platform: SmartOS
.. versionadded:: 2017.7.0
"""
import logging
import os
import re
import salt.modules.cmdmod
import salt.utils.dictupdate
import salt.utils.json
import salt.utils.path
import salt.utils.platform
import salt.utils.stringutils
__virtualname__ = "smartos"
__salt__ = {
"cmd.run": salt.modules.cmdmod.run,
}
log = logging.getLogger(__name__)
def __virtual__():
"""
Only load when we are on SmartOS
"""
if salt.utils.platform.is_smartos():
return __virtualname__
return False
def _smartos_computenode_data():
"""
Return useful information from a SmartOS compute node
"""
# Provides:
# vms_total
# vms_running
# vms_stopped
# vms_type
# sdc_version
# vm_capable
# vm_hw_virt
grains = {}
# collect vm data
vms = {}
for vm in __salt__["cmd.run"]("vmadm list -p -o uuid,alias,state,type").split("\n"):
vm = dict(list(zip(["uuid", "alias", "state", "type"], vm.split(":"))))
vms[vm["uuid"]] = vm
del vms[vm["uuid"]]["uuid"]
# set vm grains
grains["computenode_vms_total"] = len(vms)
grains["computenode_vms_running"] = 0
grains["computenode_vms_stopped"] = 0
grains["computenode_vms_type"] = {"KVM": 0, "LX": 0, "OS": 0}
for vm in vms:
if vms[vm]["state"].lower() == "running":
grains["computenode_vms_running"] += 1
elif vms[vm]["state"].lower() == "stopped":
grains["computenode_vms_stopped"] += 1
if vms[vm]["type"] not in grains["computenode_vms_type"]:
# NOTE: be prepared for when bhyve gets its own type
grains["computenode_vms_type"][vms[vm]["type"]] = 0
grains["computenode_vms_type"][vms[vm]["type"]] += 1
# sysinfo derived grains
sysinfo = salt.utils.json.loads(__salt__["cmd.run"]("sysinfo"))
grains["computenode_sdc_version"] = sysinfo["SDC Version"]
grains["computenode_vm_capable"] = sysinfo["VM Capable"]
if sysinfo["VM Capable"]:
grains["computenode_vm_hw_virt"] = sysinfo["CPU Virtualization"]
# sysinfo derived smbios grains
grains["manufacturer"] = sysinfo["Manufacturer"]
grains["productname"] = sysinfo["Product"]
grains["uuid"] = sysinfo["UUID"]
return grains
def _smartos_zone_data():
"""
Return useful information from a SmartOS zone
"""
# Provides:
# zoneid
# zonename
# imageversion
grains = {}
zoneinfo = __salt__["cmd.run"]("zoneadm list -p").strip().split(":")
grains["zoneid"] = zoneinfo[0]
grains["zonename"] = zoneinfo[1]
imageversion = re.compile("Image:\\s(.+)")
grains["imageversion"] = "Unknown"
if os.path.isfile("/etc/product"):
with salt.utils.files.fopen("/etc/product", "r") as fp_:
for line in fp_:
line = salt.utils.stringutils.to_unicode(line)
match = imageversion.match(line)
if match:
grains["imageversion"] = match.group(1)
return grains
def _smartos_zone_pkgsrc_data():
"""
SmartOS zone pkgsrc information
"""
# Provides:
# pkgsrcversion
# pkgsrcpath
grains = {
"pkgsrcversion": "Unknown",
"pkgsrcpath": "Unknown",
}
# NOTE: we are specifically interested in the SmartOS pkgsrc version and path
# - PKG_PATH MAY be different on non-SmartOS systems, but they will not
# use this grains module.
# - A sysadmin with advanced needs COULD create a 'spin' with a totally
# different URL. But at that point the value would be meaning less in
# the context of the pkgsrcversion grain as it will not followed the
# SmartOS pkgsrc versioning. So 'Unknown' would be appropriate.
pkgsrcpath = re.compile("PKG_PATH=(.+)")
pkgsrcversion = re.compile(
"^https?://pkgsrc.joyent.com/packages/SmartOS/(.+)/(.+)/All$"
)
pkg_install_paths = [
"/opt/local/etc/pkg_install.conf",
"/opt/tools/etc/pkg_install.conf",
]
for pkg_install in pkg_install_paths:
if os.path.isfile(pkg_install):
with salt.utils.files.fopen(pkg_install, "r") as fp_:
for line in fp_:
line = salt.utils.stringutils.to_unicode(line)
match_pkgsrcpath = pkgsrcpath.match(line)
if match_pkgsrcpath:
grains["pkgsrcpath"] = match_pkgsrcpath.group(1)
match_pkgsrcversion = pkgsrcversion.match(
match_pkgsrcpath.group(1)
)
if match_pkgsrcversion:
grains["pkgsrcversion"] = match_pkgsrcversion.group(1)
break
return grains
def _smartos_zone_pkgin_data():
"""
SmartOS zone pkgin information
"""
# Provides:
# pkgin_repositories
grains = {
"pkgin_repositories": [],
}
pkginrepo = re.compile("^(?:https|http|ftp|file)://.*$")
repositories_path = [
"/opt/local/etc/pkgin/repositories.conf",
"/opt/tools/etc/pkgin/repositories.conf",
]
for repositories in repositories_path:
if os.path.isfile(repositories):
with salt.utils.files.fopen(repositories, "r") as fp_:
for line in fp_:
line = salt.utils.stringutils.to_unicode(line).strip()
if pkginrepo.match(line):
grains["pkgin_repositories"].append(line)
return grains
def smartos():
"""
Provide grains for SmartOS
"""
grains = {}
if salt.utils.platform.is_smartos_zone():
grains = salt.utils.dictupdate.update(
grains, _smartos_zone_data(), merge_lists=True
)
elif salt.utils.platform.is_smartos_globalzone():
grains = salt.utils.dictupdate.update(
grains, _smartos_computenode_data(), merge_lists=True
)
grains = salt.utils.dictupdate.update(
grains, _smartos_zone_pkgin_data(), merge_lists=True
)
grains = salt.utils.dictupdate.update(
grains, _smartos_zone_pkgsrc_data(), merge_lists=True
)
return grains