def _get_mem_bytes_hv(self):
if which('virsh'):
return self._get_mem_bytes_virsh()
if which('xm'):
return self._get_mem_bytes_xm()
else:
return '0'
def unprovisioner(self):
if self.vg is None:
self.log.debug("skip lv unprovision: no vg option")
return
if not which('lvdisplay'):
self.log.debug("skip lv unprovision: lvdisplay command not found")
return
dev = self.get_dev()
if dev is None:
return
cmd = ["lvdisplay", dev]
out, err, ret = justcall(cmd)
if ret != 0:
self.log.debug("skip lv unprovision: %s is not a lv" % dev)
return
if not which('lvremove'):
self.log.error("lvcreate command not found")
raise ex.Error
if which('wipefs') and os.path.exists(dev):
self.vcall(["wipefs", "-a", dev])
cmd = ["lvremove", "-f", dev]
ret, out, err = self.vcall(cmd)
self.clear_cache("lvs.attr")
if ret != 0:
raise ex.Error
self.svc.node.unset_lazy("devtree")
def listpkg_ips():
"""
Return a list of ips packages installed.
"""
#
# PKGINST: SUNWzoneu
# NAME: Solaris Zones (Usr)
# CATEGORY: system
# ARCH: i386
# VERSION: 11.11,REV=2009.04.08.17.26
# VENDOR: Sun Microsystems, Inc.
# DESC: Solaris Zones Configuration and Administration
# HOTLINE: Please contact your local service provider
# STATUS: completely installed
#
if which('uname') is None:
return []
cmd = ['uname', '-p']
out, _, _ = justcall(cmd)
arc = out.split('\n')[0]
if which('pkg') is None:
return []
cmd = ['pkg', 'list', '-H']
out, _, _ = justcall(cmd)
lines = []
for line in out.split('\n'):
elems = line.split()
if len(elems) != 3:
continue
data = [Env.nodename, elems[0], elems[1], arc, "ips", ""]
lines.append(data)
return lines
def test_which(non_existing_file):
"""
which()
"""
assert which("ls") in ("/bin/ls", "/usr/bin/ls", "/usr/xpg4/bin/ls", "/usr/gnu/bin/ls")
assert which("/bin/ls") in ("/bin/ls", "/usr/bin/ls")
assert which(non_existing_file) is None
assert which(None) is None
def driver_capabilities(node=None):
from utilities.proc import which
data = []
if which("docker") or which("docker.io"):
data += [
"task.docker",
"task.docker.registry_creds",
]
return data
def driver_capabilities(node=None):
data = []
from utilities.proc import which
if which("docker") or which("docker.io"):
data += [
"container.docker",
"container.docker.registry_creds",
"container.docker.signal",
]
return data
def driver_capabilities(node=None):
from utilities.proc import which
data = []
if which("sg_persist"):
data.append("disk.scsireserv")
data.append("disk.scsireserv.sg_persist")
if which("mpathpersist"):
out, err, ret = justcall(["multipath", "-h"])
for line in err.splitlines():
version = [int(v) for v in line.split()[1].strip("v").split(".")]
break
if version > [0, 7, 8]:
data.append("disk.scsireserv")
data.append("disk.scsireserv.mpathpersist")
return data
def zoneadm(self, action, option=None):
if action in VALID_ACTIONS:
cmd = [ZONEADM, "-z", self.name, action]
else:
self.log.error("unsupported zone action: %s", action)
return 1
if option is not None:
cmd += option
begin = datetime.now()
if os.environ.get("OSVC_ACTION_ORIGIN") == "daemon" and which("su"):
# the zoneadm command gives an error when executed from osvcd.
# su creates a clean execution context and makes zoneadm succeed.
cmd = ["su", "root", "-c", " ".join(cmd)]
self.log.info("%s", " ".join(cmd))
ret = self.lcall(cmd, env={})
duration = datetime.now() - begin
if ret != 0:
raise ex.Error("%s failed in %s - ret %i" %
(" ".join(cmd), duration, ret))
else:
self.log.info("%s done in %s - ret %i" %
(" ".join(cmd), duration, ret))
self.zone_refresh()
return ret
def startip_cmd(self):
if which("ifconfig") and self.alias:
if ':' in self.addr:
cmd = [
'ifconfig', self.ipdev, 'inet6', 'add',
'/'.join([self.addr, to_cidr(self.netmask)])
]
else:
cmd = [
'ifconfig', self.stacked_dev, self.addr, 'netmask',
to_dotted(self.netmask), 'up'
]
else:
cmd = [
Env.syspaths.ip, "addr", "add",
'/'.join([self.addr, to_cidr(self.netmask)]), "dev", self.ipdev
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# ip activation may still be incomplete
# wait for activation, to avoid startapp scripts to fail binding their listeners
for i in range(5, 0, -1):
if utilities.ping.check_ping(self.addr, timeout=1, count=1):
return ret, out, err
self.log.error("timed out waiting for ip activation")
raise ex.Error
def load_lv(self, lv):
if not which("lvdisplay"):
return
cmd = ["lvdisplay", "-v", lv]
p = Popen(cmd, stdout=PIPE, stderr=PIPE)
out, err = p.communicate()
if p.returncode:
return
vgname = lv.split('/')[2]
# parser
h = {}
for line in out.split('\n'):
line = line.strip()
if 'LV Size' in line:
size = int(line.split()[-1])
if not line.startswith('/dev'):
continue
pv, le, pe = line.split()
h[pv] = int(pe) * self.pe_size[vgname]
# use the linux lvm naming convention
devname = lv.replace('/dev/', '').replace('-', '--').replace('/', '-')
d = self.add_dev(devname, size, "linear")
for pv in h:
d.add_parent(pv.replace('/dev/disk/', ''), size=h[pv])
d.set_devpath(lv)
parent_dev = self.get_dev_by_devpath(pv)
if parent_dev is None:
continue
parent_dev.add_child(d.devname)
def fsck(self):
if self.fs_type in ("", "tmpfs", "shm", "shmfs", "none") or os.path.isdir(self.device):
# bind mounts are in this case
return
self.set_fsck_h()
if self.fs_type not in self.fsck_h:
self.log.debug("no fsck method for %s"%self.fs_type)
return
bin = self.fsck_h[self.fs_type]['bin']
if which(bin) is None:
self.log.warning("%s not found. bypass."%self.fs_type)
return
if 'reportcmd' in self.fsck_h[self.fs_type]:
cmd = self.fsck_h[self.fs_type]['reportcmd']
(ret, out, err) = self.vcall(cmd, err_to_info=True)
if ret not in self.fsck_h[self.fs_type]['reportclean']:
return
cmd = self.fsck_h[self.fs_type]['cmd']
(ret, out, err) = self.vcall(cmd)
if 'allowed_ret' in self.fsck_h[self.fs_type]:
allowed_ret = self.fsck_h[self.fs_type]['allowed_ret']
else:
allowed_ret = [0]
if ret not in allowed_ret:
raise ex.Error
def provisioner(self):
if not which('vxassist'):
raise ex.Error("vxassist command not found")
if self.has_it():
self.log.info("skip vxvol provision: %s already exists" %
self.fullname)
return
if not self.size:
raise ex.Error("a size is required")
size_parm = str(self.size).upper()
size_parm = [str(convert_size(size_parm, _to="m")) + 'M']
create_options = self.create_options or self.oget("create_options")
# strip dev dir in case the alloc vxassist parameter was formatted using sub_devs
# lazy references
for idx, option in enumerate(create_options):
create_options[idx] = option.replace("/dev/vx/dsk/", "")
# create the logical volume
cmd = ['vxassist', '-g', self.vg, "make", self.name
] + size_parm + create_options
ret, out, err = self.vcall(cmd)
if ret != 0:
raise ex.Error(err)
self.can_rollback = True
self.svc.node.unset_lazy("devtree")
def refresh_multipath(self, dev):
if which(Env.syspaths.multipath) is None:
return
cmd = [Env.syspaths.multipath, '-v0', '-r', dev]
(ret, out, err) = self.vcall(cmd)
if ret != 0:
raise ex.Error
def listpatch():
"""
Return a list of patches installed.
Patch: patchnum-rev Obsoletes: num-rev[,patch-rev]... Requires: .... Incompatibles: ... Packages: ...
"""
if which('showrev') is None:
return []
cmd = ['showrev', '-p']
out, _, _ = justcall(cmd)
lines = []
nodename = Env.nodename
for line in out.splitlines():
elems = line.split(' ')
if len(elems) > 3:
_elems = elems[1].split('-')
if len(_elems) != 2:
continue
else:
lines.append([nodename, _elems[0], _elems[1]])
for idx, line in enumerate(lines):
# pkg install date
try:
mtime = os.stat("/var/sadm/patch/" + line[1])[ST_MTIME]
mtime = datetime.datetime.fromtimestamp(mtime).strftime(
"%Y-%m-%d %H:%M:%S")
except Exception:
mtime = ""
lines[idx].append(mtime)
return lines
def listpkg_legacy():
"""
Return a list of legacy packages installed.
"""
if which('pkginfo') is None:
return []
cmd = ['pkginfo', '-l']
out, _, _ = justcall(cmd)
lines = []
for line in out.splitlines():
elems = line.split(':', 1)
if len(elems) != 2:
continue
key, val = [elem.strip() for elem in elems]
if key == "PKGINST":
data = [Env.nodename, val, "", "", "pkg", ""]
elif key == "VERSION":
data[2] = val
elif key == "ARCH":
data[3] = val
lines.append(data)
for idx, line in enumerate(lines):
# pkg install date
try:
mtime = os.stat("/var/sadm/pkg/" + line[1])[ST_MTIME]
mtime = datetime.datetime.fromtimestamp(mtime).strftime(
"%Y-%m-%d %H:%M:%S")
except Exception:
mtime = ""
lines[idx][5] = mtime
return lines
def listpkg_snap():
"""
Example:
Name Version Rev Tracking Publisher Notes
core 16-2.35.4 5662 stable canonical* core
inkscape 0.92.3 4274 stable inkscape* -
skype 8.32.0.44 60 stable skype* classic
"""
if not which("snap"):
return []
cmd = ["snap", "list", "--unicode=never", "--color=never"]
out, err, ret = justcall(cmd)
lines = []
for line in out.splitlines():
if line.startswith('Name'):
header = namedtuple("header", line)
continue
_data = header._make(line.split())
lines.append([
Env.nodename,
_data.Name,
"%s rev %s" % (_data.Version, _data.Rev),
"",
"snap",
"",
])
return lines
def fs_u_zfs():
if not which(Env.syspaths.zfs):
return []
cmd = [
Env.syspaths.zfs, 'list', '-o', 'name,used,avail,mountpoint', '-H'
]
(out, err, ret) = justcall(cmd)
if ret != 0:
return []
lines = out.split('\n')
if len(lines) == 0:
return []
vals = []
for line in lines:
l = line.split()
if len(l) != 4:
continue
if "@" in l[0]:
# do not report clone usage
continue
if "osvc_sync_" in l[0]:
# do not report osvc sync snapshots fs usage
continue
used = convert_size(l[1], _to="KB")
if l[2] == '0':
l[2] = '0K'
avail = convert_size(l[2], _to="KB")
total = used + avail
pct = used / total * 100
vals.append([now, node.nodename, l[0], str(total), str(pct)])
return vals
def load_mpath(self):
if hasattr(self, "mpath_h"):
return self.mpath_h
self.mpath_h = {}
if which(Env.syspaths.multipath):
self.load_mpath_native()
return self.mpath_h
def sssu(cmd, manager, username, password, array=None, sssubin=None):
if sssubin is None:
if which("sssu"):
sssubin = "sssu"
elif os.path.exists(os.path.join(Env.paths.pathbin, "sssu")):
sssubin = os.path.join(Env.paths.pathbin, "sssu")
else:
raise ex.Error(
"sssu command not found. set 'array#%s.bin' in the node or cluster configuration."
% array)
os.chdir(Env.paths.pathtmp)
_cmd = [
sssubin,
"select manager %s username=%s password=%s" %
(manager, username, password)
]
if array is not None:
_cmd += ["select system %s" % array]
_cmd += [cmd]
out, err, ret = justcall(_cmd)
print(" ".join(_cmd))
if "Error" in out:
print(_cmd)
print(out)
raise ex.Error("sssu command execution error")
return out, err
def do_check(self):
if not which('hpacucli'):
return self.undef
cmd = ['controller', 'all', 'show', 'status']
out, err, ret = self.hpacucli(cmd)
if ret != 0:
return self.undef
lines = out.split('\n')
if len(lines) == 0:
return self.undef
r = []
for line in lines:
if ' Slot ' in line:
l = line.split()
idx = l.index('Slot')
uslot = l[idx+1]
slot = 'slot ' + uslot
_r = []
_r += self.check_controller(uslot)
_r += self.check_array(uslot)
_r += self.check_logicaldrive(uslot)
_r += self.check_physicaldrive(uslot)
for inst, value in _r:
r.append({
"instance": ".".join((slot, inst)),
"value": str(value),
"path": '',
})
return r
def stopip_cmd(self):
if not which(Env.syspaths.ipadm):
raise ex.Error("crossbow ips are not supported on this system")
ret, out, err = (0, '', '')
if self.gateway is not None:
cmd = ['route', '-q', 'delete', 'default', self.gateway]
r, o, e = self.call(cmd, info=True, outlog=False, errlog=False)
ret += r
cmd = [
Env.syspaths.ipadm, 'delete-addr',
self.stacked_dev + '/' + self.ipdevext
]
r, o, e = self.vcall(cmd)
ret += r
out += o
err += e
cmd = [
Env.syspaths.ipadm, 'show-addr', '-p', '-o', 'state',
self.stacked_dev
]
_out, _, _ = justcall(cmd)
_out = _out.strip().split("\n")
if len(_out) > 0:
self.log.info("skip delete-ip because addrs still use the ip")
return ret, out, err
cmd = [Env.syspaths.ipadm, 'delete-ip', self.stacked_dev]
r, o, e = self.vcall(cmd)
ret += r
out += o
err += e
return ret, out, err
def file_to_loop(f):
"""Given a file path, returns the loop device associated. For example,
/path/to/file => /dev/loop0
"""
if which('mdconfig') is None:
return []
if not os.path.isfile(f):
return []
(ret, out, err) = call(['mdconfig', '-l', '-v'])
if ret != 0:
return []
""" It's possible multiple loopdev are associated with the same file
"""
devs = []
for line in out.split('\n'):
l = line.split()
if len(l) < 4:
continue
path = ' '.join(l[3:])
if path != f:
continue
if not os.path.exists('/dev/' + l[0]):
continue
devs.append(l[0])
return devs
def scan_mapping(self):
if len(self.fcluns) > 0:
return
if not which('fcinfo'):
return
for index, portwwn, host in self._get_fc_hbas():
cmd = ['fcinfo', '/mapping', '/ai:'+index]
out, err, ret = justcall(cmd)
if ret != 0:
continue
lines = out.split('\n')
for i, line in enumerate(lines):
if line.startswith('( '):
l = line.split()
if len(l) < 3:
continue
bus = int(l[-3].strip(','))
target = int(l[-2].strip(','))
lun = int(l[-1].strip(')'))
_index = (host, bus, target, lun)
elif line.startswith('(cs:'):
l = line.split()
if len(l) < 2:
continue
wwid = l[-1].strip(')')
self.fcluns[_index] = dict(wwid=wwid)
def listpkg():
if which('swlist') is None:
return []
lines = []
for t in ('product', 'bundle'):
lines += listpkg_t(t)
return lines
def listpkg_rpm():
if not which("rpm"):
return []
cmd = [
'rpm', '-qai',
'--queryformat=XX%{n} %{v}-%{r} %{arch} rpm %{installtime}\n'
]
out, err, ret = justcall(cmd)
lines = []
for line in out.split('\n'):
if line.startswith('Signature'):
sig = line.split()[-1].strip()
continue
elif not line.startswith('XX'):
continue
line = line[2:]
l = line.split()
if len(l) < 5:
continue
try:
l[4] = datetime.datetime.fromtimestamp(int(
l[4])).strftime("%Y-%m-%d %H:%M:%S")
except:
l[4] = ""
x = [Env.nodename] + l + [sig]
lines.append(x)
return lines
def find_fmadm(self):
if which(self.fmadm):
return self.fmadm
for prefix in self.prefixes:
fmadm = os.path.join(prefix, self.fmadm)
if os.path.exists(fmadm):
return fmadm
return
def start_link(self):
if which(Env.syspaths.ip):
cmd = [Env.syspaths.ip, 'link', 'set', 'dev', self.ipdev, 'up']
else:
cmd = ['ifconfig', self.ipdev, 'up']
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
def find_sas2ircu(self):
if which(self.sas2ircu):
return self.sas2ircu
for prefix in self.prefixes:
sas2ircu = os.path.join(prefix, self.sas2ircu)
if os.path.exists(sas2ircu):
return sas2ircu
return
def driver_capabilities(node=None):
from utilities.proc import which
from env import Env
if Env.sysname != "SunOS":
return []
if which("share"):
return ["share.nfs"]
return []
def unprovisioner(self):
if not which('vxassist'):
raise ex.Error("vxassist command not found")
if not self.has_it():
self.log.info("skip vxvol unprovision: %s already unprovisioned",
self.fullname)
return
if which('wipefs') and os.path.exists(self.devpath) and self.is_up():
self.vcall(["wipefs", "-a", self.devpath])
cmd = ["vxassist", "-g", self.vg, "remove", "volume", self.name]
ret, out, err = self.vcall(cmd)
if ret != 0:
raise ex.Error
self.svc.node.unset_lazy("devtree")
