def enable_snmpd(password):
_functions.system("service snmpd stop")
# get old password #
if os.path.exists("/tmp/snmpd.conf"):
conf = "/tmp/snmpd.conf"
else:
conf = snmp_conf
cmd = "cat %s|grep createUser|awk '{print $4}'" % conf
oldpwd = _functions.subprocess_closefds(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
oldpwd = oldpwd.stdout.read().strip()
_functions.system("sed -c -ie '/^createUser root/d' %s" % snmp_conf)
f = open(snmp_conf, "a")
# create user account
f.write("createUser root SHA %s AES\n" % password)
f.close()
_functions.system("service snmpd start")
# change existing password
if len(oldpwd) > 0:
pwd_change_cmd = ("snmpusm -v 3 -u root -n \"\" -l authNoPriv -a " +
"SHA -A %s localhost passwd %s %s -x AES") % (
oldpwd, oldpwd, password)
if _functions.system(pwd_change_cmd):
_functions.system("rm -rf /tmp/snmpd.conf")
_functions.ovirt_store_config(snmp_conf)
def enable_snmpd(password):
_functions.system("service snmpd stop")
# get old password #
if os.path.exists("/tmp/snmpd.conf"):
conf = "/tmp/snmpd.conf"
else:
conf = snmp_conf
cmd = "cat %s|grep createUser|awk '{print $4}'" % conf
oldpwd = _functions.subprocess_closefds(cmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
oldpwd = oldpwd.stdout.read().strip()
_functions.system("sed -c -ie '/^createUser root/d' %s" % snmp_conf)
f = open(snmp_conf, "a")
# create user account
f.write("createUser root SHA %s AES\n" % password)
f.close()
_functions.system("service snmpd start")
# change existing password
if len(oldpwd) > 0:
pwd_change_cmd = ("snmpusm -v 3 -u root -n \"\" -l authNoPriv -a " +
"SHA -A %s localhost passwd %s %s -x AES") % (oldpwd, oldpwd, password)
if _functions.system(pwd_change_cmd):
_functions.system("rm -rf /tmp/snmpd.conf")
_functions.ovirt_store_config(snmp_conf)
def iscsi_auto():
if "OVIRT_ISCSI_NAME" not in _functions.OVIRT_VARS:
_functions.logger.info("Generating iSCSI IQN")
iscsi_iqn_cmd = _functions.subprocess_closefds("/sbin/iscsi-iname", \
stdout=subprocess.PIPE)
iscsi_iqn, err = iscsi_iqn_cmd.communicate()
set_iscsi_initiator(iscsi_iqn.strip())
else:
set_iscsi_initiator(_functions.OVIRT_VARS["OVIRT_ISCSI_NAME"])
def get_sd_name(self, id):
device_sys_cmd = "grep -H \"^%s$\" /sys/block/*/dev | cut -d: -f1" % id
device_sys = _functions.subprocess_closefds(device_sys_cmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
device_sys_output = device_sys.stdout.read().strip()
if not device_sys_output is "":
device = os.path.basename(os.path.dirname(device_sys_output))
return device
def get_sd_name(self, id):
device_sys_cmd = "grep -H \"^%s$\" /sys/block/*/dev | cut -d: -f1" % id
device_sys = _functions.subprocess_closefds(device_sys_cmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
device_sys_output = device_sys.stdout.read().strip()
if not device_sys_output is "":
device = os.path.basename(os.path.dirname(device_sys_output))
return device
def get_drive_size(self, drive):
logger.debug("Getting Drive Size For: %s" % drive)
size_cmd = "sfdisk -s " + drive + " 2>/dev/null"
size = _functions.subprocess_closefds(size_cmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
size = size.stdout.read().strip()
size = int(int(size) / 1024)
logger.debug(size)
return size
def get_drive_size(self, drive):
logger.debug("Getting Drive Size For: %s" % drive)
size_cmd = "sfdisk -s " + drive + " 2>/dev/null"
size = _functions.subprocess_closefds(size_cmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
size = size.stdout.read().strip()
size = int(int(size) / 1024)
logger.debug(size)
return size
def wipe_fakeraid(device):
dmraid_cmd = "echo y | dmraid -rE $(readlink -f \"%s\")" % device
dmraid = _functions.subprocess_closefds(dmraid_cmd,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
shell=True)
dmraid.communicate()
dmraid.poll()
if dmraid.returncode == 0:
return True
else:
return False
def get_udev_devices(self):
self.disk_dict = {}
client = gudev.Client(['block'])
for device in client.query_by_subsystem("block"):
dev_name = device.get_property("DEVNAME")
dev_bus = device.get_property("ID_BUS")
dev_model = device.get_property("ID_MODEL")
dev_serial = device.get_property("ID_SERIAL")
dev_desc = device.get_property("ID_SCSI_COMPAT")
dev_size_cmd = "sfdisk -s %s 2>/dev/null" % dev_name
dev_size = _functions.subprocess_closefds(dev_size_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
dev_size = dev_size.stdout.read()
size_failed = 0
if not device.get_property("ID_CDROM"):
try:
dev_size = int(dev_size) / 1024 / 1024
except:
size_failed = 1
if not dev_desc:
if "/dev/vd" in dev_name:
dev_desc = "virtio disk"
elif dev_serial is not None:
dev_desc = dev_serial
else:
dev_desc = "unknown"
if (not device.get_property("ID_CDROM")
and not "/dev/dm-" in dev_name
and not "/dev/loop" in dev_name and size_failed == 0):
dev_name = _functions.translate_multipath_device(dev_name)
busmap = { \
"usb": "USB Device ", \
"ata": "Local / FibreChannel", \
"scsi": "Local / FibreChannel", \
"cciss": "CCISS " \
}
if dev_bus in busmap:
dev_bus = busmap[dev_bus]
elif "/dev/vd" in dev_name:
dev_bus = "Local (Virtio) "
else:
dev_bus = " "
self.disk_dict[dev_name] = "%s,%s,%s,%s,%s,%s" % (
dev_bus, dev_name, dev_size, dev_desc, dev_serial,
dev_model)
devs = self.get_dev_name()
return (sorted(devs), self.disk_dict)
def get_multipath_deps(self, mpath_device):
deplist = ""
#get dependencies for multipath device
deps_cmd = "dmsetup deps -u mpath-%s | sed 's/^.*: //' \
| sed 's/, /:/g' | sed 's/[\(\)]//g'" % mpath_device
deps = _functions.subprocess_closefds(deps_cmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
deps_output, deps_err = deps.communicate()
for dep in deps_output.split():
device = self.get_sd_name(dep)
if device is not None:
deplist = "%s %s" % (device, deplist)
return deplist
def get_udev_devices(self):
self.disk_dict = {}
client = gudev.Client(['block'])
for device in client.query_by_subsystem("block"):
dev_name = device.get_property("DEVNAME")
dev_bus = device.get_property("ID_BUS")
dev_model = device.get_property("ID_MODEL")
dev_serial = device.get_property("ID_SERIAL")
dev_desc = device.get_property("ID_SCSI_COMPAT")
dev_size_cmd = "sfdisk -s %s 2>/dev/null" % dev_name
dev_size_popen = _functions.subprocess_closefds(dev_size_cmd, shell=True,
stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
dev_size, dev_size_err = dev_size_popen.communicate()
size_failed = 0
if not device.get_property("ID_CDROM"):
try:
dev_size = int(dev_size) / 1024 / 1024
except:
size_failed = 1
if not dev_desc:
if "/dev/vd" in dev_name:
dev_desc = "virtio disk"
elif dev_serial is not None:
dev_desc = dev_serial
else:
dev_desc = "unknown"
if (not device.get_property("ID_CDROM") and
not "/dev/dm-" in dev_name and
not "/dev/loop" in dev_name and size_failed == 0):
dev_name = _functions.translate_multipath_device(dev_name)
busmap = { \
"usb": "USB Device ", \
"ata": "Local / FibreChannel", \
"scsi": "Local / FibreChannel", \
"cciss": "CCISS " \
}
if dev_bus in busmap:
dev_bus = busmap[dev_bus]
elif "/dev/vd" in dev_name:
dev_bus = "Local (Virtio) "
else:
dev_bus = " "
self.disk_dict[dev_name] = "%s,%s,%s,%s,%s,%s" % (dev_bus,
dev_name, dev_size, dev_desc,
dev_serial, dev_model)
devs = self.get_dev_name()
return (sorted(devs), self.disk_dict)
def get_drive_size(self, drive):
logger.debug("Getting Drive Size For: %s" % drive)
size_cmd = "lsblk -bn -o SIZE " + drive + " 2>/dev/null | head -n1"
size_popen = _functions.subprocess_closefds(size_cmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
size, size_err = size_popen.communicate()
size = size.strip()
try:
# Size is bytes, calculate MB
size = int(int(size) / 1024 / 1024)
except Exception as e:
logger.debug(str(e))
logger.debug(drive)
logger.debug(size)
raise RuntimeError("Failed to determin disk size: %s" % drive)
logger.debug(size)
return size
def get_all(self):
"""Get all available storage devices attached to this system
"""
if self._fake_devices:
return self._fake_devices
from ovirtnode.ovirtfunctions import translate_multipath_device
from ovirtnode.ovirtfunctions import subprocess_closefds
dev_names, disk_dict = self._storage.get_udev_devices()
devices = {}
for _dev in dev_names:
dev = translate_multipath_device(_dev)
self.logger.debug("Checking device %s (%s)" % (dev, _dev))
disk_type_cmd = ["lsblk", "-ino", "TYPE", dev, "--nodeps"]
disk_type_popen = subprocess_closefds(disk_type_cmd,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
dev_type, dev_type_err = disk_type_popen.communicate()
if not dev_type.strip() in ("disk", "mpath"):
self.logger.warning("Type is %s" % dev_type)
self.logger.warning("Device is not disk %s" % dev)
continue
if dev in devices:
self.logger.warning("Device is already in dict: %s" % dev)
continue
if dev not in disk_dict:
self.logger.warning("Device in names but not in dict: " +
"%s" % dev)
continue
if dev == self.live_disk_name():
self.logger.info("Ignoring device " +
"%s it's the live media" % dev)
continue
infos = disk_dict[dev].split(",", 5)
device = Device(dev, *infos)
device.name = os.path.basename(device.name).replace(" ", "")
device.name = translate_multipath_device(device.name)
if device.name in devices:
self.logger.debug("Device with same name already " +
"exists: %s" % device.name)
devices[device.path] = device
return devices
def get_all(self):
"""Get all available storage devices attached to this system
"""
if self._fake_devices:
return self._fake_devices
from ovirtnode.ovirtfunctions import translate_multipath_device
from ovirtnode.ovirtfunctions import subprocess_closefds
dev_names, disk_dict = self._storage.get_udev_devices()
devices = {}
for _dev in dev_names:
dev = translate_multipath_device(_dev)
self.logger.debug("Checking device %s (%s)" % (dev, _dev))
disk_type_cmd = ["lsblk", "-ino", "TYPE", dev, "--nodeps"]
disk_type_popen = subprocess_closefds(disk_type_cmd,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
dev_type, dev_type_err = disk_type_popen.communicate()
if not dev_type.strip() in ("disk", "mpath"):
self.logger.warning("Type is %s" % dev_type)
self.logger.warning("Device is not disk %s" % dev)
continue
if dev in devices:
self.logger.warning("Device is already in dict: %s" % dev)
continue
if dev not in disk_dict:
self.logger.warning("Device in names but not in dict: " +
"%s" % dev)
continue
if dev == self.live_disk_name():
self.logger.info("Ignoring device " +
"%s it's the live media" % dev)
continue
infos = disk_dict[dev].split(",", 5)
device = Device(dev, *infos)
device.name = os.path.basename(device.name).replace(" ", "")
device.name = translate_multipath_device(device.name)
if device.name in devices:
self.logger.debug("Device with same name already " +
"exists: %s" % device.name)
devices[device.path] = device
return devices
def get_system_nics():
# Re-trigger udev for rhbz#866584
for sysfspath in glob("/sys/class/net/*"):
_functions.system_closefds("udevadm test %s > /dev/null 2> /dev/null" % quote(sysfspath))
client = _functions.gudev.Client(['net'])
configured_nics = 0
ntp_dhcp = 0
nic_dict = {}
for device in client.query_by_subsystem("net"):
try:
dev_interface = device.get_property("INTERFACE")
dev_vendor = device.get_property("ID_VENDOR_FROM_DATABASE")
dev_type = device.get_property("DEVTYPE")
dev_path = device.get_property("DEVPATH")
if (dev_interface == "lo" or \
dev_interface.startswith("bond") or \
dev_interface.startswith("sit") or \
dev_interface.startswith("vnet") or \
"." in dev_interface or \
dev_type == "bridge"):
logger.info("Skipping interface '%s'" % dev_interface)
continue
else:
logger.info("Gathering informations for '%s'" % dev_interface)
try:
dev_vendor = dev_vendor.replace(",", "")
except AttributeError:
logger.debug("2. vendor approach: %s" % dev_vendor)
try:
# rhevh workaround since udev version
# doesn't have vendor info
dev_path = dev_path.split('/')
if "virtio" in dev_path[4]:
pci_dev = dev_path[3].replace("0000:", "")
else:
pci_dev = dev_path[4].replace("0000:", "")
pci_lookup_cmd = (("lspci|grep '%s'|awk -F \":\" " % pci_dev) +
"{'print $3'}")
pci_lookup = _functions.subprocess_closefds(pci_lookup_cmd,
shell=True, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
dev_vendor = pci_lookup.stdout.read().strip()
except:
dev_vendor = "unknown"
logger.debug("3. vendor approach: %s" % dev_vendor)
try:
dev_vendor = dev_vendor.replace(",", "")
except AttributeError:
dev_vendor = "unknown"
logger.debug("4. vendor approach: %s" % dev_vendor)
dev_vendor = _functions.pad_or_trim(25, dev_vendor)
dev_driver = ""
try:
dev_driver = os.readlink("/sys/class/net/" + dev_interface + \
"/device/driver")
dev_driver = os.path.basename(dev_driver)
except Exception as e:
logger.debug("Exception while determining NIC driver: %s" % (
repr(e)))
nic_addr_file = open("/sys/class/net/" + dev_interface + \
"/address")
dev_address = nic_addr_file.read().strip()
cmd = ("/files/etc/sysconfig/network-scripts/" + \
"ifcfg-%s/BOOTPROTO") % str(dev_interface)
dev_bootproto = _functions.augtool_get(cmd)
type_cmd = ("/files/etc/sysconfig/network-scripts/" + \
"ifcfg-%s/TYPE") % str(dev_interface)
bridge_cmd = ("/files/etc/sysconfig/network-scripts/" + \
"ifcfg-%s/BRIDGE") % str(dev_interface)
dev_bridge = _functions.augtool_get(bridge_cmd)
# check for vlans
logger.debug("checking for vlan")
vlans = glob("/etc/sysconfig/network-scripts/ifcfg-%s.*" %
dev_interface)
if (len(vlans) > 0):
dev_conf_status = "Configured "
vlanid = vlans[0].split(".")[-1]
logger.debug("found vlan %s" % vlanid)
# if no bridge in nic, check clan-nic for bridge
if not dev_bridge:
vlancfg = "ifcfg-%s.%s" % (str(dev_interface), vlanid)
cmd = ("/files/etc/sysconfig/network-scripts/%s/" +
"BRIDGE") % vlancfg
dev_bridge = augtool_get(cmd)
logger.debug("Getting bridge '%s' from vlan: %s" % (
dev_bridge, cmd))
if dev_bootproto is None:
logger.debug("Looking for bootproto in %s" % dev_bridge)
cmd = ("/files/etc/sysconfig/network-scripts/" + \
"ifcfg-%s/BOOTPROTO") % str(dev_bridge)
dev_bootproto = _functions.augtool_get(cmd)
if dev_bootproto is None:
dev_bootproto = "Disabled"
dev_conf_status = "Unconfigured"
else:
dev_conf_status = "Configured "
else:
dev_conf_status = "Configured "
if dev_conf_status == "Configured ":
configured_nics = configured_nics + 1
except Exception as e:
logger.warning("Error while determining NICs: %s" % repr(e))
nic_info = "%s,%s,%s,%s,%s,%s,%s" % ( \
dev_interface, dev_bootproto, \
dev_vendor, dev_address, \
dev_driver, dev_conf_status, \
dev_bridge)
logger.debug("NIC info: %s" % nic_info)
nic_dict[dev_interface] = nic_info
if dev_bootproto == "dhcp":
ntp_dhcp = 1
return nic_dict, configured_nics, ntp_dhcp
def ovirt_boot_setup(self, reboot="N"):
self.generate_paths()
logger.info("Installing the image.")
if "OVIRT_ROOT_INSTALL" in OVIRT_VARS:
if OVIRT_VARS["OVIRT_ROOT_INSTALL"] == "n":
logger.info("Root Installation Not Required, Finished.")
return True
self.oldtitle = None
if os.path.ismount("/liveos"):
if (os.path.exists("/liveos/vmlinuz0") and
os.path.exists("/liveos/initrd0.img")):
f = open(self.grub_config_file)
oldgrub = f.read()
f.close()
m = re.search("^title (.*)$", oldgrub, re.MULTILINE)
if m is not None:
self.oldtitle = m.group(1)
_functions.system("umount /liveos")
if _functions.findfs("BootBackup"):
self.boot_candidate = "BootBackup"
elif _functions.findfs("Boot"):
self.boot_candidate = "Boot"
if not os.path.ismount("/boot"):
logger.error("Boot partition not available, Install Failed")
return False
# Grab OVIRT_ISCSI VARIABLES from boot partition for upgrading
# file created only if OVIRT_ISCSI_ENABLED=y
if os.path.exists("/boot/ovirt"):
try:
f = open("/boot/ovirt", 'r')
for line in f:
try:
line = line.strip()
key, value = line.split("\"", 1)
key = key.strip("=")
key = key.strip()
value = value.strip("\"")
OVIRT_VARS[key] = value
except:
pass
f.close()
iscsiadm_cmd = (("iscsiadm -p %s:%s -m discovery -t " +
"sendtargets") % (
OVIRT_VARS["OVIRT_ISCSI_TARGET_IP"],
OVIRT_VARS["OVIRT_ISCSI_TARGET_PORT"]))
_functions.system(iscsiadm_cmd)
logger.info("Restarting iscsi service")
_functions.system("service iscsi restart")
except:
pass
if _functions.findfs("RootBackup"):
candidate = "RootBackup"
elif _functions.findfs("RootUpdate"):
candidate = "RootUpdate"
elif _functions.findfs("RootNew"):
candidate = "RootNew"
else:
logger.error("Unable to find %s partition" % candidate)
label_debug = ''
for label in os.listdir("/dev/disk/by-label"):
label_debug += "%s\n" % label
label_debug += _functions.subprocess_closefds("blkid", shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT).stdout.read()
logger.debug(label_debug)
return False
logger.debug("candidate: " + candidate)
if _functions.is_iscsi_install():
_functions.system("mount LABEL=%s /boot" % self.boot_candidate)
try:
candidate_dev = self.disk = _functions.findfs(candidate)
logger.info(candidate_dev)
logger.info(self.disk)
# grub2 starts at part 1
self.partN = int(self.disk[-1:])
if (not os.path.exists("/sbin/grub2-install") \
or _functions.is_efi_boot()):
self.partN = self.partN - 1
except:
logger.debug(traceback.format_exc())
return False
if self.disk is None or self.partN < 0:
logger.error("Failed to determine Root partition number")
return False
# prepare Root partition update
if candidate != "RootNew":
e2label_cmd = "e2label \"%s\" RootNew" % candidate_dev
logger.debug(e2label_cmd)
if not _functions.system(e2label_cmd):
logger.error("Failed to label new Root partition")
return False
mount_cmd = "mount \"%s\" /liveos" % candidate_dev
_functions.system(mount_cmd)
_functions.system("rm -rf /liveos/LiveOS")
_functions.system("mkdir -p /liveos/LiveOS")
_functions.mount_live()
if os.path.isdir(self.grub_dir):
shutil.rmtree(self.grub_dir)
if not os.path.exists(self.grub_dir):
os.makedirs(self.grub_dir)
if _functions.is_efi_boot():
logger.info("efi detected, installing efi configuration")
_functions.system("mkdir /liveos/efi")
_functions.mount_efi()
_functions.system("mkdir -p /liveos/efi/EFI/redhat")
_functions.system("cp /boot/efi/EFI/redhat/grub.efi " +
"/liveos/efi/EFI/redhat/grub.efi")
efi_disk = re.sub("p[1,2,3]$", "", self.disk)
# generate grub legacy config for efi partition
#remove existing efi entries
efi_mgr_cmd = "efibootmgr|grep '%s'" % _functions.PRODUCT_SHORT
efi_mgr = _functions.subprocess_closefds(efi_mgr_cmd, \
shell=True, \
stdout=subprocess.PIPE, \
stderr=subprocess.STDOUT)
efi_out = efi_mgr.stdout.read().strip()
logger.debug(efi_mgr_cmd)
logger.debug(efi_out)
for line in efi_out.splitlines():
if not "Warning" in line:
num = line[4:8] # grabs 4 digit hex id
cmd = "efibootmgr -B -b %s" % num
_functions.system(cmd)
efi_mgr_cmd = ("efibootmgr -c -l '\\EFI\\redhat\\grub.efi' " +
"-L '%s' -d %s -v") % (_functions.PRODUCT_SHORT,
efi_disk)
logger.info(efi_mgr_cmd)
_functions.system(efi_mgr_cmd)
self.kernel_image_copy()
# reorder tty0 to allow both serial and phys console after installation
if _functions.is_iscsi_install():
self.root_param = "root=LABEL=Root"
self.bootparams = "root=iscsi:%s::%s::%s ip=%s:dhcp" % (
OVIRT_VARS["OVIRT_ISCSI_TARGET_HOST"],
OVIRT_VARS["OVIRT_ISCSI_TARGET_PORT"],
OVIRT_VARS["OVIRT_ISCSI_TARGET_NAME"],
OVIRT_VARS["OVIRT_BOOTIF"])
else:
self.root_param = "root=live:LABEL=Root"
self.bootparams = "ro rootfstype=auto rootflags=ro "
self.bootparams += OVIRT_VARS["OVIRT_BOOTPARAMS"].replace(
"console=tty0", "")
if " " in self.disk or os.path.exists("/dev/cciss"):
# workaround for grub setup failing with spaces in dev.name:
# use first active sd* device
self.disk = re.sub("p[1,2,3]$", "", self.disk)
grub_disk_cmd = "multipath -l \"" + os.path.basename(self.disk) + \
"\" | awk '/ active / {print $3}' | head -n1"
logger.debug(grub_disk_cmd)
grub_disk = _functions.subprocess_closefds(grub_disk_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
self.disk = grub_disk.stdout.read().strip()
if "cciss" in self.disk:
self.disk = self.disk.replace("!", "/")
# flush to sync DM and blockdev, workaround from rhbz#623846#c14
sysfs = open("/proc/sys/vm/drop_caches", "w")
sysfs.write("3")
sysfs.close()
partprobe_cmd = "partprobe \"/dev/%s\"" % self.disk
logger.debug(partprobe_cmd)
_functions.system(partprobe_cmd)
if not self.disk.startswith("/dev/"):
self.disk = "/dev/" + self.disk
try:
if stat.S_ISBLK(os.stat(self.disk).st_mode):
try:
if stat.S_ISBLK(os.stat(self.disk[:-1]).st_mode):
# e.g. /dev/sda2
self.disk = self.disk[:-1]
except OSError:
pass
try:
if stat.S_ISBLK(os.stat(self.disk[:-2]).st_mode):
# e.g. /dev/mapper/WWIDp2
self.disk = self.disk[:-2]
except OSError:
pass
except OSError:
logger.error("Unable to determine disk for grub installation " +
traceback.format_exc())
return False
self.grub_dict = {
"product": _functions.PRODUCT_SHORT,
"version": _functions.PRODUCT_VERSION,
"release": _functions.PRODUCT_RELEASE,
"partN": self.partN,
"root_param": self.root_param,
"bootparams": self.bootparams,
"disk": self.disk,
"grub_dir": self.grub_dir,
"grub_prefix": self.grub_prefix,
"efi_hd": self.efi_hd
}
if os.path.exists("/sbin/grub2-install"):
if not _functions.is_efi_boot():
if not self.grub2_install():
logger.error("Grub2 Installation Failed ")
return False
else:
if not self.grub_install():
logger.error("Grub EFI Installation Failed ")
return False
else:
logger.info("Grub EFI Installation Completed ")
else:
if not self.grub_install():
logger.error("Grub Installation Failed ")
return False
else:
logger.info("Grub Installation Completed")
if _functions.is_iscsi_install():
# copy default for when Root/HostVG is inaccessible(iscsi upgrade)
shutil.copy(_functions.OVIRT_DEFAULTS, "/boot")
_functions.system("umount /boot")
else:
_functions.system("umount /liveos/efi")
_functions.system("umount /liveos")
# mark new Root ready to go, reboot() in ovirt-function switches it
# to active
e2label_cmd = "e2label \"%s\" RootUpdate" % candidate_dev
if not _functions.system(e2label_cmd):
logger.error("Unable to relabel " + candidate_dev +
" to RootUpdate ")
return False
_functions.disable_firstboot()
if _functions.finish_install():
_iscsi.iscsi_auto()
logger.info("Installation of %s Completed" % \
_functions.PRODUCT_SHORT)
if reboot is not None and reboot == "Y":
f = open('/var/spool/cron/root', 'w')
f.write('* * * * * sleep 10 && /sbin/reboot')
f.close()
#ensure crond is started
subprocess_closefds("crond", shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
return True
else:
return False
def get_dev_name(self):
devices = []
# list separator
for d in os.listdir("/sys/block/"):
if re.match("^[hsv]+d", d):
devices.append("/dev/%s" % d)
byid_list_cmd = ("find /dev/disk/by-id -mindepth 1 -not -name " +
"'*-part*' 2>/dev/null")
byid_list = _functions.subprocess_closefds(byid_list_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
byid_list_output, byid_list_err = byid_list.communicate()
for d in byid_list_output.split():
d = os.readlink(d)
d_basename = os.path.basename(d)
udev_cmd = ("udevadm info --name=/dev/" + d_basename +
" --query=property | grep -q ^ID_BUS: &>>/dev/null")
if _functions.system_closefds(udev_cmd):
devices.append("/dev/%s" % d_basename)
# FIXME: workaround for detecting cciss devices
if os.path.exists("/dev/cciss"):
for d in os.listdir("/dev/cciss"):
if not re.match("p[0-9]+\$", d):
devices.append("/dev/cciss/%s" % d)
# include multipath devices
devs_to_remove = ""
multipath_list_cmd = "dmsetup ls --target=multipath | cut -f1"
multipath_list = _functions.subprocess_closefds(multipath_list_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
multipath_list_output, multipath_list_err = multipath_list.communicate()
for d in multipath_list_output.split():
devices.append("/dev/mapper/%s" % d)
sd_devs = ""
sd_devs = self.get_multipath_deps(d)
dm_dev_cmd = ("multipath -ll \"%s\" | grep \"%s\" | " +
"sed -r 's/^.*(dm-[0-9]+ ).*$/\\1/'") % (d, d)
dm_dev = _functions.subprocess_closefds(dm_dev_cmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
dm_dev_output, dm_dev_err = dm_dev.communicate()
devs_to_remove = ("%s %s %s" % (devs_to_remove, sd_devs,
dm_dev_output))
# Remove /dev/sd* devices that are part of a multipath device
dev_list = []
for d in devices:
if (os.path.basename(d) not in devs_to_remove and
not "/dev/dm-" in d):
dev_list.append(d)
for dev in dev_list:
if dev_list.count(dev) > 1:
count = dev_list.count(dev)
while (count > 1):
dev_list.remove(dev)
count = count - 1
return dev_list
def ovirt_boot_setup(self, reboot="N"):
self.generate_paths()
logger.info("Installing the image.")
# copy grub.efi to safe location
if _functions.is_efi_boot():
shutil.copy("/boot/efi/EFI/%s/grub.efi" % self.efi_dir_name,
"/tmp")
if "OVIRT_ROOT_INSTALL" in OVIRT_VARS:
if OVIRT_VARS["OVIRT_ROOT_INSTALL"] == "n":
logger.info("Root Installation Not Required, Finished.")
return True
self.oldtitle = None
grub_config_file = None
if _functions.findfs("Boot") and _functions.is_upgrade():
grub_config_file = "/boot/grub/grub.conf"
if not _functions.connect_iscsi_root():
return False
_functions.mount_liveos()
if os.path.ismount("/liveos"):
if os.path.exists("/liveos/vmlinuz0") \
and os.path.exists("/liveos/initrd0.img"):
grub_config_file = self.grub_config_file
elif not _functions.is_firstboot():
# find existing iscsi install
if _functions.findfs("Boot"):
grub_config_file = "/boot/grub/grub.conf"
elif os.path.ismount("/dev/.initramfs/live"):
if not _functions.grub2_available():
grub_config_file = "/dev/.initramfs/live/grub/grub.conf"
else:
grub_config_file = "/dev/.initramfs/live/grub2/grub.cfg"
elif os.path.ismount("/run/initramfs/live"):
grub_config_file = "/run/initramfs/live/grub/grub.conf"
if _functions.is_upgrade() and not _functions.is_iscsi_install():
_functions.mount_liveos()
grub_config_file = "/liveos/grub/grub.conf"
if _functions.is_efi_boot():
logger.debug(str(os.listdir("/liveos")))
_functions.system("umount /liveos")
_functions.mount_efi(target="/liveos")
if self.efi_dir_name == "fedora":
grub_config_file = "/liveos/EFI/fedora/grub.cfg"
else:
grub_config_file = "/liveos/EFI/redhat/grub.conf"
if _functions.is_iscsi_install() or _functions.findfs("Boot"):
grub_config_file = "/boot/grub/grub.conf"
grub_config_file_exists = grub_config_file is not None \
and os.path.exists(grub_config_file)
logger.debug("Grub config file is: %s" % grub_config_file)
logger.debug("Grub config file exists: %s" % grub_config_file_exists)
if not grub_config_file is None and os.path.exists(grub_config_file):
f = open(grub_config_file)
oldgrub = f.read()
f.close()
if _functions.grub2_available():
m = re.search("^menuentry (.*)$", oldgrub, re.MULTILINE)
else:
m = re.search("^title (.*)$", oldgrub, re.MULTILINE)
if m is not None:
self.oldtitle = m.group(1)
# strip off extra title characters
if _functions.grub2_available():
self.oldtitle = self.oldtitle.replace('"', '').strip(" {")
_functions.system("umount /liveos/efi")
_functions.system("umount /liveos")
if _functions.is_iscsi_install() or _functions.findfs("Boot"):
self.boot_candidate = None
boot_candidate_names = ["BootBackup", "BootUpdate", "BootNew"]
for trial in range(1, 3):
time.sleep(1)
_functions.system("partprobe")
for candidate_name in boot_candidate_names:
logger.debug(os.listdir("/dev/disk/by-label"))
if _functions.findfs(candidate_name):
self.boot_candidate = candidate_name
break
logger.debug("Trial %s to find candidate (%s)" % \
(trial, candidate_name))
if self.boot_candidate:
logger.debug("Found candidate: %s" % self.boot_candidate)
break
if not self.boot_candidate:
logger.error("Unable to find boot partition")
label_debug = ''
for label in os.listdir("/dev/disk/by-label"):
label_debug += "%s\n" % label
label_debug += _functions.subprocess_closefds("blkid", \
shell=True, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT).stdout.read()
logger.debug(label_debug)
return False
else:
boot_candidate_dev = _functions.findfs(self.boot_candidate)
# prepare Root partition update
if self.boot_candidate != "BootNew":
e2label_cmd = "e2label \"%s\" BootNew" % boot_candidate_dev
logger.debug(e2label_cmd)
if not _functions.system(e2label_cmd):
logger.error("Failed to label new Boot partition")
return False
_functions.system("umount /boot")
_functions.system("mount %s /boot &>/dev/null" \
% boot_candidate_dev)
candidate = None
candidate_names = ["RootBackup", "RootUpdate", "RootNew"]
for trial in range(1, 3):
time.sleep(1)
_functions.system("partprobe")
for candidate_name in candidate_names:
if _functions.findfs(candidate_name):
candidate = candidate_name
break
logger.debug("Trial %s to find candidate (%s)" %
(trial, candidate_name))
if candidate:
logger.debug("Found candidate: %s" % candidate)
break
if not candidate:
logger.error("Unable to find root partition")
label_debug = ''
for label in os.listdir("/dev/disk/by-label"):
label_debug += "%s\n" % label
label_debug += _functions.subprocess_closefds(
"blkid",
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT).stdout.read()
logger.debug(label_debug)
return False
try:
candidate_dev = self.disk = _functions.findfs(candidate)
logger.info(candidate_dev)
logger.info(self.disk)
# grub2 starts at part 1
self.partN = int(self.disk[-1:])
if not _functions.grub2_available():
self.partN = self.partN - 1
except:
logger.debug(traceback.format_exc())
return False
if self.disk is None or self.partN < 0:
logger.error("Failed to determine Root partition number")
return False
# prepare Root partition update
if candidate != "RootNew":
e2label_cmd = "e2label \"%s\" RootNew" % candidate_dev
logger.debug(e2label_cmd)
if not _functions.system(e2label_cmd):
logger.error("Failed to label new Root partition")
return False
mount_cmd = "mount \"%s\" /liveos" % candidate_dev
_functions.system(mount_cmd)
_functions.system("rm -rf /liveos/LiveOS")
_functions.system("mkdir -p /liveos/LiveOS")
_functions.mount_live()
if os.path.isdir(self.grub_dir):
shutil.rmtree(self.grub_dir)
if not os.path.exists(self.grub_dir):
os.makedirs(self.grub_dir)
if _functions.is_efi_boot():
logger.info("efi detected, installing efi configuration")
_functions.system("mkdir /liveos/efi")
_functions.mount_efi()
_functions.system("mkdir -p /liveos/efi/EFI/redhat")
if _functions.is_iscsi_install() or _functions.is_efi_boot():
shutil.copy("/tmp/grub.efi",
"/liveos/efi/EFI/redhat/grub.efi")
else:
shutil.copy("/boot/efi/EFI/redhat/grub.efi",
"/liveos/efi/EFI/redhat/grub.efi")
if _functions.is_iscsi_install() or _functions.findfs(
"BootNew"):
self.disk = _functions.findfs("BootNew")
if not "/dev/mapper/" in self.disk:
efi_disk = self.disk[:-1]
else:
efi_disk = re.sub("p[1,2,3]$", "", self.disk)
# generate grub legacy config for efi partition
#remove existing efi entries
_functions.remove_efi_entry(_functions.PRODUCT_SHORT)
if self.efi_dir_name == "fedora":
_functions.add_efi_entry(
_functions.PRODUCT_SHORT,
("\\EFI\\%s\\grubx64.efi" % self.efi_dir_name),
efi_disk)
else:
_functions.add_efi_entry(
_functions.PRODUCT_SHORT,
("\\EFI\\%s\\grub.efi" % self.efi_dir_name), efi_disk)
self.kernel_image_copy()
# reorder tty0 to allow both serial and phys console after installation
if _functions.is_iscsi_install() or _functions.findfs("BootNew"):
self.root_param = "root=live:LABEL=Root"
if "OVIRT_NETWORK_LAYOUT" in OVIRT_VARS and \
OVIRT_VARS["OVIRT_NETWORK_LAYOUT"] == "bridged":
network_conf = "ip=br%s:dhcp bridge=br%s:%s" % \
(OVIRT_VARS["OVIRT_BOOTIF"],
OVIRT_VARS["OVIRT_BOOTIF"],
OVIRT_VARS["OVIRT_BOOTIF"])
else:
network_conf = "ip=%s:dhcp" % OVIRT_VARS["OVIRT_BOOTIF"]
self.bootparams = "netroot=iscsi:%s::%s::%s %s " % (
OVIRT_VARS["OVIRT_ISCSI_TARGET_HOST"],
OVIRT_VARS["OVIRT_ISCSI_TARGET_PORT"],
OVIRT_VARS["OVIRT_ISCSI_TARGET_NAME"], network_conf)
if "OVIRT_ISCSI_NAME" in OVIRT_VARS:
self.bootparams+= "iscsi_initiator=%s " % \
OVIRT_VARS["OVIRT_ISCSI_NAME"]
else:
self.root_param = "root=live:LABEL=Root"
self.bootparams = "ro rootfstype=auto rootflags=ro "
self.bootparams += OVIRT_VARS["OVIRT_BOOTPARAMS"].replace(
"console=tty0", "").replace("rd_NO_MULTIPATH", "")
if " " in self.disk or os.path.exists("/dev/cciss"):
# workaround for grub setup failing with spaces in dev.name:
# use first active sd* device
self.disk = re.sub("p[1,2,3]$", "", self.disk)
grub_disk_cmd = ("multipath -l " + "\"" + self.disk + "\" " +
"| egrep -o '[0-9]+:.*' " +
"| awk '/ active / {print $2}' " + "| head -n1")
logger.debug(grub_disk_cmd)
grub_disk = _functions.subprocess_closefds(
grub_disk_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
grub_disk_output, grub_disk_err = grub_disk.communicate()
self.disk = grub_disk_output.strip()
if "cciss" in self.disk:
self.disk = self.disk.replace("!", "/")
# flush to sync DM and blockdev, workaround from rhbz#623846#c14
sysfs = open("/proc/sys/vm/drop_caches", "w")
sysfs.write("3")
sysfs.close()
partprobe_cmd = "partprobe \"/dev/%s\"" % self.disk
logger.debug(partprobe_cmd)
_functions.system(partprobe_cmd)
if not self.disk.startswith("/dev/"):
self.disk = "/dev/" + self.disk
try:
if stat.S_ISBLK(os.stat(self.disk).st_mode):
try:
if stat.S_ISBLK(os.stat(self.disk[:-1]).st_mode):
# e.g. /dev/sda2
self.disk = self.disk[:-1]
except OSError:
pass
try:
if stat.S_ISBLK(os.stat(self.disk[:-2]).st_mode):
# e.g. /dev/mapper/WWIDp2
self.disk = self.disk[:-2]
except OSError:
pass
except OSError:
logger.error("Unable to determine disk for grub installation " +
traceback.format_exc())
return False
self.grub_dict = {
"product": _functions.PRODUCT_SHORT,
"version": _functions.PRODUCT_VERSION,
"release": _functions.PRODUCT_RELEASE,
"partN": self.partN,
"root_param": self.root_param,
"bootparams": self.bootparams,
"disk": self.disk,
"grub_dir": self.grub_dir,
"grub_prefix": self.grub_prefix,
"efi_hd": self.efi_hd
}
if not _functions.is_firstboot():
if os.path.ismount("/live"):
with open("%s/version" % self.live_path) as version:
for line in version.readlines():
if "VERSION" in line:
key, value = line.split("=")
self.grub_dict["version"] = value.strip()
if "RELEASE" in line:
key, value = line.split("=")
self.grub_dict["release"] = value.strip()
if _functions.grub2_available():
if not self.grub2_install():
logger.error("Grub2 Installation Failed ")
return False
else:
logger.info("Grub2 EFI Installation Completed ")
else:
if not self.grub_install():
logger.error("Grub Installation Failed ")
return False
else:
logger.info("Grub Installation Completed")
if _functions.is_iscsi_install() or _functions.findfs("BootNew"):
# copy default for when Root/HostVG is inaccessible(iscsi upgrade)
shutil.copy(_functions.OVIRT_DEFAULTS, "/boot")
# mark new Boot ready to go, reboot() in ovirt-function switches it
# to active
e2label_cmd = "e2label \"%s\" BootUpdate" % boot_candidate_dev
if not _functions.system(e2label_cmd):
logger.error("Unable to relabel " + boot_candidate_dev +
" to RootUpdate ")
return False
else:
_functions.system("umount /liveos/efi")
_functions.system("umount /liveos")
# mark new Root ready to go, reboot() in ovirt-function switches it
# to active
e2label_cmd = "e2label \"%s\" RootUpdate" % candidate_dev
if not _functions.system(e2label_cmd):
logger.error("Unable to relabel " + candidate_dev +
" to RootUpdate ")
return False
_functions.disable_firstboot()
if _functions.finish_install():
if _functions.is_firstboot():
_iscsi.iscsi_auto()
logger.info("Installation of %s Completed" % \
_functions.PRODUCT_SHORT)
if reboot is not None and reboot == "Y":
_system.async_reboot()
return True
else:
return False
def ovirt_boot_setup(self, reboot="N"):
self.generate_paths()
logger.info("Installing the image.")
# copy grub.efi to safe location
if _functions.is_efi_boot():
if "OVIRT_ISCSI_INSTALL" in OVIRT_VARS:
_functions.system("umount /boot")
if os.path.isfile("/boot/efi/%s/grubx64.efi" % self.efi_path):
shutil.copy("/boot/efi/%s/grubx64.efi" % self.efi_path, "/tmp")
else:
shutil.copy("/boot/efi/%s/grub.efi" % self.efi_path, "/tmp")
_functions.mount_boot()
if "OVIRT_ROOT_INSTALL" in OVIRT_VARS:
if OVIRT_VARS["OVIRT_ROOT_INSTALL"] == "n":
logger.info("Root Installation Not Required, Finished.")
return True
self.oldtitle = None
grub_config_file = None
if _functions.findfs("Boot") and _functions.is_upgrade():
grub_config_file = "/boot/grub/grub.conf"
if not _functions.connect_iscsi_root():
return False
_functions.mount_liveos()
if os.path.ismount("/liveos"):
if os.path.exists("/liveos/vmlinuz0") \
and os.path.exists("/liveos/initrd0.img"):
grub_config_file = self.grub_config_file
elif not _functions.is_firstboot():
# find existing iscsi install
if _functions.findfs("Boot"):
grub_config_file = "/boot/grub/grub.conf"
elif os.path.ismount("/dev/.initramfs/live"):
if not _functions.grub2_available():
grub_config_file = "/dev/.initramfs/live/grub/grub.conf"
else:
grub_config_file = "/dev/.initramfs/live/grub2/grub.cfg"
elif os.path.ismount("/run/initramfs/live"):
grub_config_file = "/run/initramfs/live/grub/grub.conf"
if _functions.is_upgrade() and not _functions.is_iscsi_install():
_functions.mount_liveos()
grub_config_file = "/liveos/grub/grub.conf"
if _functions.is_iscsi_install() or _functions.findfs("Boot") \
and not _functions.is_efi_boot():
grub_config_file = "/boot/grub/grub.conf"
if _functions.is_efi_boot():
logger.debug(str(os.listdir("/liveos")))
_functions.system("umount /liveos")
_functions.mount_efi(target="/liveos")
if self.efi_name == "fedora":
grub_config_file = "/liveos/EFI/fedora/grub.cfg"
else:
grub_config_file = "/liveos/%s/grub.conf" % self.efi_path
grub_config_file_exists = grub_config_file is not None \
and os.path.exists(grub_config_file)
logger.debug("Grub config file is: %s" % grub_config_file)
logger.debug("Grub config file exists: %s" % grub_config_file_exists)
if not grub_config_file is None and os.path.exists(grub_config_file):
f = open(grub_config_file)
oldgrub = f.read()
f.close()
if _functions.grub2_available():
m = re.search("^menuentry (.*)$", oldgrub, re.MULTILINE)
else:
m = re.search("^title (.*)$", oldgrub, re.MULTILINE)
if m is not None:
self.oldtitle = m.group(1)
# strip off extra title characters
if _functions.grub2_available():
self.oldtitle = self.oldtitle.replace('"', '').strip(" {")
_functions.system("umount /liveos/efi")
_functions.system("umount /liveos")
if _functions.is_iscsi_install() or _functions.findfs("Boot"):
self.boot_candidate = None
boot_candidate_names = ["BootBackup", "BootUpdate", "BootNew"]
for trial in range(1, 3):
time.sleep(1)
for candidate_name in boot_candidate_names:
logger.debug(os.listdir("/dev/disk/by-label"))
if _functions.findfs(candidate_name):
self.boot_candidate = candidate_name
break
logger.debug("Trial %s to find candidate (%s)" % \
(trial, candidate_name))
if self.boot_candidate:
logger.debug("Found candidate: %s" % self.boot_candidate)
break
if not self.boot_candidate:
logger.error("Unable to find boot partition")
label_debug = ''
for label in os.listdir("/dev/disk/by-label"):
label_debug += "%s\n" % label
label_debug += _functions.subprocess_closefds("blkid", \
shell=True, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT).stdout.read()
logger.debug(label_debug)
return False
else:
boot_candidate_dev = _functions.findfs(self.boot_candidate)
# prepare Root partition update
if self.boot_candidate != "BootNew":
e2label_cmd = "e2label \"%s\" BootNew" % boot_candidate_dev
logger.debug(e2label_cmd)
if not _functions.system(e2label_cmd):
logger.error("Failed to label new Boot partition")
return False
_functions.system("umount /boot")
_functions.system("mount %s /boot &>/dev/null" \
% boot_candidate_dev)
candidate = None
candidate_dev = None
candidate_names = ["RootBackup", "RootUpdate", "RootNew"]
for trial in range(1, 3):
time.sleep(1)
for candidate_name in candidate_names:
candidate_dev = _functions.findfs(candidate_name)
logger.debug("Finding %s: '%s'" %
(candidate_name, candidate_dev))
if candidate_dev:
candidate = candidate_name
logger.debug("Found: %s" % candidate)
break
logger.debug("Trial %s to find candidate (%s)" %
(trial, candidate_name))
if candidate:
logger.debug("Found candidate: '%s'" % candidate)
break
if not candidate:
logger.error("Unable to find root partition")
label_debug = ''
for label in os.listdir("/dev/disk/by-label"):
label_debug += "%s\n" % label
label_debug += _functions.subprocess_closefds(
"blkid",
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT).stdout.read()
logger.debug(label_debug)
return False
try:
self.disk = candidate_dev
logger.info("Candidate device: %s" % candidate_dev)
logger.info("Candidate disk: %s" % self.disk)
# grub2 starts at part 1
self.partN = int(self.disk[-1:])
if not _functions.grub2_available():
self.partN = self.partN - 1
except:
logger.debug("Failed to get partition", exc_info=True)
return False
if self.disk is None or self.partN < 0:
logger.error("Failed to determine Root partition number")
return False
# prepare Root partition update
if candidate != "RootNew":
e2label_cmd = "e2label \"%s\" RootNew" % candidate_dev
logger.debug(e2label_cmd)
if not _functions.system(e2label_cmd):
logger.error("Failed to label new Root partition")
return False
mount_cmd = "mount \"%s\" /liveos" % candidate_dev
if not _functions.system(mount_cmd):
logger.error("Failed to mount %s on /liveos" % candidate_dev)
_functions.system("lsof")
_functions.system("dmsetup info -c")
_functions.system("cat /proc/mounts")
_functions.system("multipath -ll")
_functions.system("lsblk")
_functions.system("ls -l /dev/mapper")
_functions.system("rm -rf /liveos/LiveOS")
_functions.system("mkdir -p /liveos/LiveOS")
_functions.mount_live()
if os.path.isdir(self.grub_dir):
shutil.rmtree(self.grub_dir)
if not os.path.exists(self.grub_dir):
os.makedirs(self.grub_dir)
if _functions.is_efi_boot():
logger.info("efi detected, installing efi configuration")
_functions.system("mkdir /liveos/efi")
_functions.mount_efi()
_functions.system("mkdir -p /liveos/efi/%s" % self.efi_path)
if _functions.is_iscsi_install() or _functions.is_efi_boot():
if os.path.isfile("/tmp/grubx64.efi"):
shutil.copy(
"/tmp/grubx64.efi",
"/liveos/efi/%s/grubx64.efi" % self.efi_path)
else:
shutil.copy("/tmp/grub.efi",
"/liveos/efi/%s/grub.efi" % self.efi_path)
elif os.path.isfile("/boot/efi/%s/grubx64.efi" %
self.efi_path):
shutil.copy("/boot/efi/%s/grubx64.efi" % self.efi_path,
"/liveos/efi/%s/grubx64.efi" % self.efi_path)
else:
shutil.copy("/boot/efi/%s/grub.efi" % self.efi_path,
"/liveos/efi/%s/grub.efi" % self.efi_path)
if _functions.is_iscsi_install() or _functions.findfs(
"BootNew"):
self.disk = _functions.findfs("BootNew")
if not "/dev/mapper/" in self.disk:
efi_disk = self.disk[:-1]
else:
efi_disk = re.sub(r'p?[1,2,3]$', "", self.disk)
# generate grub legacy config for efi partition
#remove existing efi entries
_functions.remove_efi_entry(_functions.PRODUCT_SHORT)
if self.efi_name == "fedora":
_functions.add_efi_entry(
_functions.PRODUCT_SHORT,
("\\EFI\\%s\\grubx64.efi" % self.efi_name), efi_disk)
else:
if os.path.isfile("/liveos/efi/%s/grubx64.efi" %
self.efi_path):
_functions.add_efi_entry(
_functions.PRODUCT_SHORT,
("\\EFI\\%s\\grubx64.efi" % self.efi_name),
efi_disk)
else:
_functions.add_efi_entry(
_functions.PRODUCT_SHORT,
("\\EFI\\%s\\grub.efi" % self.efi_name), efi_disk)
self.kernel_image_copy()
# reorder tty0 to allow both serial and phys console after installation
if _functions.is_iscsi_install() or _functions.findfs("BootNew"):
self.root_param = "root=live:LABEL=Root"
if "OVIRT_NETWORK_LAYOUT" in OVIRT_VARS and \
OVIRT_VARS["OVIRT_NETWORK_LAYOUT"] == "bridged":
network_conf = "ip=br%s:dhcp bridge=br%s:%s" % \
(OVIRT_VARS["OVIRT_BOOTIF"],
OVIRT_VARS["OVIRT_BOOTIF"],
OVIRT_VARS["OVIRT_BOOTIF"])
else:
network_conf = "ip=%s:dhcp" % OVIRT_VARS["OVIRT_BOOTIF"]
self.bootparams = "netroot=iscsi:%s::%s::%s %s " % (
OVIRT_VARS["OVIRT_ISCSI_TARGET_HOST"],
OVIRT_VARS["OVIRT_ISCSI_TARGET_PORT"],
OVIRT_VARS["OVIRT_ISCSI_TARGET_NAME"], network_conf)
if "OVIRT_ISCSI_NAME" in OVIRT_VARS:
self.bootparams+= "iscsi_initiator=%s " % \
OVIRT_VARS["OVIRT_ISCSI_NAME"]
else:
self.root_param = "root=live:LABEL=Root"
self.bootparams = "ro rootfstype=auto rootflags=ro "
self.bootparams += OVIRT_VARS["OVIRT_BOOTPARAMS"].replace(
"console=tty0", "").replace("rd_NO_MULTIPATH", "")
if " " in self.disk:
# workaround for grub setup failing with spaces in dev.name:
# use first active sd* device
self.disk = re.sub("p[1,2,3]$", "", self.disk)
grub_disk_cmd = ("multipath -l " + "\"" + self.disk + "\" " +
"| egrep -o '[0-9]+:.*' " +
"| awk '/ active / {print $2}' " + "| head -n1")
logger.debug(grub_disk_cmd)
grub_disk = _functions.subprocess_closefds(
grub_disk_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
grub_disk_output, grub_disk_err = grub_disk.communicate()
self.disk = grub_disk_output.strip()
if "cciss" in self.disk:
self.disk = self.disk.replace("!", "/")
# flush to sync DM and blockdev, workaround from rhbz#623846#c14
sysfs = open("/proc/sys/vm/drop_caches", "w")
sysfs.write("3")
sysfs.close()
if not self.disk.startswith("/dev/"):
self.disk = "/dev/" + self.disk
try:
if stat.S_ISBLK(os.stat(self.disk).st_mode):
try:
if stat.S_ISBLK(os.stat(self.disk[:-1]).st_mode):
# e.g. /dev/sda2
self.disk = self.disk[:-1]
except OSError:
pass
try:
if stat.S_ISBLK(os.stat(self.disk[:-2]).st_mode):
# e.g. /dev/mapper/WWIDp2
self.disk = self.disk[:-2]
except OSError:
pass
except OSError:
logger.error("Unable to determine disk for grub installation " +
traceback.format_exc())
return False
self.grub_dict = {
"product": _functions.PRODUCT_SHORT,
"version": _functions.PRODUCT_VERSION,
"release": _functions.PRODUCT_RELEASE,
"partN": self.partN,
"root_param": self.root_param,
"bootparams": self.bootparams,
"disk": self.disk,
"grub_dir": self.grub_dir,
"grub_prefix": self.grub_prefix,
"efi_hd": self.efi_hd,
"linux": "linux",
"initrd": "initrd",
}
if not _functions.is_firstboot():
if os.path.ismount("/live"):
with open("%s/version" % self.live_path) as version:
for line in version.readlines():
if "VERSION" in line:
key, value = line.split("=")
self.grub_dict["version"] = value.strip()
if "RELEASE" in line:
key, value = line.split("=")
self.grub_dict["release"] = value.strip()
if _functions.grub2_available():
if not self.grub2_install():
logger.error("Grub2 Installation Failed ")
return False
else:
logger.info("Grub2 EFI Installation Completed ")
else:
if not self.grub_install():
logger.error("Grub Installation Failed ")
return False
else:
logger.info("Grub Installation Completed")
if _functions.is_iscsi_install() or _functions.findfs("BootNew"):
# copy default for when Root/HostVG is inaccessible(iscsi upgrade)
shutil.copy(_functions.OVIRT_DEFAULTS, "/boot")
# mark new Boot ready to go, reboot() in ovirt-function switches it
# to active
e2label_cmd = "e2label \"%s\" BootUpdate" % boot_candidate_dev
if not _functions.system(e2label_cmd):
logger.error("Unable to relabel " + boot_candidate_dev +
" to RootUpdate ")
return False
else:
_functions.system("umount /liveos/efi")
_functions.system("umount /liveos")
# mark new Root ready to go, reboot() in ovirt-function switches it
# to active
e2label_cmd = "e2label \"%s\" RootUpdate" % candidate_dev
if not _functions.system(e2label_cmd):
logger.error("Unable to relabel " + candidate_dev +
" to RootUpdate ")
return False
_functions.system("udevadm settle --timeout=10")
#
# Rebuild the initramfs
# A few hacks are needed to prep the chroot
# The general issue is that we need to run dracut in the context fo the new iso
# and that we need to put the initrd in the right place of the new iso.
# These two things make the logic a bit more complicated.
#
mnts = []
try:
if not _functions.system("blkid -L RootUpdate"):
raise RuntimeError("RootUpdate not found")
# Let's mount the update fs, and use that kernel version and modules
# We need this work to help dracut
isomnt = tempfile.mkdtemp("RootUpdate")
squashmnt = tempfile.mkdtemp("RootUpdate-LiveOS")
updfs = tempfile.mkdtemp("RootUpdate-LiveOS-Img")
mnts += [isomnt, squashmnt, updfs]
# Unpack the iso
def _call(args):
logger.debug("Calling: %s" % args)
try:
out = subprocess.check_output(args)
logger.debug("Out: %s" % out)
except Exception as e:
logger.debug("Failed with: %s %s" % (e, e.output))
raise
_call(["mount", "LABEL=RootUpdate", isomnt])
_call(["mount", "%s/LiveOS/squashfs.img" % isomnt, squashmnt])
_call(["mount", "%s/LiveOS/ext3fs.img" % squashmnt, updfs])
# Now mount the update modules into place, and find the
# correct kver
def rbind(path, updfs=updfs):
dst = updfs + "/" + path
logger.debug("Binding %r to %r" % (path, dst))
_call(["mount", "--make-rshared", "--rbind", "/" + path, dst])
return dst
for path in ["etc", "dev", "proc", "sys", "tmp", "run", "var/tmp"]:
mnts += [rbind(path)]
upd_kver = str(
_functions.passthrough("ls -1 %s/lib/modules" %
updfs)).strip()
if len(upd_kver.splitlines()) != 1:
# It would be very unusual to see more than one kver directory
# in /lib/modules but might happen when using edit-node.
# Check via check_higher_kernel() the higher version available
upd_kver = self.check_higher_kernel(updfs)
if upd_kver is None:
raise RuntimeError("Unable to find the kernel version")
# Update initramfs to pickup multipath wwids
# Let /boot point to the filesystem on the update candidate partition
builder = _system.Initramfs(dracut_chroot=updfs,
boot_source=isomnt)
builder.rebuild(kver=upd_kver)
except Exception as e:
logger.debug("Failed to build initramfs: %s" % e, exc_info=True)
output = getattr(e, "output", "")
if output:
logger.debug("Output: %s" % output)
raise
finally:
# Clean up all eventual mounts
pass
# Disabled for now because akward things happen, we leave it to
# systemd to unnmount on reboot
# for mnt in reversed(mnts):
# d = _functions.passthrough("umount -fl %s" % mnt, logger.debug)
# logger.debug("Returned: %s" % d)
_functions.disable_firstboot()
if _functions.finish_install():
if _functions.is_firstboot():
_iscsi.iscsi_auto()
logger.info("Installation of %s Completed" % \
_functions.PRODUCT_SHORT)
if reboot is not None and reboot == "Y":
_system.async_reboot()
return True
else:
return False
def grub2_install(self):
GRUB2_EFI_CONFIG_TEMPLATE = """
insmod efi_gop
insmod efi_uga
"""
GRUB2_CONFIG_TEMPLATE = """
#default saved
set timeout=5
#hiddenmenu
menuentry "%(product)s %(version)s-%(release)s" {
set root=(hd0,%(partN)d)
search --no-floppy --label Root --set root
%(linux)s /vmlinuz0 %(root_param)s %(bootparams)s
%(initrd)s /initrd0.img
}"""
GRUB2_BACKUP_TEMPLATE = """
menuentry "BACKUP %(oldtitle)s" {
set root=(hd0,%(partB)d)
search --no-floppy --label RootBackup --set root
%(linux)s /vmlinuz0 root=live:LABEL=RootBackup %(bootparams)s
%(initrd)s /initrd0.img
} """
if _functions.is_iscsi_install():
disk = re.sub("p[1,2,3]$", "", \
_functions.findfs("BootNew"))
self.grub_dict["partN"] = int(_functions.findfs("BootNew")[-1:])
else:
disk = self.disk
if _functions.is_efi_boot():
boot_dir = self.initrd_dest + "/efi"
self.grub_dict["linux"] = "linuxefi"
self.grub_dict["initrd"] = "initrdefi"
else:
boot_dir = self.initrd_dest
if not _functions.is_efi_boot():
grub_setup_cmd = ("/sbin/grub2-install " + disk +
" --boot-directory=" + boot_dir +
" --root-directory=" + boot_dir +
" --efi-directory=" + boot_dir +
" --bootloader-id=" + self.efi_name + " --force")
_functions.system("echo '%s' >> /liveos/efi/cmd" % grub_setup_cmd)
logger.info(grub_setup_cmd)
grub_setup = _functions.subprocess_closefds(grub_setup_cmd, \
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
grub_results, grub_err = grub_setup.communicate()
logger.info(grub_results)
if grub_setup.wait() != 0 or "Error" in grub_results:
logger.error("grub2-install Failed")
return False
else:
efi_setup_cmd = (r'efibootmgr -c -L "RHEV-H" -l '
r'"\EFI\redhat\shim.efi" -d %s -p 1' % disk)
_functions.system("echo '%s' >> /liveos/efi/cmd" % efi_setup_cmd)
logger.info(efi_setup_cmd)
efi_setup = _functions.subprocess_closefds(
efi_setup_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
efi_results, efi_err = efi_setup.communicate()
logger.info(efi_results)
if efi_setup.wait() != 0:
logger.error("efibootmgr setup failed")
return False
else:
shutil.copy("/boot/efi/%s/shim.efi" % self.efi_path,
"/liveos/efi/%s/shim.efi" % self.efi_path)
logger.debug("Generating Grub2 Templates")
if _functions.is_efi_boot():
if not os.path.exists("/liveos/efi/%s" % self.efi_path):
os.makedirs("/liveos/efi/%s" % self.efi_path)
grub_conf = open(self.grub_config_file, "w")
grub_conf.write(GRUB2_CONFIG_TEMPLATE % self.grub_dict)
if self.oldtitle is not None:
partB = 0
if self.partN == 0:
partB = 1
self.grub_dict['oldtitle'] = self.oldtitle
self.grub_dict['partB'] = partB
grub_conf.write(GRUB2_BACKUP_TEMPLATE % self.grub_dict)
grub_conf.close()
if os.path.exists("/liveos/efi/EFI"):
efi_grub_conf = open("/liveos/efi/%s/grub.cfg" \
% self.efi_path, "w")
# inject efi console output modules
efi_grub_conf.write(GRUB2_EFI_CONFIG_TEMPLATE)
efi_grub_conf.write(GRUB2_CONFIG_TEMPLATE % self.grub_dict)
if self.oldtitle is not None:
partB = 0
if self.partN == 0:
partB = 1
self.grub_dict['oldtitle'] = self.oldtitle
self.grub_dict['partB'] = partB
efi_grub_conf.write(GRUB2_BACKUP_TEMPLATE % self.grub_dict)
efi_grub_conf.close()
_functions.system("umount /liveos")
_functions.remove_efi_entry(self.efi_name)
logger.info("Grub2 Install Completed")
return True
return True
def grub_install(self):
if _functions.is_iscsi_install() or _functions.findfs("BootNew"):
self.disk = _functions.findfs("BootNew")
self.grub_dict["partN"] = int(self.disk[-1:]) - 1
if not "/dev/mapper/" in self.disk:
self.disk = self.disk[:-1]
else:
self.disk = re.sub("p[1,2,3]$", "", self.disk)
device_map = "(hd0) %s" % self.disk
logger.debug(device_map)
device_map_conf = open(self.grub_dir + "/device.map", "w")
device_map_conf.write(device_map)
device_map_conf.close()
GRUB_CONFIG_TEMPLATE = """
default saved
timeout 5
hiddenmenu
%(splashscreen)s
title %(product)s %(version)s-%(release)s
root (hd0,%(partN)d)
kernel /vmlinuz0 %(root_param)s %(bootparams)s
initrd /initrd0.img
savedefault
"""
GRUB_BACKUP_TEMPLATE = """
title BACKUP %(oldtitle)s
root (hd0,%(partB)d)
kernel /vmlinuz0 root=live:LABEL=RootBackup %(bootparams)s
initrd /initrd0.img
savedefault
"""
GRUB_SETUP_TEMPLATE = """
grub --device-map=%(grub_dir)s/device.map <<EOF
root (hd0,%(partN)d)
setup --prefix=%(grub_prefix)s (hd0)
EOF
"""
if _functions.is_efi_boot():
""" The EFI product path.
eg: HD(1,800,64000,faacb4ef-e361-455e-bd97-ca33632550c3)
"""
efi_cmd = "efibootmgr -v"
efi = _functions.subprocess_closefds(efi_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
efi_out, efi_err = efi.communicate()
efi_out = efi_out.strip()
matches = re.search(_functions.PRODUCT_SHORT + r'\s+(HD\(.+?\))', \
efi_out)
if matches and matches.groups():
GRUB_EFIONLY_CONFIG = """%(efi_hd)s"""
GRUB_CONFIG_TEMPLATE = GRUB_EFIONLY_CONFIG + \
GRUB_CONFIG_TEMPLATE
self.grub_dict['efi_hd'] = "device (hd0) " + matches.group(1)
if os.path.exists("/live/EFI/BOOT/splash.xpm.gz"):
if _functions.is_iscsi_install() or _functions.findfs("BootNew"):
splashscreen = "splashimage=(hd0,%s)/grub/splash.xpm.gz" \
% self.grub_dict["partN"]
else:
splashscreen = "splashimage=(hd0,%s)/grub/splash.xpm.gz" \
% self.partN
else:
splashscreen = ""
self.grub_dict["splashscreen"] = splashscreen
GRUB_CONFIG_TEMPLATE % self.grub_dict
grub_conf = open(self.grub_config_file, "w")
grub_conf.write(GRUB_CONFIG_TEMPLATE % self.grub_dict)
if self.oldtitle is not None:
partB = 1
if self.partN == 1:
partB = 2
if _functions.is_iscsi_install() or _functions.findfs("Boot"):
partB = partB + 1
self.grub_dict['oldtitle'] = self.oldtitle
self.grub_dict['partB'] = partB
grub_conf.write(GRUB_BACKUP_TEMPLATE % self.grub_dict)
grub_conf.close()
# splashscreen
if _functions.is_iscsi_install() or _functions.findfs("BootNew"):
_functions.system("cp /live/EFI/BOOT/splash.xpm.gz /boot/grub")
else:
_functions.system("cp /live/EFI/BOOT/splash.xpm.gz /liveos/grub")
# usb devices requires default BOOTX64 entries
if _functions.is_efi_boot():
_functions.system("mkdir -p /liveos/efi/EFI/BOOT")
if _functions.is_iscsi_install() or _functions.findfs("BootNew"):
_functions.system("cp /tmp/grub.efi \
/liveos/efi/EFI/BOOT/BOOTX64.efi")
if os.path.isfile("/boot/efi/%s/grubx86.efi" % self.efi_path):
_functions.system("cp /boot/efi/%s/grubx64.efi \
/liveos/efi/EFI/BOOT/BOOTX64.efi" %
self.efi_path)
else:
_functions.system("cp /boot/efi/%s/grub.efi \
/liveos/efi/EFI/BOOT/BOOTX64.efi" %
self.efi_path)
_functions.system("cp %s /liveos/efi/EFI/BOOT/BOOTX64.conf" \
% self.grub_config_file)
_functions.system("umount /liveos/efi")
if not _functions.is_efi_boot():
for f in ["stage1", "stage2", "e2fs_stage1_5"]:
_functions.system("cp /usr/share/grub/x86_64-redhat/%s %s" % \
(f, self.grub_dir))
grub_setup_out = GRUB_SETUP_TEMPLATE % self.grub_dict
logger.debug(grub_setup_out)
grub_setup = _functions.subprocess_closefds(
grub_setup_out,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
grub_results, grub_err = grub_setup.communicate()
logger.debug(grub_results)
if grub_setup.wait() != 0 or "Error" in grub_results:
logger.error("GRUB setup failed")
return False
return True
def get_dev_name(self):
devices = []
# list separator
for d in os.listdir("/sys/block/"):
if re.match("^[hsv]+d", d):
devices.append("/dev/%s" % d)
byid_list_cmd = ("find /dev/disk/by-id -mindepth 1 -not -name " +
"'*-part*' 2>/dev/null")
byid_list = _functions.subprocess_closefds(byid_list_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
byid_list_output, byid_list_err = byid_list.communicate()
for d in byid_list_output.split():
d = os.readlink(d)
d_basename = os.path.basename(d)
udev_cmd = ("udevadm info --name=/dev/" + d_basename +
" --query=property | grep -q ^ID_BUS: &>>/dev/null")
if _functions.system_closefds(udev_cmd):
devices.append("/dev/%s" % d_basename)
# FIXME: workaround for detecting cciss devices
if os.path.exists("/dev/cciss"):
for d in os.listdir("/dev/cciss"):
if not re.match("p[0-9]+\$", d):
devices.append("/dev/cciss/%s" % d)
# include multipath devices
mpath_sets = ""
devs_to_remove = {}
multipath_list_cmd = "dmsetup ls --target=multipath | cut -f1"
multipath_list = _functions.subprocess_closefds(multipath_list_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
multipath_list_output, multipath_list_err = multipath_list.communicate()
for d in multipath_list_output.split():
devices.append("/dev/mapper/%s" % d)
sd_devs = ""
sd_devs = self.get_multipath_deps(d)
dm_dev_cmd = ("multipath -ll \"%s\" | grep \"%s\" | " +
"sed -r 's/^.*(dm-[0-9]+ ).*$/\\1/'") % (d, d)
dm_dev = _functions.subprocess_closefds(dm_dev_cmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
dm_dev_output, dm_dev_err = dm_dev.communicate()
[devs_to_remove.update({d: True}) for d in sd_devs.split()]
mpath_sets = ("%s %s %s" % (mpath_sets, sd_devs,
dm_dev_output))
logger.debug("Multipath sets are %s" % mpath_sets)
logger.debug("Removing the following from the list of disks, because "
"they're part of a multipath set: %s" % sorted(
devs_to_remove))
# Remove /dev/sd* devices that are part of a multipath device
dev_list = set()
for d in devices:
if (os.path.basename(d) not in devs_to_remove and
not "/dev/dm-" in d):
dev_list.add(d)
return list(dev_list)
def __init__(self):
logger = logging.getLogger(_functions.PRODUCT_SHORT)
logger.propagate = False
OVIRT_VARS = _functions.parse_defaults()
self.overcommit = 0.5
self.BOOT_SIZE = 50
self.ROOT_SIZE = 256
self.CONFIG_SIZE = 5
self.LOGGING_SIZE = 2048
self.EFI_SIZE = 256
self.SWAP_SIZE = 0
self.MIN_SWAP_SIZE = 5
self.SWAP2_SIZE = 0
self.DATA2_SIZE = 0
self.BOOTDRIVE = ""
self.HOSTVGDRIVE = ""
self.APPVGDRIVE = []
self.ISCSIDRIVE = ""
# -1 indicates data partition should use remaining disk
self.DATA_SIZE = -1
# gpt or msdos partition table type
self.LABEL_TYPE = "gpt"
if "OVIRT_INIT" in OVIRT_VARS:
_functions.OVIRT_VARS["OVIRT_INIT"] = \
_functions.OVIRT_VARS["OVIRT_INIT"].strip(",")
if "," in _functions.OVIRT_VARS["OVIRT_INIT"]:
disk_count = 0
for disk in _functions.OVIRT_VARS["OVIRT_INIT"].split(","):
skip = False
if disk_count < 1:
self.ROOTDRIVE = disk
disk_count = disk_count + 1
self.HOSTVGDRIVE = disk
else:
for hostvg in self.HOSTVGDRIVE.split(","):
if hostvg == disk:
skip = True
break
if not skip:
self.HOSTVGDRIVE = self.HOSTVGDRIVE + "," + disk
else:
self.ROOTDRIVE = _functions.translate_multipath_device(
_functions.OVIRT_VARS["OVIRT_INIT"])
self.HOSTVGDRIVE = _functions.translate_multipath_device(
_functions.OVIRT_VARS["OVIRT_INIT"])
if _functions.is_iscsi_install():
logger.info(self.BOOTDRIVE)
logger.info(self.ROOTDRIVE)
self.BOOTDRIVE = _functions.translate_multipath_device( \
self.ROOTDRIVE)
mem_size_cmd = "awk '/MemTotal:/ { print $2 }' /proc/meminfo"
mem_size_mb = _functions.subprocess_closefds(mem_size_cmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
MEM_SIZE_MB = mem_size_mb.stdout.read()
MEM_SIZE_MB = int(MEM_SIZE_MB) / 1024
# we multiply the overcommit coefficient by 10 then divide the
# product by 10 to avoid decimals in the result
OVERCOMMIT_SWAP_SIZE = int(MEM_SIZE_MB) * self.overcommit * 10 / 10
# add to the swap the amounts from
# http://kbase.redhat.com/faq/docs/DOC-15252
MEM_SIZE_GB = int(MEM_SIZE_MB) / 1024
if MEM_SIZE_GB < 4:
BASE_SWAP_SIZE = 2048
elif MEM_SIZE_GB < 16:
BASE_SWAP_SIZE = 4096
elif MEM_SIZE_GB < 64:
BASE_SWAP_SIZE = 8192
else:
BASE_SWAP_SIZE = 16384
if "OVIRT_VOL_SWAP_SIZE" in OVIRT_VARS:
if int(OVIRT_VARS["OVIRT_VOL_SWAP_SIZE"]) < self.MIN_SWAP_SIZE:
logger.error("Swap size is smaller than minimum required + "
"size of: %s" % self.MIN_SWAP_SIZE)
print ("\n\nSwap size is smaller than minimum required " +
"size of: %s" % self.MIN_SWAP_SIZE)
return False
sys.exit(1)
else:
self.SWAP_SIZE = _functions.OVIRT_VARS["OVIRT_VOL_SWAP_SIZE"]
else:
self.SWAP_SIZE = int(BASE_SWAP_SIZE) + int(OVERCOMMIT_SWAP_SIZE)
for i in ['OVIRT_VOL_BOOT_SIZE', 'OVIRT_VOL_ROOT_SIZE',
'OVIRT_VOL_CONFIG_SIZE', 'OVIRT_VOL_LOGGING_SIZE',
'OVIRT_VOL_DATA_SIZE', 'OVIRT_VOL_SWAP2_SIZE',
'OVIRT_VOL_DATA2_SIZE']:
i_short = i.replace("OVIRT_VOL_", "")
if i in OVIRT_VARS:
if int(OVIRT_VARS[i]) < int(self.__dict__[i_short]):
logger.error("%s is smaller than minimum required size " +
"of: %s" % (i, self.__dict__[i_short]))
print ("\n%s is smaller than minimum required size of: " +
"%s" % (i, self.__dict__[i_short]))
return False
logging.info(("Setting value for %s to %s " %
(self.__dict__[i_short], _functions.OVIRT_VARS[i])))
self.__dict__[i_short] = int(OVIRT_VARS[i])
else:
logging.info("Using default value for: %s" % i_short)
self.RootBackup_end = self.ROOT_SIZE * 2 + self.EFI_SIZE
self.Root_end = self.EFI_SIZE + self.ROOT_SIZE
if "OVIRT_INIT_APP" in OVIRT_VARS:
if self.SWAP2_SIZE != 0 or self.DATA2_SIZE != 0:
for drv in _functions.OVIRT_VARS["OVIRT_INIT_APP"].split(","):
DRIVE = _functions.translate_multipath_device(drv)
self.APPVGDRIVE.append(DRIVE)
if not self.cross_check_host_app:
logger.error("Skip disk partitioning, " +
"AppVG overlaps with HostVG")
return False
else:
if self.SWAP2_SIZE != 0 or self.DATA2_SIZE != 0:
logger.error("Missing device parameter for AppVG: " +
"unable to partition any disk")
return False
def save_network_configuration(self):
_functions.aug.load()
net_configured = 0
_functions.augtool_workdir_list = "ls %s/augtool-* >/dev/null"
logger.info("Configuring network for NIC %s" % self.CONFIGURED_NIC)
# Wee need to bring down all network stuff, with the current network
# config, before we change the config. Otherwise the interfaces can
# not be brought down correctly.
logger.info("Stopping Network services")
_functions.system("service network stop")
# FIXME can't this be done further down were we remove the bridges?
for vlan in get_system_vlans():
# XXX wrong match e.g. eth10.1 with eth1
if self.CONFIGURED_NIC in vlan:
_functions.system_closefds("vconfig rem " + vlan + \
"&> /dev/null")
_functions.ovirt_safe_delete_config(self.IFSCRIPTS_PATH + vlan)
_functions.system_closefds("rm -rf " + \
self.IFSCRIPTS_PATH + vlan)
# All old config files are gone, the new ones are created step by step
logger.debug("Removing persisted network configs")
# This should cover NICs, VLANs and bridges
for script in glob("%s*" % (self.IFSCRIPTS_PATH)):
#print script
#print 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
if not _functions.is_persisted(script):
continue
logger.debug("Removing Script: " + script)
_functions.ovirt_safe_delete_config(script)
_functions.aug.load()
logger.debug("Updating interface config")
for line in self.IF_CONFIG:
logger.debug(line)
try:
oper, key, value = line.split()
_functions.augtool(oper, key, value)
except:
oper, key = line.split()
_functions.augtool(oper, key, "")
logger.debug("Updating bridge config")
if not self.disabled_nic == 1:
for line in self.BR_CONFIG:
logger.debug(line)
try:
oper, key, value = line.split()
_functions.augtool(oper, key, value)
except:
try:
oper, key = line.split()
_functions.augtool(oper, key, "")
except:
pass
logger.debug("Updating VLAN config")
for line in self.VL_CONFIG.split("\n"):
logger.debug(line)
try:
oper, key, value = line.split()
_functions.augtool(oper, key, value)
except:
try:
oper, key = line.split()
_functions.augtool(oper, key, "")
except:
pass
# preserve current MAC mappings for *all physical* network interfaces
logger.error("Preserving current MAC mappings")
for nicdev in glob('/sys/class/net/*/device'):
nic = nicdev.split('/')[4]
if nic != self.CONFIGURED_NIC:
f = open('/sys/class/net/%s/address' % nic)
mac = f.read().strip()
f.close()
if len(mac) > 0:
logger.debug("Mapping for %s" % nic)
self.CONFIGURED_NICS.append(nic)
nicroot = "%s%s" % (self.IFCONFIG_FILE_ROOT, nic)
# XXX _functions.augtool does save every time!
_functions.augtool("set", "%s/DEVICE" % nicroot, nic)
_functions.augtool("set", "%s/HWADDR" % nicroot, mac)
_functions.augtool("set", "%s/ONBOOT" % nicroot, "no")
logger.debug("Storing configured NICs")
net_configured = 1
for nic in self.CONFIGURED_NICS:
logger.debug("Storing %s" % nic)
_functions.ovirt_store_config("%s%s" % (self.IFSCRIPTS_PATH, nic))
_functions.ovirt_store_config(self.NTP_CONFIG_FILE)
if self.disabled_nic == 1:
_functions.augtool("set", \
"/files/etc/sysconfig/network/NETWORKING", "no")
else:
_functions.augtool("set", \
"/files/etc/sysconfig/network/NETWORKING", "yes")
_functions.ovirt_store_config("/etc/sysconfig/network")
_functions.ovirt_store_config("/etc/hosts")
# Copy the initial net rules to a file that get's not
# overwritten at each boot, rhbz#773495
rulesfile = "/etc/udev/rules.d/70-persistent-net.rules"
newrulesfile = "/etc/udev/rules.d/71-persistent-node-net.rules"
if os.path.exists(rulesfile):
_functions.system_closefds("cp %s %s >> /var/log/ovirt.log" %
(rulesfile, newrulesfile))
_functions.ovirt_store_config(newrulesfile)
# Eventully it makes sense to rename the NICs
#system_closefds("sed -ic 's/NAME=\"eth/NAME=\"eth00/' " +
# "/etc/udev/rules.d/71-persistent-node-net.rules")
logger.info("Network configured successfully")
if net_configured == 1:
logger.info("Stopping Network services")
_functions.system_closefds("service network stop &> /dev/null")
_functions.system_closefds("service ntpd stop &> /dev/null")
# XXX eth assumed in breth
brctl_cmd = "brctl show| awk 'NR>1 && /^br[ep]/ {print $1}'"
brctl = _functions.subprocess_closefds(brctl_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
brctl_output = brctl.stdout.read()
for i in brctl_output.split():
if_down_cmd = "ifconfig %s down &> /dev/null" % i
_functions.system_closefds(if_down_cmd)
del_br_cmd = "brctl delbr %s &> /dev/null" % i
_functions.system_closefds(del_br_cmd)
logger.info("Starting Network service")
_functions.system_closefds("service network start &> /dev/null")
_functions.system_closefds("service ntpdate start &> /dev/null")
_functions.system_closefds("service ntpd start &> /dev/null")
# rhbz#745541
_functions.system_closefds("service rpcbind start &> /dev/null")
_functions.system_closefds("service nfslock start &> /dev/null")
_functions.system_closefds("service rpcidmapd start &> /dev/null")
_functions.system_closefds("service rpcgssd start &> /dev/null")
if "NTP" in OVIRT_VARS:
logger.info("Testing NTP Configuration")
_functions.test_ntp_configuration()
def get_system_nics():
# Re-trigger udev for rhbz#866584
for sysfspath in glob("/sys/class/net/*"):
_functions.system_closefds("udevadm test %s > /dev/null 2> /dev/null" %
sysfspath)
client = _functions.gudev.Client(['net'])
configured_nics = 0
ntp_dhcp = 0
nic_dict = {}
for device in client.query_by_subsystem("net"):
try:
dev_interface = device.get_property("INTERFACE")
dev_vendor = device.get_property("ID_VENDOR_FROM_DATABASE")
dev_type = device.get_property("DEVTYPE")
dev_path = device.get_property("DEVPATH")
if (dev_interface == "lo" or \
dev_interface.startswith("bond") or \
dev_interface.startswith("sit") or \
dev_interface.startswith("vnet") or \
"." in dev_interface or \
dev_type == "bridge"):
logger.info("Skipping interface '%s'" % dev_interface)
continue
else:
logger.info("Gathering informations for '%s'" % dev_interface)
try:
dev_vendor = dev_vendor.replace(",", "")
except AttributeError:
logger.debug("2. vendor approach: %s" % dev_vendor)
try:
# rhevh workaround since udev version
# doesn't have vendor info
dev_path = dev_path.split('/')
if "virtio" in dev_path[4]:
pci_dev = dev_path[3].replace("0000:", "")
else:
pci_dev = dev_path[4].replace("0000:", "")
pci_lookup_cmd = (
("lspci|grep '%s'|awk -F \":\" " % pci_dev) +
"{'print $3'}")
pci_lookup = _functions.subprocess_closefds(
pci_lookup_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
dev_vendor = pci_lookup.stdout.read().strip()
except:
dev_vendor = "unknown"
logger.debug("3. vendor approach: %s" % dev_vendor)
try:
dev_vendor = dev_vendor.replace(",", "")
except AttributeError:
dev_vendor = "unknown"
logger.debug("4. vendor approach: %s" % dev_vendor)
dev_vendor = _functions.pad_or_trim(25, dev_vendor)
dev_driver = ""
try:
dev_driver = os.readlink("/sys/class/net/" + dev_interface + \
"/device/driver")
dev_driver = os.path.basename(dev_driver)
except Exception as e:
logger.debug("Exception while determining NIC driver: %s" %
(repr(e)))
nic_addr_file = open("/sys/class/net/" + dev_interface + \
"/address")
dev_address = nic_addr_file.read().strip()
cmd = ("/files/etc/sysconfig/network-scripts/" + \
"ifcfg-%s/BOOTPROTO") % str(dev_interface)
dev_bootproto = _functions.augtool_get(cmd)
type_cmd = ("/files/etc/sysconfig/network-scripts/" + \
"ifcfg-%s/TYPE") % str(dev_interface)
bridge_cmd = ("/files/etc/sysconfig/network-scripts/" + \
"ifcfg-%s/BRIDGE") % str(dev_interface)
dev_bridge = _functions.augtool_get(bridge_cmd)
# check for vlans
logger.debug("checking for vlan")
vlans = glob("/etc/sysconfig/network-scripts/ifcfg-%s.*" %
dev_interface)
if (len(vlans) > 0):
dev_conf_status = "Configured "
vlanid = vlans[0].split(".")[-1]
logger.debug("found vlan %s" % vlanid)
# if no bridge in nic, check clan-nic for bridge
if not dev_bridge:
vlancfg = "ifcfg-%s.%s" % (str(dev_interface), vlanid)
cmd = ("/files/etc/sysconfig/network-scripts/%s/" +
"BRIDGE") % vlancfg
dev_bridge = augtool_get(cmd)
logger.debug("Getting bridge '%s' from vlan: %s" %
(dev_bridge, cmd))
if dev_bootproto is None:
logger.debug("Looking for bootproto in %s" % dev_bridge)
cmd = ("/files/etc/sysconfig/network-scripts/" + \
"ifcfg-%s/BOOTPROTO") % str(dev_bridge)
dev_bootproto = _functions.augtool_get(cmd)
if dev_bootproto is None:
dev_bootproto = "Disabled"
dev_conf_status = "Unconfigured"
else:
dev_conf_status = "Configured "
else:
dev_conf_status = "Configured "
if dev_conf_status == "Configured ":
configured_nics = configured_nics + 1
except Exception as e:
logger.warning("Error while determining NICs: %s" % repr(e))
nic_info = "%s,%s,%s,%s,%s,%s,%s" % ( \
dev_interface, dev_bootproto, \
dev_vendor, dev_address, \
dev_driver, dev_conf_status, \
dev_bridge)
logger.debug("NIC info: %s" % nic_info)
nic_dict[dev_interface] = nic_info
if dev_bootproto == "dhcp":
ntp_dhcp = 1
return nic_dict, configured_nics, ntp_dhcp
def ovirt_boot_setup(self, reboot="N"):
self.generate_paths()
logger.info("Installing the image.")
# copy grub.efi to safe location
if _functions.is_efi_boot():
if "OVIRT_ISCSI_INSTALL" in OVIRT_VARS:
_functions.system("umount /boot")
if os.path.isfile("/boot/efi/%s/grubx64.efi" % self.efi_path):
shutil.copy("/boot/efi/%s/grubx64.efi" % self.efi_path, "/tmp")
else:
shutil.copy("/boot/efi/%s/grub.efi" % self.efi_path, "/tmp")
_functions.mount_boot()
if "OVIRT_ROOT_INSTALL" in OVIRT_VARS:
if OVIRT_VARS["OVIRT_ROOT_INSTALL"] == "n":
logger.info("Root Installation Not Required, Finished.")
return True
self.oldtitle=None
grub_config_file = None
if _functions.findfs("Boot") and _functions.is_upgrade():
grub_config_file = "/boot/grub/grub.conf"
if not _functions.connect_iscsi_root():
return False
_functions.mount_liveos()
if os.path.ismount("/liveos"):
if os.path.exists("/liveos/vmlinuz0") \
and os.path.exists("/liveos/initrd0.img"):
grub_config_file = self.grub_config_file
elif not _functions.is_firstboot():
# find existing iscsi install
if _functions.findfs("Boot"):
grub_config_file = "/boot/grub/grub.conf"
elif os.path.ismount("/dev/.initramfs/live"):
if not _functions.grub2_available():
grub_config_file = "/dev/.initramfs/live/grub/grub.conf"
else:
grub_config_file = "/dev/.initramfs/live/grub2/grub.cfg"
elif os.path.ismount("/run/initramfs/live"):
grub_config_file = "/run/initramfs/live/grub/grub.conf"
if _functions.is_upgrade() and not _functions.is_iscsi_install():
_functions.mount_liveos()
grub_config_file = "/liveos/grub/grub.conf"
if _functions.is_iscsi_install() or _functions.findfs("Boot") \
and not _functions.is_efi_boot():
grub_config_file = "/boot/grub/grub.conf"
if _functions.is_efi_boot():
logger.debug(str(os.listdir("/liveos")))
_functions.system("umount /liveos")
_functions.mount_efi(target="/liveos")
if self.efi_name == "fedora":
grub_config_file = "/liveos/EFI/fedora/grub.cfg"
else:
grub_config_file = "/liveos/%s/grub.conf" % self.efi_path
grub_config_file_exists = grub_config_file is not None \
and os.path.exists(grub_config_file)
logger.debug("Grub config file is: %s" % grub_config_file)
logger.debug("Grub config file exists: %s" % grub_config_file_exists)
if not grub_config_file is None and os.path.exists(grub_config_file):
f=open(grub_config_file)
oldgrub=f.read()
f.close()
if _functions.grub2_available():
m=re.search("^menuentry (.*)$", oldgrub, re.MULTILINE)
else:
m=re.search("^title (.*)$", oldgrub, re.MULTILINE)
if m is not None:
self.oldtitle=m.group(1)
# strip off extra title characters
if _functions.grub2_available():
self.oldtitle = self.oldtitle.replace('"','').strip(" {")
_functions.system("umount /liveos/efi")
_functions.system("umount /liveos")
if _functions.is_iscsi_install() or _functions.findfs("Boot"):
self.boot_candidate = None
boot_candidate_names = ["BootBackup", "BootUpdate", "BootNew"]
for trial in range(1, 3):
time.sleep(1)
for candidate_name in boot_candidate_names:
logger.debug(os.listdir("/dev/disk/by-label"))
if _functions.findfs(candidate_name):
self.boot_candidate = candidate_name
break
logger.debug("Trial %s to find candidate (%s)" % \
(trial, candidate_name))
if self.boot_candidate:
logger.debug("Found candidate: %s" % self.boot_candidate)
break
if not self.boot_candidate:
logger.error("Unable to find boot partition")
label_debug = ''
for label in os.listdir("/dev/disk/by-label"):
label_debug += "%s\n" % label
label_debug += _functions.subprocess_closefds("blkid", \
shell=True, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT).stdout.read()
logger.debug(label_debug)
return False
else:
boot_candidate_dev = _functions.findfs(self.boot_candidate)
# prepare Root partition update
if self.boot_candidate != "BootNew":
e2label_cmd = "e2label \"%s\" BootNew" % boot_candidate_dev
logger.debug(e2label_cmd)
if not _functions.system(e2label_cmd):
logger.error("Failed to label new Boot partition")
return False
_functions.system("umount /boot")
_functions.system("mount %s /boot &>/dev/null" \
% boot_candidate_dev)
candidate = None
candidate_dev = None
candidate_names = ["RootBackup", "RootUpdate", "RootNew"]
for trial in range(1, 3):
time.sleep(1)
for candidate_name in candidate_names:
candidate_dev = _functions.findfs(candidate_name)
logger.debug("Finding %s: '%s'" % (candidate_name, candidate_dev))
if candidate_dev:
candidate = candidate_name
logger.debug("Found: %s" % candidate)
break
logger.debug("Trial %s to find candidate (%s)" % (trial,
candidate_name))
if candidate:
logger.debug("Found candidate: '%s'" % candidate)
break
if not candidate:
logger.error("Unable to find root partition")
label_debug = ''
for label in os.listdir("/dev/disk/by-label"):
label_debug += "%s\n" % label
label_debug += _functions.subprocess_closefds("blkid", shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT).stdout.read()
logger.debug(label_debug)
return False
try:
self.disk = candidate_dev
logger.info("Candidate device: %s" % candidate_dev)
logger.info("Candidate disk: %s" % self.disk)
# grub2 starts at part 1
self.partN = int(self.disk[-1:])
if not _functions.grub2_available():
self.partN = self.partN - 1
except:
logger.debug("Failed to get partition", exc_info=True)
return False
if self.disk is None or self.partN < 0:
logger.error("Failed to determine Root partition number")
return False
# prepare Root partition update
if candidate != "RootNew":
e2label_cmd = "e2label \"%s\" RootNew" % candidate_dev
logger.debug(e2label_cmd)
if not _functions.system(e2label_cmd):
logger.error("Failed to label new Root partition")
return False
mount_cmd = "mount \"%s\" /liveos" % candidate_dev
if not _functions.system(mount_cmd):
logger.error("Failed to mount %s on /liveos" % candidate_dev)
_functions.system("lsof")
_functions.system("dmsetup info -c")
_functions.system("cat /proc/mounts")
_functions.system("multipath -ll")
_functions.system("lsblk")
_functions.system("ls -l /dev/mapper")
_functions.system("rm -rf /liveos/LiveOS")
_functions.system("mkdir -p /liveos/LiveOS")
_functions.mount_live()
if os.path.isdir(self.grub_dir):
shutil.rmtree(self.grub_dir)
if not os.path.exists(self.grub_dir):
os.makedirs(self.grub_dir)
if _functions.is_efi_boot():
logger.info("efi detected, installing efi configuration")
_functions.system("mkdir /liveos/efi")
_functions.mount_efi()
_functions.system("mkdir -p /liveos/efi/%s" % self.efi_path)
if _functions.is_iscsi_install() or _functions.is_efi_boot():
if os.path.isfile("/tmp/grubx64.efi"):
shutil.copy("/tmp/grubx64.efi",
"/liveos/efi/%s/grubx64.efi" %
self.efi_path)
else:
shutil.copy("/tmp/grub.efi",
"/liveos/efi/%s/grub.efi" % self.efi_path)
elif os.path.isfile("/boot/efi/%s/grubx64.efi" %
self.efi_path):
shutil.copy("/boot/efi/%s/grubx64.efi" % self.efi_path,
"/liveos/efi/%s/grubx64.efi" % self.efi_path)
else:
shutil.copy("/boot/efi/%s/grub.efi" % self.efi_path,
"/liveos/efi/%s/grub.efi" % self.efi_path)
if _functions.is_iscsi_install() or _functions.findfs("BootNew"):
self.disk = _functions.findfs("BootNew")
if not "/dev/mapper/" in self.disk:
efi_disk = self.disk[:-1]
else:
efi_disk = re.sub(r'p?[1,2,3]$', "", self.disk)
# generate grub legacy config for efi partition
#remove existing efi entries
_functions.remove_efi_entry(_functions.PRODUCT_SHORT)
if self.efi_name == "fedora":
_functions.add_efi_entry(_functions.PRODUCT_SHORT,
("\\EFI\\%s\\grubx64.efi" %
self.efi_name),
efi_disk)
else:
if os.path.isfile("/liveos/efi/%s/grubx64.efi" %
self.efi_path):
_functions.add_efi_entry(_functions.PRODUCT_SHORT,
("\\EFI\\%s\\grubx64.efi" %
self.efi_name),
efi_disk)
else:
_functions.add_efi_entry(_functions.PRODUCT_SHORT,
("\\EFI\\%s\\grub.efi" %
self.efi_name),
efi_disk)
self.kernel_image_copy()
# reorder tty0 to allow both serial and phys console after installation
if _functions.is_iscsi_install() or _functions.findfs("BootNew"):
self.root_param = "root=live:LABEL=Root"
if "OVIRT_NETWORK_LAYOUT" in OVIRT_VARS and \
OVIRT_VARS["OVIRT_NETWORK_LAYOUT"] == "bridged":
network_conf = "ip=br%s:dhcp bridge=br%s:%s" % \
(OVIRT_VARS["OVIRT_BOOTIF"],
OVIRT_VARS["OVIRT_BOOTIF"],
OVIRT_VARS["OVIRT_BOOTIF"])
else:
network_conf = "ip=%s:dhcp" % OVIRT_VARS["OVIRT_BOOTIF"]
self.bootparams = "netroot=iscsi:%s::%s::%s %s " % (
OVIRT_VARS["OVIRT_ISCSI_TARGET_HOST"],
OVIRT_VARS["OVIRT_ISCSI_TARGET_PORT"],
OVIRT_VARS["OVIRT_ISCSI_TARGET_NAME"],
network_conf)
if "OVIRT_ISCSI_NAME" in OVIRT_VARS:
self.bootparams+= "iscsi_initiator=%s " % \
OVIRT_VARS["OVIRT_ISCSI_NAME"]
else:
self.root_param = "root=live:LABEL=Root"
self.bootparams = "ro rootfstype=auto rootflags=ro "
self.bootparams += OVIRT_VARS["OVIRT_BOOTPARAMS"].replace(
"console=tty0", ""
).replace(
"rd_NO_MULTIPATH",
"")
if " " in self.disk:
# workaround for grub setup failing with spaces in dev.name:
# use first active sd* device
self.disk = re.sub("p[1,2,3]$", "", self.disk)
grub_disk_cmd = ("multipath -l " +
"\"" + self.disk + "\" " +
"| egrep -o '[0-9]+:.*' " +
"| awk '/ active / {print $2}' " +
"| head -n1")
logger.debug(grub_disk_cmd)
grub_disk = _functions.subprocess_closefds(grub_disk_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
grub_disk_output, grub_disk_err = grub_disk.communicate()
self.disk = grub_disk_output.strip()
if "cciss" in self.disk:
self.disk = self.disk.replace("!", "/")
# flush to sync DM and blockdev, workaround from rhbz#623846#c14
sysfs = open("/proc/sys/vm/drop_caches", "w")
sysfs.write("3")
sysfs.close()
if not self.disk.startswith("/dev/"):
self.disk = "/dev/" + self.disk
try:
if stat.S_ISBLK(os.stat(self.disk).st_mode):
try:
if stat.S_ISBLK(os.stat(self.disk[:-1]).st_mode):
# e.g. /dev/sda2
self.disk = self.disk[:-1]
except OSError:
pass
try:
if stat.S_ISBLK(os.stat(self.disk[:-2]).st_mode):
# e.g. /dev/mapper/WWIDp2
self.disk = self.disk[:-2]
except OSError:
pass
except OSError:
logger.error("Unable to determine disk for grub installation " +
traceback.format_exc())
return False
self.grub_dict = {
"product": _functions.PRODUCT_SHORT,
"version": _functions.PRODUCT_VERSION,
"release": _functions.PRODUCT_RELEASE,
"partN": self.partN,
"root_param": self.root_param,
"bootparams": self.bootparams,
"disk": self.disk,
"grub_dir": self.grub_dir,
"grub_prefix": self.grub_prefix,
"efi_hd": self.efi_hd,
"linux": "linux",
"initrd": "initrd",
}
if not _functions.is_firstboot():
if os.path.ismount("/live"):
with open("%s/version" % self.live_path) as version:
for line in version.readlines():
if "VERSION" in line:
key, value = line.split("=")
self.grub_dict["version"] = value.strip()
if "RELEASE" in line:
key, value = line.split("=")
self.grub_dict["release"] = value.strip()
if _functions.grub2_available():
if not self.grub2_install():
logger.error("Grub2 Installation Failed ")
return False
else:
logger.info("Grub2 EFI Installation Completed ")
else:
if not self.grub_install():
logger.error("Grub Installation Failed ")
return False
else:
logger.info("Grub Installation Completed")
if _functions.is_iscsi_install() or _functions.findfs("BootNew"):
# copy default for when Root/HostVG is inaccessible(iscsi upgrade)
shutil.copy(_functions.OVIRT_DEFAULTS, "/boot")
# mark new Boot ready to go, reboot() in ovirt-function switches it
# to active
e2label_cmd = "e2label \"%s\" BootUpdate" % boot_candidate_dev
if not _functions.system(e2label_cmd):
logger.error("Unable to relabel " + boot_candidate_dev +
" to RootUpdate ")
return False
else:
_functions.system("umount /liveos/efi")
_functions.system("umount /liveos")
# mark new Root ready to go, reboot() in ovirt-function switches it
# to active
e2label_cmd = "e2label \"%s\" RootUpdate" % candidate_dev
if not _functions.system(e2label_cmd):
logger.error("Unable to relabel " + candidate_dev +
" to RootUpdate ")
return False
_functions.system("udevadm settle --timeout=10")
#
# Rebuild the initramfs
# A few hacks are needed to prep the chroot
# The general issue is that we need to run dracut in the context fo the new iso
# and that we need to put the initrd in the right place of the new iso.
# These two things make the logic a bit more complicated.
#
mnts = []
try:
if not _functions.system("blkid -L RootUpdate"):
raise RuntimeError("RootUpdate not found")
# Let's mount the update fs, and use that kernel version and modules
# We need this work to help dracut
isomnt = tempfile.mkdtemp("RootUpdate")
squashmnt = tempfile.mkdtemp("RootUpdate-LiveOS")
updfs = tempfile.mkdtemp("RootUpdate-LiveOS-Img")
mnts += [isomnt, squashmnt, updfs]
# Unpack the iso
def _call(args):
logger.debug("Calling: %s" % args)
try:
out = subprocess.check_output(args)
logger.debug("Out: %s" % out)
except Exception as e:
logger.debug("Failed with: %s %s" % (e, e.output))
raise
_call(["mount", "LABEL=RootUpdate", isomnt])
_call(["mount", "%s/LiveOS/squashfs.img" % isomnt, squashmnt])
_call(["mount", "%s/LiveOS/ext3fs.img" % squashmnt, updfs])
# Now mount the update modules into place, and find the
# correct kver
def rbind(path, updfs=updfs):
dst = updfs + "/" + path
logger.debug("Binding %r to %r" % (path, dst))
_call(["mount", "--make-rshared", "--rbind", "/" + path, dst])
return dst
for path in ["etc", "dev", "proc", "sys", "tmp", "run", "var/tmp"]:
mnts += [rbind(path)]
upd_kver = str(_functions.passthrough("ls -1 %s/lib/modules" % updfs)).strip()
if len(upd_kver.splitlines()) != 1:
# It would be very unusual to see more than one kver directory
# in /lib/modules, because our images just contain one kernel
raise RuntimeError("Found more than one kernel version")
# Update initramfs to pickup multipath wwids
# Let /boot point to the filesystem on the update candidate partition
builder = _system.Initramfs(dracut_chroot=updfs, boot_source=isomnt)
builder.rebuild(kver=upd_kver)
except Exception as e:
logger.debug("Failed to build initramfs: %s" % e, exc_info=True)
output = getattr(e, "output", "")
if output:
logger.debug("Output: %s" % output)
raise
finally:
# Clean up all eventual mounts
pass
# Disabled for now because akward things happen, we leave it to
# systemd to unnmount on reboot
# for mnt in reversed(mnts):
# d = _functions.passthrough("umount -fl %s" % mnt, logger.debug)
# logger.debug("Returned: %s" % d)
_functions.disable_firstboot()
if _functions.finish_install():
if _functions.is_firstboot():
_iscsi.iscsi_auto()
logger.info("Installation of %s Completed" % \
_functions.PRODUCT_SHORT)
if reboot is not None and reboot == "Y":
_system.async_reboot()
return True
else:
return False
def ovirt_boot_setup(self, reboot="N"):
self.generate_paths()
logger.info("Installing the image.")
if "OVIRT_ROOT_INSTALL" in OVIRT_VARS:
if OVIRT_VARS["OVIRT_ROOT_INSTALL"] == "n":
logger.info("Root Installation Not Required, Finished.")
return True
self.oldtitle=None
grub_config_file = None
_functions.mount_liveos()
if os.path.ismount("/liveos"):
if os.path.exists("/liveos/vmlinuz0") and os.path.exists("/liveos/initrd0.img"):
grub_config_file = self.grub_config_file
elif not _functions.is_firstboot():
# find existing iscsi install
if _functions.findfs("Boot"):
grub_config_file = "/boot/grub/grub.conf"
elif os.path.ismount("/dev/.initramfs/live"):
if not _functions.grub2_available():
grub_config_file = "/dev/.initramfs/live/grub/grub.conf"
else:
grub_config_file = "/dev/.initramfs/live/grub2/grub.cfg"
elif os.path.ismount("/run/initramfs/live"):
grub_config_file = "/run/initramfs/live/grub/grub.conf"
if _functions.is_upgrade() and not _functions.is_iscsi_install():
mount_liveos()
grub_config_file = "/liveos/grub/grub.conf"
if _functions.is_efi_boot():
logger.debug(str(os.listdir("/liveos")))
_functions.system("umount /liveos")
_functions.mount_efi(target="/liveos")
grub_config_file = "/liveos/EFI/%s/grub.cfg" % self.efi_dir_name
if _functions.is_iscsi_install():
grub_config_file = "/boot/grub/grub.conf"
grub_config_file_exists = grub_config_file is not None and os.path.exists(grub_config_file)
logger.debug("Grub config file is: %s" % grub_config_file)
logger.debug("Grub config file exists: %s" % grub_config_file_exists)
if not grub_config_file is None and os.path.exists(grub_config_file):
f=open(grub_config_file)
oldgrub=f.read()
f.close()
if _functions.grub2_available():
m=re.search("^menuentry (.*)$", oldgrub, re.MULTILINE)
else:
m=re.search("^title (.*)$", oldgrub, re.MULTILINE)
if m is not None:
self.oldtitle=m.group(1)
# strip off extra title characters
if _functions.grub2_available():
self.oldtitle = self.oldtitle.replace('"','').strip(" {")
_functions.system("umount /liveos/efi")
_functions.system("umount /liveos")
if _functions.is_iscsi_install():
self.boot_candidate = None
boot_candidate_names = ["BootBackup", "BootUpdate", "BootNew"]
for trial in range(1, 3):
time.sleep(1)
_functions.system("partprobe")
for candidate_name in boot_candidate_names:
if _functions.findfs(candidate_name):
self.boot_candidate = candidate_name
break
logger.debug("Trial %s to find candidate (%s)" % \
(trial, self.boot_candidate))
if self.boot_candidate:
logger.debug("Found candidate: %s" % self.boot_candidate)
break
if not self.boot_candidate:
logger.error("Unable to find boot partition")
label_debug = ''
for label in os.listdir("/dev/disk/by-label"):
label_debug += "%s\n" % label
label_debug += _functions.subprocess_closefds("blkid", \
shell=True, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT).stdout.read()
logger.debug(label_debug)
return False
else:
boot_candidate_dev = _functions.findfs(self.boot_candidate)
# prepare Root partition update
if self.boot_candidate != "BootNew":
e2label_cmd = "e2label \"%s\" BootNew" % boot_candidate_dev
logger.debug(e2label_cmd)
if not _functions.system(e2label_cmd):
logger.error("Failed to label new Boot partition")
return False
_functions.system("mount LABEL=%s /boot &>/dev/null" % self.boot_candidate)
if os.path.exists("/boot/ovirt"):
try:
f = open("/boot/ovirt", 'r')
for line in f:
try:
line = line.strip()
key, value = line.split("\"", 1)
key = key.strip("=")
key = key.strip()
value = value.strip("\"")
OVIRT_VARS[key] = value
except:
pass
f.close()
iscsiadm_cmd = (("iscsiadm -p %s:%s -m discovery -t " +
"sendtargets") % (
OVIRT_VARS["OVIRT_ISCSI_TARGET_IP"],
OVIRT_VARS["OVIRT_ISCSI_TARGET_PORT"]))
_functions.system(iscsiadm_cmd)
logger.info("Restarting iscsi service")
_functions.system("service iscsi restart")
except:
pass
candidate = None
candidate_names = ["RootBackup", "RootUpdate", "RootNew"]
for trial in range(1, 3):
time.sleep(1)
_functions.system("partprobe")
for candidate_name in candidate_names:
if _functions.findfs(candidate_name):
candidate = candidate_name
break
logger.debug("Trial %s to find candidate (%s)" % (trial,
candidate))
if candidate:
logger.debug("Found candidate: %s" % candidate)
break
if not candidate:
logger.error("Unable to find root partition")
label_debug = ''
for label in os.listdir("/dev/disk/by-label"):
label_debug += "%s\n" % label
label_debug += _functions.subprocess_closefds("blkid", shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT).stdout.read()
logger.debug(label_debug)
return False
try:
candidate_dev = self.disk = _functions.findfs(candidate)
logger.info(candidate_dev)
logger.info(self.disk)
# grub2 starts at part 1
self.partN = int(self.disk[-1:])
if not _functions.grub2_available():
self.partN = self.partN - 1
except:
logger.debug(traceback.format_exc())
return False
if self.disk is None or self.partN < 0:
logger.error("Failed to determine Root partition number")
return False
# prepare Root partition update
if candidate != "RootNew":
e2label_cmd = "e2label \"%s\" RootNew" % candidate_dev
logger.debug(e2label_cmd)
if not _functions.system(e2label_cmd):
logger.error("Failed to label new Root partition")
return False
mount_cmd = "mount \"%s\" /liveos" % candidate_dev
_functions.system(mount_cmd)
_functions.system("rm -rf /liveos/LiveOS")
_functions.system("mkdir -p /liveos/LiveOS")
_functions.mount_live()
if os.path.isdir(self.grub_dir):
shutil.rmtree(self.grub_dir)
if not os.path.exists(self.grub_dir):
os.makedirs(self.grub_dir)
if _functions.is_efi_boot():
logger.info("efi detected, installing efi configuration")
_functions.system("mkdir /liveos/efi")
_functions.mount_efi()
_functions.system("mkdir -p /liveos/efi/EFI/redhat")
_functions.system("cp /boot/efi/EFI/redhat/grub.efi " +
"/liveos/efi/EFI/redhat/grub.efi")
if not "/dev/mapper/" in self.disk:
efi_disk = self.disk[:-1]
else:
efi_disk = re.sub("p[1,2,3]$", "", self.disk)
# generate grub legacy config for efi partition
#remove existing efi entries
_functions.remove_efi_entry(self.efi_dir_name)
efi_mgr_cmd = ("efibootmgr -c -l '\\EFI\\%s\\grubx64.efi' " +
"-L '%s' -d %s -v") % (self.efi_dir_name, \
_functions.PRODUCT_SHORT, \
efi_disk)
logger.info(efi_mgr_cmd)
_functions.system(efi_mgr_cmd)
self.kernel_image_copy()
# reorder tty0 to allow both serial and phys console after installation
if _functions.is_iscsi_install():
self.root_param = "root=live:LABEL=Root"
self.bootparams = "netroot=iscsi:%s::%s::%s ip=br%s:dhcp bridge=br%s:%s " % (
OVIRT_VARS["OVIRT_ISCSI_TARGET_HOST"],
OVIRT_VARS["OVIRT_ISCSI_TARGET_PORT"],
OVIRT_VARS["OVIRT_ISCSI_TARGET_NAME"],
OVIRT_VARS["OVIRT_BOOTIF"],
OVIRT_VARS["OVIRT_BOOTIF"],
OVIRT_VARS["OVIRT_BOOTIF"])
else:
self.root_param = "root=live:LABEL=Root"
self.bootparams = "ro rootfstype=auto rootflags=ro "
self.bootparams += OVIRT_VARS["OVIRT_BOOTPARAMS"].replace(
"console=tty0", "")
if " " in self.disk or os.path.exists("/dev/cciss"):
# workaround for grub setup failing with spaces in dev.name:
# use first active sd* device
self.disk = re.sub("p[1,2,3]$", "", self.disk)
grub_disk_cmd = "multipath -l \"" + self.disk + \
"\" | awk '/ active / {print $3}' | head -n1"
logger.debug(grub_disk_cmd)
grub_disk = _functions.subprocess_closefds(grub_disk_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
self.disk = grub_disk.stdout.read().strip()
if "cciss" in self.disk:
self.disk = self.disk.replace("!", "/")
# flush to sync DM and blockdev, workaround from rhbz#623846#c14
sysfs = open("/proc/sys/vm/drop_caches", "w")
sysfs.write("3")
sysfs.close()
partprobe_cmd = "partprobe \"/dev/%s\"" % self.disk
logger.debug(partprobe_cmd)
_functions.system(partprobe_cmd)
if not self.disk.startswith("/dev/"):
self.disk = "/dev/" + self.disk
try:
if stat.S_ISBLK(os.stat(self.disk).st_mode):
try:
if stat.S_ISBLK(os.stat(self.disk[:-1]).st_mode):
# e.g. /dev/sda2
self.disk = self.disk[:-1]
except OSError:
pass
try:
if stat.S_ISBLK(os.stat(self.disk[:-2]).st_mode):
# e.g. /dev/mapper/WWIDp2
self.disk = self.disk[:-2]
except OSError:
pass
except OSError:
logger.error("Unable to determine disk for grub installation " +
traceback.format_exc())
return False
self.grub_dict = {
"product": _functions.PRODUCT_SHORT,
"version": _functions.PRODUCT_VERSION,
"release": _functions.PRODUCT_RELEASE,
"partN": self.partN,
"root_param": self.root_param,
"bootparams": self.bootparams,
"disk": self.disk,
"grub_dir": self.grub_dir,
"grub_prefix": self.grub_prefix,
"efi_hd": self.efi_hd
}
if not _functions.is_firstboot():
if os.path.ismount("/live"):
with open("/live/%s/version" % self.syslinux) as version:
for line in version.readlines():
if "VERSION" in line:
key, value = line.split("=")
self.grub_dict["version"] = value.strip()
if "RELEASE" in line:
key, value = line.split("=")
self.grub_dict["release"] = value.strip()
if _functions.grub2_available():
if not self.grub2_install():
logger.error("Grub2 Installation Failed ")
return False
else:
logger.info("Grub2 EFI Installation Completed ")
else:
if not self.grub_install():
logger.error("Grub Installation Failed ")
return False
else:
logger.info("Grub Installation Completed")
if _functions.is_iscsi_install():
# copy default for when Root/HostVG is inaccessible(iscsi upgrade)
shutil.copy(_functions.OVIRT_DEFAULTS, "/boot")
# mark new Root ready to go, reboot() in ovirt-function switches it
# to active
e2label_cmd = "e2label \"%s\" BootUpdate" % boot_candidate_dev
if not _functions.system(e2label_cmd):
logger.error("Unable to relabel " + boot_candidate_dev +
" to RootUpdate ")
return False
else:
_functions.system("umount /liveos/efi")
_functions.system("umount /liveos")
# mark new Root ready to go, reboot() in ovirt-function switches it
# to active
e2label_cmd = "e2label \"%s\" RootUpdate" % candidate_dev
if not _functions.system(e2label_cmd):
logger.error("Unable to relabel " + candidate_dev +
" to RootUpdate ")
return False
_functions.disable_firstboot()
if _functions.finish_install():
if _functions.is_firstboot():
_iscsi.iscsi_auto()
logger.info("Installation of %s Completed" % \
_functions.PRODUCT_SHORT)
if reboot is not None and reboot == "Y":
_system.async_reboot()
return True
else:
return False
def ovirt_boot_setup(self, reboot="N"):
self.generate_paths()
logger.info("Installing the image.")
# copy grub.efi to safe location
if _functions.is_efi_boot():
if "OVIRT_ISCSI_INSTALL" in OVIRT_VARS:
_functions.system("umount /boot")
if os.path.isfile("/boot/efi/EFI/%s/grubx64.efi" %
self.efi_dir_name):
shutil.copy("/boot/efi/EFI/%s/grubx64.efi" % self.efi_dir_name,
"/tmp")
else:
shutil.copy("/boot/efi/EFI/%s/grub.efi" % self.efi_dir_name,
"/tmp")
_functions.mount_boot()
if "OVIRT_ROOT_INSTALL" in OVIRT_VARS:
if OVIRT_VARS["OVIRT_ROOT_INSTALL"] == "n":
logger.info("Root Installation Not Required, Finished.")
return True
self.oldtitle=None
grub_config_file = None
if _functions.findfs("Boot") and _functions.is_upgrade():
grub_config_file = "/boot/grub/grub.conf"
if not _functions.connect_iscsi_root():
return False
_functions.mount_liveos()
if os.path.ismount("/liveos"):
if os.path.exists("/liveos/vmlinuz0") \
and os.path.exists("/liveos/initrd0.img"):
grub_config_file = self.grub_config_file
elif not _functions.is_firstboot():
# find existing iscsi install
if _functions.findfs("Boot"):
grub_config_file = "/boot/grub/grub.conf"
elif os.path.ismount("/dev/.initramfs/live"):
if not _functions.grub2_available():
grub_config_file = "/dev/.initramfs/live/grub/grub.conf"
else:
grub_config_file = "/dev/.initramfs/live/grub2/grub.cfg"
elif os.path.ismount("/run/initramfs/live"):
grub_config_file = "/run/initramfs/live/grub/grub.conf"
if _functions.is_upgrade() and not _functions.is_iscsi_install():
_functions.mount_liveos()
grub_config_file = "/liveos/grub/grub.conf"
if _functions.is_iscsi_install() or _functions.findfs("Boot") \
and not _functions.is_efi_boot():
grub_config_file = "/boot/grub/grub.conf"
if _functions.is_efi_boot():
logger.debug(str(os.listdir("/liveos")))
_functions.system("umount /liveos")
_functions.mount_efi(target="/liveos")
if self.efi_dir_name == "fedora":
grub_config_file = "/liveos/EFI/fedora/grub.cfg"
else:
grub_config_file = "/liveos/EFI/redhat/grub.conf"
grub_config_file_exists = grub_config_file is not None \
and os.path.exists(grub_config_file)
logger.debug("Grub config file is: %s" % grub_config_file)
logger.debug("Grub config file exists: %s" % grub_config_file_exists)
if not grub_config_file is None and os.path.exists(grub_config_file):
f=open(grub_config_file)
oldgrub=f.read()
f.close()
if _functions.grub2_available():
m=re.search("^menuentry (.*)$", oldgrub, re.MULTILINE)
else:
m=re.search("^title (.*)$", oldgrub, re.MULTILINE)
if m is not None:
self.oldtitle=m.group(1)
# strip off extra title characters
if _functions.grub2_available():
self.oldtitle = self.oldtitle.replace('"','').strip(" {")
_functions.system("umount /liveos/efi")
_functions.system("umount /liveos")
if _functions.is_iscsi_install() or _functions.findfs("Boot"):
self.boot_candidate = None
boot_candidate_names = ["BootBackup", "BootUpdate", "BootNew"]
for trial in range(1, 3):
time.sleep(1)
for candidate_name in boot_candidate_names:
logger.debug(os.listdir("/dev/disk/by-label"))
if _functions.findfs(candidate_name):
self.boot_candidate = candidate_name
break
logger.debug("Trial %s to find candidate (%s)" % \
(trial, candidate_name))
if self.boot_candidate:
logger.debug("Found candidate: %s" % self.boot_candidate)
break
if not self.boot_candidate:
logger.error("Unable to find boot partition")
label_debug = ''
for label in os.listdir("/dev/disk/by-label"):
label_debug += "%s\n" % label
label_debug += _functions.subprocess_closefds("blkid", \
shell=True, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT).stdout.read()
logger.debug(label_debug)
return False
else:
boot_candidate_dev = _functions.findfs(self.boot_candidate)
# prepare Root partition update
if self.boot_candidate != "BootNew":
e2label_cmd = "e2label \"%s\" BootNew" % boot_candidate_dev
logger.debug(e2label_cmd)
if not _functions.system(e2label_cmd):
logger.error("Failed to label new Boot partition")
return False
_functions.system("umount /boot")
_functions.system("mount %s /boot &>/dev/null" \
% boot_candidate_dev)
candidate = None
candidate_dev = None
candidate_names = ["RootBackup", "RootUpdate", "RootNew"]
for trial in range(1, 3):
time.sleep(1)
for candidate_name in candidate_names:
candidate_dev = _functions.findfs(candidate_name)
logger.debug("Finding %s: '%s'" % (candidate_name, candidate_dev))
if candidate_dev:
candidate = candidate_name
logger.debug("Found: %s" % candidate)
break
logger.debug("Trial %s to find candidate (%s)" % (trial,
candidate_name))
if candidate:
logger.debug("Found candidate: '%s'" % candidate)
break
if not candidate:
logger.error("Unable to find root partition")
label_debug = ''
for label in os.listdir("/dev/disk/by-label"):
label_debug += "%s\n" % label
label_debug += _functions.subprocess_closefds("blkid", shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT).stdout.read()
logger.debug(label_debug)
return False
try:
self.disk = candidate_dev
logger.info("Candidate device: %s" % candidate_dev)
logger.info("Candidate disk: %s" % self.disk)
# grub2 starts at part 1
self.partN = int(self.disk[-1:])
if not _functions.grub2_available():
self.partN = self.partN - 1
except:
logger.debug("Failed to get partition", exc_info=True)
return False
if self.disk is None or self.partN < 0:
logger.error("Failed to determine Root partition number")
return False
# prepare Root partition update
if candidate != "RootNew":
e2label_cmd = "e2label \"%s\" RootNew" % candidate_dev
logger.debug(e2label_cmd)
if not _functions.system(e2label_cmd):
logger.error("Failed to label new Root partition")
return False
mount_cmd = "mount \"%s\" /liveos" % candidate_dev
if not _functions.system(mount_cmd):
logger.error("Failed to mount %s on /liveos" % candidate_dev)
_functions.system("lsof")
_functions.system("dmsetup info -c")
_functions.system("cat /proc/mounts")
_functions.system("multipath -ll")
_functions.system("lsblk")
_functions.system("ls -l /dev/mapper")
_functions.system("rm -rf /liveos/LiveOS")
_functions.system("mkdir -p /liveos/LiveOS")
_functions.mount_live()
if os.path.isdir(self.grub_dir):
shutil.rmtree(self.grub_dir)
if not os.path.exists(self.grub_dir):
os.makedirs(self.grub_dir)
if _functions.is_efi_boot():
logger.info("efi detected, installing efi configuration")
_functions.system("mkdir /liveos/efi")
_functions.mount_efi()
_functions.system("mkdir -p /liveos/efi/EFI/redhat")
if _functions.is_iscsi_install() or _functions.is_efi_boot():
if os.path.isfile("/tmp/grubx64.efi"):
shutil.copy("/tmp/grubx64.efi",
"/liveos/efi/EFI/redhat/grubx64.efi")
else:
shutil.copy("/tmp/grub.efi",
"/liveos/efi/EFI/redhat/grub.efi")
elif os.path.isfile("/boot/efi/EFI/redhat/grubx64.efi"):
shutil.copy("/boot/efi/EFI/redhat/grubx64.efi",
"/liveos/efi/EFI/redhat/grubx64.efi")
else:
shutil.copy("/boot/efi/EFI/redhat/grub.efi",
"/liveos/efi/EFI/redhat/grub.efi")
if _functions.is_iscsi_install() or _functions.findfs("BootNew"):
self.disk = _functions.findfs("BootNew")
if not "/dev/mapper/" in self.disk:
efi_disk = self.disk[:-1]
else:
efi_disk = re.sub(r'p?[1,2,3]$', "", self.disk)
# generate grub legacy config for efi partition
#remove existing efi entries
_functions.remove_efi_entry(_functions.PRODUCT_SHORT)
if self.efi_dir_name == "fedora":
_functions.add_efi_entry(_functions.PRODUCT_SHORT,
("\\EFI\\%s\\grubx64.efi" %
self.efi_dir_name),
efi_disk)
else:
if os.path.isfile("/liveos/efi/EFI/redhat/grubx64.efi"):
_functions.add_efi_entry(_functions.PRODUCT_SHORT,
("\\EFI\\%s\\grubx64.efi" %
self.efi_dir_name),
efi_disk)
else:
_functions.add_efi_entry(_functions.PRODUCT_SHORT,
("\\EFI\\%s\\grub.efi" %
self.efi_dir_name),
efi_disk)
self.kernel_image_copy()
# reorder tty0 to allow both serial and phys console after installation
if _functions.is_iscsi_install() or _functions.findfs("BootNew"):
self.root_param = "root=live:LABEL=Root"
if "OVIRT_NETWORK_LAYOUT" in OVIRT_VARS and \
OVIRT_VARS["OVIRT_NETWORK_LAYOUT"] == "bridged":
network_conf = "ip=br%s:dhcp bridge=br%s:%s" % \
(OVIRT_VARS["OVIRT_BOOTIF"],
OVIRT_VARS["OVIRT_BOOTIF"],
OVIRT_VARS["OVIRT_BOOTIF"])
else:
network_conf = "ip=%s:dhcp" % OVIRT_VARS["OVIRT_BOOTIF"]
self.bootparams = "netroot=iscsi:%s::%s::%s %s " % (
OVIRT_VARS["OVIRT_ISCSI_TARGET_HOST"],
OVIRT_VARS["OVIRT_ISCSI_TARGET_PORT"],
OVIRT_VARS["OVIRT_ISCSI_TARGET_NAME"],
network_conf)
if "OVIRT_ISCSI_NAME" in OVIRT_VARS:
self.bootparams+= "iscsi_initiator=%s " % \
OVIRT_VARS["OVIRT_ISCSI_NAME"]
else:
self.root_param = "root=live:LABEL=Root"
self.bootparams = "ro rootfstype=auto rootflags=ro "
self.bootparams += OVIRT_VARS["OVIRT_BOOTPARAMS"].replace(
"console=tty0", ""
).replace(
"rd_NO_MULTIPATH",
"")
is_mpath_root = self.disk and self.disk.startswith("/dev/mapper")
has_mpath_wwid = "mpath.wwid=" in self.bootparams
if is_mpath_root and not has_mpath_wwid:
"""We need to specify the wwid of the root device if it
is using multiple paths to prevent races within dracut.
Basically there are two options:
1. bake wwid of root device into initrd
2. pass wwid of root device on kernel cmdline
I choose 2 because it seems to be less invasive.
https://bugzilla.redhat.com/show_bug.cgi?id=1152948
"""
lsblkcmd = "lsblk -inls %s | awk 'FNR==2 {print $1}'" % self.disk
lsblkproc = _functions.subprocess_closefds(lsblkcmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
lsblkout, lsblkerr = lsblkproc.communicate()
logger.debug("lsblk returned: %s -- %s" % (lsblkout, lsblkerr))
if not lsblkout.strip():
raise RuntimeError("Failed to determin parent of partition: %s" % self.disk)
part_parent = "/dev/mapper/" + lsblkout.strip()
logger.debug("lsblk found parent for partition %s: %s" % (self.disk, part_parent))
wwidcmd = "multipath -ll %s | egrep -o '^.*dm-[0-9]' | cut -d' ' -f1" % part_parent
logger.debug("Checking device for multipath: %s" % wwidcmd)
wwidproc = _functions.subprocess_closefds(wwidcmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
wwidout, wwiderr = wwidproc.communicate()
logger.debug("multipath returned: %s -- %s" % (wwidout, wwiderr))
wwid = wwidout.strip()
if wwid:
logger.debug("Using multipath wwid: %s" % wwid)
self.bootparams += " mpath.wwid=%s" % wwid
logger.debug("Cmdline with mpath: %s" % self.bootparams)
else:
logger.debug("Got NO multipath wwid, not using any")
if " " in self.disk:
# workaround for grub setup failing with spaces in dev.name:
# use first active sd* device
self.disk = re.sub("p[1,2,3]$", "", self.disk)
grub_disk_cmd = ("multipath -l " +
"\"" + self.disk + "\" " +
"| egrep -o '[0-9]+:.*' " +
"| awk '/ active / {print $2}' " +
"| head -n1")
logger.debug(grub_disk_cmd)
grub_disk = _functions.subprocess_closefds(grub_disk_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
grub_disk_output, grub_disk_err = grub_disk.communicate()
self.disk = grub_disk_output.strip()
if "cciss" in self.disk:
self.disk = self.disk.replace("!", "/")
# flush to sync DM and blockdev, workaround from rhbz#623846#c14
sysfs = open("/proc/sys/vm/drop_caches", "w")
sysfs.write("3")
sysfs.close()
if not self.disk.startswith("/dev/"):
self.disk = "/dev/" + self.disk
try:
if stat.S_ISBLK(os.stat(self.disk).st_mode):
try:
if stat.S_ISBLK(os.stat(self.disk[:-1]).st_mode):
# e.g. /dev/sda2
self.disk = self.disk[:-1]
except OSError:
pass
try:
if stat.S_ISBLK(os.stat(self.disk[:-2]).st_mode):
# e.g. /dev/mapper/WWIDp2
self.disk = self.disk[:-2]
except OSError:
pass
except OSError:
logger.error("Unable to determine disk for grub installation " +
traceback.format_exc())
return False
self.grub_dict = {
"product": _functions.PRODUCT_SHORT,
"version": _functions.PRODUCT_VERSION,
"release": _functions.PRODUCT_RELEASE,
"partN": self.partN,
"root_param": self.root_param,
"bootparams": self.bootparams,
"disk": self.disk,
"grub_dir": self.grub_dir,
"grub_prefix": self.grub_prefix,
"efi_hd": self.efi_hd,
"linux": "linux",
"initrd": "initrd",
}
if not _functions.is_firstboot():
if os.path.ismount("/live"):
with open("%s/version" % self.live_path) as version:
for line in version.readlines():
if "VERSION" in line:
key, value = line.split("=")
self.grub_dict["version"] = value.strip()
if "RELEASE" in line:
key, value = line.split("=")
self.grub_dict["release"] = value.strip()
if _functions.grub2_available():
if not self.grub2_install():
logger.error("Grub2 Installation Failed ")
return False
else:
logger.info("Grub2 EFI Installation Completed ")
else:
if not self.grub_install():
logger.error("Grub Installation Failed ")
return False
else:
logger.info("Grub Installation Completed")
if _functions.is_iscsi_install() or _functions.findfs("BootNew"):
# copy default for when Root/HostVG is inaccessible(iscsi upgrade)
shutil.copy(_functions.OVIRT_DEFAULTS, "/boot")
# mark new Boot ready to go, reboot() in ovirt-function switches it
# to active
e2label_cmd = "e2label \"%s\" BootUpdate" % boot_candidate_dev
if not _functions.system(e2label_cmd):
logger.error("Unable to relabel " + boot_candidate_dev +
" to RootUpdate ")
return False
else:
_functions.system("umount /liveos/efi")
_functions.system("umount /liveos")
# mark new Root ready to go, reboot() in ovirt-function switches it
# to active
e2label_cmd = "e2label \"%s\" RootUpdate" % candidate_dev
if not _functions.system(e2label_cmd):
logger.error("Unable to relabel " + candidate_dev +
" to RootUpdate ")
return False
_functions.disable_firstboot()
if _functions.finish_install():
if _functions.is_firstboot():
_iscsi.iscsi_auto()
logger.info("Installation of %s Completed" % \
_functions.PRODUCT_SHORT)
if reboot is not None and reboot == "Y":
_system.async_reboot()
return True
else:
return False
def grub2_install(self):
GRUB2_EFI_CONFIG_TEMPLATE = """
insmod efi_gop
insmod efi_uga
"""
GRUB2_CONFIG_TEMPLATE = """
#default saved
set timeout=5
#hiddenmenu
menuentry "%(product)s %(version)s-%(release)s" {
set root=(hd0,%(partN)d)
linux /vmlinuz0 %(root_param)s %(bootparams)s
initrd /initrd0.img
}"""
GRUB2_BACKUP_TEMPLATE = """
menuentry "BACKUP %(oldtitle)s" {
set root (hd0,%(partB)d)
linux /vmlinuz0 root=live:LABEL=RootBackup %(bootparams)s
initrd /initrd0.img
"""
# if efi is detected only install grub-efi
if not _functions.is_efi_boot():
logger.info("efi not detected, installing grub2 configuraton")
if _functions.is_iscsi_install():
disk = re.sub("p[1,2,3]$", "", \
_functions.findfs(self.boot_candidate))
else:
disk = self.disk
grub_setup_cmd = ("/sbin/grub2-install " + disk +
" --boot-directory=" + self.initrd_dest +
" --force")
logger.info(grub_setup_cmd)
grub_setup = _functions.subprocess_closefds(grub_setup_cmd, \
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
grub_results = grub_setup.stdout.read()
logger.info(grub_results)
if grub_setup.wait() != 0 or "Error" in grub_results:
logger.error("GRUB efi setup failed")
return False
else:
logger.debug("Generating Grub2 Templates")
grub_conf = open(self.grub_config_file, "w")
grub_conf.write(GRUB2_CONFIG_TEMPLATE % self.grub_dict)
if self.oldtitle is not None:
partB = 0
if self.partN == 0:
partB = 1
self.grub_dict['oldtitle'] = self.oldtitle
self.grub_dict['partB'] = partB
grub_conf.write(GRUB2_BACKUP_TEMPLATE % self.grub_dict)
grub_conf.close()
if os.path.exists("/liveos/efi"):
efi_grub_conf = open("/liveos/grub2-efi/grub.cfg", "w")
# inject efi console output modules
efi_grub_conf.write(GRUB2_EFI_CONFIG_TEMPLATE)
efi_grub_conf.write(GRUB2_CONFIG_TEMPLATE % self.grub_dict)
if self.oldtitle is not None:
partB = 0
if self.partN == 0:
partB = 1
self.grub_dict['oldtitle'] = self.oldtitle
self.grub_dict['partB'] = partB
efi_grub_conf.write(GRUB2_BACKUP_TEMPLATE % self.grub_dict)
efi_grub_conf.close()
_functions.system("umount /liveos/efi")
logger.info("Grub2 Install Completed")
return True
def grub2_install(self):
GRUB2_EFI_CONFIG_TEMPLATE = """
insmod efi_gop
insmod efi_uga
"""
GRUB2_CONFIG_TEMPLATE = """
#default saved
set timeout=5
#hiddenmenu
menuentry "%(product)s %(version)s-%(release)s" {
set root=(hd0,%(partN)d)
search --no-floppy --label Root --set root
linux /vmlinuz0 %(root_param)s %(bootparams)s
initrd /initrd0.img
}"""
GRUB2_BACKUP_TEMPLATE = """
menuentry "BACKUP %(oldtitle)s" {
set root (hd0,%(partB)d)
search --no-floppy --label RootBackup --set root
linux /vmlinuz0 root=live:LABEL=RootBackup %(bootparams)s
initrd /initrd0.img
} """
if _functions.is_iscsi_install():
disk = re.sub("p[1,2,3]$", "", \
_functions.findfs("BootNew"))
self.grub_dict["partN"] = int(_functions.findfs("BootNew")[-1:])
else:
disk = self.disk
if _functions.is_efi_boot():
boot_dir = self.initrd_dest + "/efi"
else:
boot_dir = self.initrd_dest
grub_setup_cmd = ("/sbin/grub2-install " + disk +
" --boot-directory=" + boot_dir +
" --root-directory=" + boot_dir +
" --efi-directory=" + boot_dir +
" --bootloader-id=" + self.efi_dir_name +
" --force")
_functions.system("echo '%s' >> /liveos/efi/cmd" % grub_setup_cmd)
logger.info(grub_setup_cmd)
grub_setup = _functions.subprocess_closefds(grub_setup_cmd, \
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
grub_results = grub_setup.stdout.read()
logger.info(grub_results)
if grub_setup.wait() != 0 or "Error" in grub_results:
logger.error("grub2-install Failed")
return False
else:
logger.debug("Generating Grub2 Templates")
if _functions.is_efi_boot():
if not os.path.exists("/liveos/efi/EFI/%s" % self.efi_dir_name):
os.makedirs("/liveos/efi/EFI/%s" % self.efi_dir_name)
grub_conf = open(self.grub_config_file, "w")
grub_conf.write(GRUB2_CONFIG_TEMPLATE % self.grub_dict)
if self.oldtitle is not None:
partB = 0
if self.partN == 0:
partB = 1
self.grub_dict['oldtitle'] = self.oldtitle
self.grub_dict['partB'] = partB
grub_conf.write(GRUB2_BACKUP_TEMPLATE % self.grub_dict)
grub_conf.close()
if os.path.exists("/liveos/efi/EFI"):
efi_grub_conf = open("/liveos/efi/EFI/%s/grub.cfg" \
% self.efi_dir_name, "w")
# inject efi console output modules
efi_grub_conf.write(GRUB2_EFI_CONFIG_TEMPLATE)
efi_grub_conf.write(GRUB2_CONFIG_TEMPLATE % self.grub_dict)
if self.oldtitle is not None:
partB = 0
if self.partN == 0:
partB = 1
self.grub_dict['oldtitle'] = self.oldtitle
self.grub_dict['partB'] = partB
efi_grub_conf.write(GRUB2_BACKUP_TEMPLATE % self.grub_dict)
efi_grub_conf.close()
_functions.system("umount /liveos")
_functions.remove_efi_entry(self.efi_dir_name)
logger.info("Grub2 Install Completed")
return True
return True
def save_network_configuration(self):
_functions.aug.load()
net_configured = 0
_functions.augtool_workdir_list = "ls %s/augtool-* >/dev/null"
logger.info("Configuring network for NIC %s" % self.CONFIGURED_NIC)
# Wee need to bring down all network stuff, with the current network
# config, before we change the config. Otherwise the interfaces can
# not be brought down correctly.
logger.info("Stopping Network services")
_functions.system("service network stop")
# FIXME can't this be done further down were we remove the bridges?
for vlan in get_system_vlans():
# XXX wrong match e.g. eth10.1 with eth1
if self.CONFIGURED_NIC in vlan:
_functions.system_closefds("vconfig rem " + vlan + \
"&> /dev/null")
_functions.ovirt_safe_delete_config(self.IFSCRIPTS_PATH + vlan)
_functions.system_closefds("rm -rf " + \
self.IFSCRIPTS_PATH + vlan)
# All old config files are gone, the new ones are created step by step
logger.debug("Removing persisted network configs")
# This should cover NICs, VLANs and bridges
for script in glob("%s*" % (self.IFSCRIPTS_PATH)):
if not _functions.is_persisted(script):
continue
logger.debug("Removing Script: " + script)
_functions.ovirt_safe_delete_config(script)
_functions.aug.load()
logger.debug("Updating interface config")
for line in self.IF_CONFIG:
logger.debug(line)
try:
oper, key, value = line.split()
_functions.augtool(oper, key, value)
except:
oper, key = line.split()
_functions.augtool(oper, key, "")
logger.debug("Updating bridge config")
if not self.disabled_nic == 1:
for line in self.BR_CONFIG:
logger.debug(line)
try:
oper, key, value = line.split()
_functions.augtool(oper, key, value)
except:
try:
oper, key = line.split()
_functions.augtool(oper, key, "")
except:
pass
logger.debug("Updating VLAN config")
for line in self.VL_CONFIG.split("\n"):
logger.debug(line)
try:
oper, key, value = line.split()
_functions.augtool(oper, key, value)
except:
try:
oper, key = line.split()
_functions.augtool(oper, key, "")
except:
pass
# preserve current MAC mappings for *all physical* network interfaces
logger.debug("Preserving current MAC mappings")
for nicdev in glob('/sys/class/net/*/device'):
nic = nicdev.split('/')[4]
if nic != self.CONFIGURED_NIC:
f = open('/sys/class/net/%s/address' % nic)
mac = f.read().strip()
f.close()
if len(mac) > 0:
logger.debug("Mapping for %s" % nic)
self.CONFIGURED_NICS.append(nic)
nicroot = "%s%s" % (self.IFCONFIG_FILE_ROOT, nic)
# XXX _functions.augtool does save every time!
_functions.augtool("set", "%s/DEVICE" % nicroot, nic)
_functions.augtool("set", "%s/HWADDR" % nicroot, mac)
_functions.augtool("set", "%s/ONBOOT" % nicroot, "no")
logger.debug("Storing configured NICs")
net_configured = 1
for nic in self.CONFIGURED_NICS:
logger.debug("Storing %s" % nic)
_functions.ovirt_store_config("%s%s" % (self.IFSCRIPTS_PATH, nic))
_functions.ovirt_store_config(self.NTP_CONFIG_FILE)
if self.disabled_nic == 1:
_functions.augtool("set", \
"/files/etc/sysconfig/network/NETWORKING", "no")
else:
_functions.augtool("set", \
"/files/etc/sysconfig/network/NETWORKING", "yes")
_functions.ovirt_store_config("/etc/sysconfig/network")
_functions.ovirt_store_config("/etc/hosts")
# Copy the initial net rules to a file that get's not
# overwritten at each boot, rhbz#773495
rulesfile = "/etc/udev/rules.d/70-persistent-net.rules"
newrulesfile = "/etc/udev/rules.d/71-persistent-node-net.rules"
if os.path.exists(rulesfile):
_functions.system_closefds("cp %s %s >> /var/log/ovirt.log" % (
rulesfile,
newrulesfile))
_functions.ovirt_store_config(newrulesfile)
# Eventully it makes sense to rename the NICs
#system_closefds("sed -ic 's/NAME=\"eth/NAME=\"eth00/' " +
# "/etc/udev/rules.d/71-persistent-node-net.rules")
logger.info("Network configured successfully")
if net_configured == 1:
logger.info("Stopping Network services")
_functions.system_closefds("service network stop &> /dev/null")
_functions.system_closefds("service ntpd stop &> /dev/null")
# XXX eth assumed in breth
brctl_cmd = "ip --details --oneline link " \
"| awk -F':' '/^[0-9]: br[ep]/ {print $2}'"
brctl = _functions.subprocess_closefds(brctl_cmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
brctl_output = brctl.stdout.read()
for i in brctl_output.split():
if_down_cmd = "ifconfig %s down &> /dev/null" % i
_functions.system_closefds(if_down_cmd)
del_br_cmd = "ip link delete %s type bridge &> /dev/null" % i
_functions.system_closefds(del_br_cmd)
logger.info("Starting Network service")
_functions.system_closefds("service network start &> /dev/null")
_functions.system_closefds("service ntpdate start &> /dev/null")
_functions.system_closefds("service ntpd start &> /dev/null")
# rhbz#745541
_functions.system_closefds("service rpcbind start &> /dev/null")
_functions.system_closefds("service nfslock start &> /dev/null")
_functions.system_closefds("service rpcidmapd start &> /dev/null")
_functions.system_closefds("service rpcgssd start &> /dev/null")
if "NTP" in OVIRT_VARS:
logger.info("Testing NTP Configuration")
_functions.test_ntp_configuration()
def grub_install(self):
if _functions.is_iscsi_install():
self.disk = re.sub("p[1,2,3]$", "", _functions.findfs(self.boot_candidate))
device_map = "(hd0) %s" % self.disk
logger.debug(device_map)
device_map_conf = open(self.grub_dir + "/device.map", "w")
device_map_conf.write(device_map)
device_map_conf.close()
GRUB_CONFIG_TEMPLATE = """
default saved
timeout 5
hiddenmenu
%(splashscreen)s
title %(product)s %(version)s-%(release)s
root (hd0,%(partN)d)
kernel /vmlinuz0 %(root_param)s %(bootparams)s
initrd /initrd0.img
"""
GRUB_BACKUP_TEMPLATE = """
title BACKUP %(oldtitle)s
root (hd0,%(partB)d)
kernel /vmlinuz0 root=live:LABEL=RootBackup %(bootparams)s
initrd /initrd0.img
savedefault
"""
GRUB_SETUP_TEMPLATE = """
grub --device-map=%(grub_dir)s/device.map <<EOF
root (hd0,%(partN)d)
setup --prefix=%(grub_prefix)s (hd0)
EOF
"""
if _functions.is_efi_boot():
""" The EFI product path.
eg: HD(1,800,64000,faacb4ef-e361-455e-bd97-ca33632550c3)
"""
efi_cmd = "efibootmgr -v"
efi = _functions.subprocess_closefds(efi_cmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
efi_out = efi.stdout.read().strip()
matches = re.search(_functions.PRODUCT_SHORT + r'\s+(HD\(.+?\))', \
efi_out)
if matches and matches.groups():
GRUB_EFIONLY_CONFIG = """%(efi_hd)s"""
GRUB_CONFIG_TEMPLATE = GRUB_EFIONLY_CONFIG + GRUB_CONFIG_TEMPLATE
self.grub_dict['efi_hd'] = "device (hd0) " + matches.group(1)
if os.path.exists("/live/EFI/BOOT/splash.xpm.gz"):
splashscreen = "splashimage=(hd0,%s)/grub/splash.xpm.gz" \
% self.partN
else:
splashscreen = ""
self.grub_dict["splashscreen"] = splashscreen
GRUB_CONFIG_TEMPLATE % self.grub_dict
grub_conf = open(self.grub_config_file, "w")
grub_conf.write(GRUB_CONFIG_TEMPLATE % self.grub_dict)
if self.oldtitle is not None:
partB = 1
if self.partN == 1:
partB = 2
if _functions.is_iscsi_install():
partB = 0
if self.partN == 0:
partB = 1
self.grub_dict['oldtitle'] = self.oldtitle
self.grub_dict['partB'] = partB
grub_conf.write(GRUB_BACKUP_TEMPLATE % self.grub_dict)
grub_conf.close()
# splashscreen
_functions.system("cp /live/EFI/BOOT/splash.xpm.gz /liveos/grub")
# usb devices requires default BOOTX64 entries
if _functions.is_efi_boot():
_functions.system("mkdir -p /liveos/efi/EFI/BOOT")
_functions.system("cp /boot/efi/EFI/redhat/grub.efi /liveos/efi/EFI/BOOT/BOOTX64.efi")
_functions.system("cp %s /liveos/efi/EFI/BOOT/BOOTX64.conf" % self.grub_config_file)
_functions.system("umount /liveos/efi")
if not _functions.is_efi_boot():
for f in ["stage1", "stage2", "e2fs_stage1_5"]:
_functions.system("cp /usr/share/grub/x86_64-redhat/%s %s" % \
(f, self.grub_dir))
grub_setup_out = GRUB_SETUP_TEMPLATE % self.grub_dict
logger.debug(grub_setup_out)
grub_setup = _functions.subprocess_closefds(grub_setup_out,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
grub_results = grub_setup.stdout.read()
logger.debug(grub_results)
if grub_setup.wait() != 0 or "Error" in grub_results:
logger.error("GRUB setup failed")
return False
return True
def get_system_nics():
client = _functions.gudev.Client(['net'])
configured_nics = 0
ntp_dhcp = 0
nic_dict = {}
for device in client.query_by_subsystem("net"):
try:
dev_interface = device.get_property("INTERFACE")
dev_vendor = device.get_property("ID_VENDOR_FROM_DATABASE")
dev_type = device.get_property("DEVTYPE")
dev_path = device.get_property("DEVPATH")
try:
dev_vendor = dev_vendor.replace(",", "")
except AttributeError:
try:
# rhevh workaround since udev version
# doesn't have vendor info
dev_path = dev_path.split('/')
if "virtio" in dev_path[4]:
pci_dev = dev_path[3].replace("0000:", "")
else:
pci_dev = dev_path[4].replace("0000:", "")
pci_lookup_cmd = ((" lspci|grep %s|awk -F \":\" " +
"{'print $3'}" % pci_dev))
pci_lookup = _functions.subprocess_closefds(pci_lookup_cmd,
shell=True, stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
dev_vendor = pci_lookup.stdout.read().strip()
except:
dev_vendor = "unknown"
try:
dev_vendor = dev_vendor.replace(",", "")
except AttributeError:
dev_vendor = "unknown"
dev_vendor = _functions.pad_or_trim(25, dev_vendor)
try:
dev_driver = os.readlink("/sys/class/net/" + dev_interface + \
"/device/driver")
dev_driver = os.path.basename(dev_driver)
except:
pass
nic_addr_file = open("/sys/class/net/" + dev_interface + \
"/address")
dev_address = nic_addr_file.read().strip()
cmd = ("/files/etc/sysconfig/network-scripts/" + \
"ifcfg-%s/BOOTPROTO") % str(dev_interface)
dev_bootproto = _functions.augtool_get(cmd)
type_cmd = ("/files/etc/sysconfig/network-scripts/" + \
"ifcfg-%s/TYPE") % str(dev_interface)
bridge_cmd = ("/files/etc/sysconfig/network-scripts/" + \
"ifcfg-%s/BRIDGE") % str(dev_interface)
dev_bridge = _functions.augtool_get(bridge_cmd)
if dev_bootproto is None:
cmd = ("/files/etc/sysconfig/network-scripts/" + \
"ifcfg-%s/BOOTPROTO") % str(dev_bridge)
dev_bootproto = _functions.augtool_get(cmd)
if dev_bootproto is None:
dev_bootproto = "Disabled"
dev_conf_status = "Unconfigured"
# check for vlans
logger.debug("checking for vlan")
if (len(glob("/etc/sysconfig/network-scripts/ifcfg-" + \
dev_interface + ".*")) > 0):
logger.debug("found vlan")
dev_conf_status = "Configured "
else:
dev_conf_status = "Configured "
else:
dev_conf_status = "Configured "
if dev_conf_status == "Configured ":
configured_nics = configured_nics + 1
except:
pass
if (not dev_interface == "lo" and \
not dev_interface.startswith("bond") and \
not dev_interface.startswith("sit") and \
not "." in dev_interface):
if not dev_type == "bridge":
nic_dict[dev_interface] = "%s,%s,%s,%s,%s,%s,%s" % ( \
dev_interface, dev_bootproto, \
dev_vendor, dev_address, \
dev_driver, dev_conf_status, \
dev_bridge)
if dev_bootproto == "dhcp":
ntp_dhcp = 1
return nic_dict, configured_nics, ntp_dhcp
