From: Thierry Parmentelat Date: Tue, 28 Apr 2015 00:15:48 +0000 (+0200) Subject: no real change, just made prettier with a more standard layout - half of steps X-Git-Tag: bootmanager-5.3-1~27 X-Git-Url: http://git.onelab.eu/?p=bootmanager.git;a=commitdiff_plain;h=f52080486db907ba6557d1047730c638c4562790 no real change, just made prettier with a more standard layout - half of steps --- diff --git a/source/steps/AnsibleHook.py b/source/steps/AnsibleHook.py index 5275e72..ecbac91 100644 --- a/source/steps/AnsibleHook.py +++ b/source/steps/AnsibleHook.py @@ -10,16 +10,16 @@ import systeminfo def run_ansible(ansible_path, ansible_hash, playbook_name, log): try: if (ansible_hash): - hash_arg = '-U %s'%ansible_hash + hash_arg = '-U {}'.format(ansible_hash) else: hash_arg = '' - utils.sysexec_noerr('ansible-pull -i hosts %s %s %s' % (ansible_path, hash_arg, playbook_name), log ) + utils.sysexec_noerr('ansible-pull -i hosts {} {} {}'.format(ansible_path, hash_arg, playbook_name), log ) except: pass -def Run( vars, log ): - log.write( "\n\nStep: Running Ansible Hook\n" ) +def Run(vars, log): + log.write("\n\nStep: Running Ansible Hook\n") # make sure we have the variables we need try: ansible_path = vars["ANSIBLE_PATH"] @@ -30,7 +30,7 @@ def Run( vars, log ): ansible_hash = None if (ansible_path): - run_ansible(ansible_path, ansible_hash, "%s.yml"%run_level, log) - except KeyError, var: - log.write( "No Ansible directive. Skipping.\n"); + run_ansible(ansible_path, ansible_hash, "{}.yml".format(run_level), log) + except KeyError as var: + log.write("No Ansible directive. Skipping.\n"); pass diff --git a/source/steps/AuthenticateWithPLC.py b/source/steps/AuthenticateWithPLC.py index 72d5ec2..2e71a1c 100644 --- a/source/steps/AuthenticateWithPLC.py +++ b/source/steps/AuthenticateWithPLC.py @@ -13,10 +13,10 @@ from Exceptions import * import BootAPI -AUTH_FAILURE_COUNT_FILE= "/tmp/authfailurecount" +AUTH_FAILURE_COUNT_FILE = "/tmp/authfailurecount" -def Run( vars, log ): +def Run(vars, log): """ Authenticate this node with PLC. This ensures that the node can operate as normal, and that our management authority has authorized it. @@ -33,41 +33,41 @@ def Run( vars, log ): NUM_AUTH_FAILURES_BEFORE_DEBUG How many failures before debug """ - log.write( "\n\nStep: Authenticating node with PLC.\n" ) + log.write("\n\nStep: Authenticating node with PLC.\n") # make sure we have the variables we need try: - NUM_AUTH_FAILURES_BEFORE_DEBUG= int(vars["NUM_AUTH_FAILURES_BEFORE_DEBUG"]) - except KeyError, var: - raise BootManagerException, "Missing variable in vars: %s\n" % var - except ValueError, var: - raise BootManagerException, "Variable in vars, shouldn't be: %s\n" % var + NUM_AUTH_FAILURES_BEFORE_DEBUG = int(vars["NUM_AUTH_FAILURES_BEFORE_DEBUG"]) + except KeyError as var: + raise BootManagerException("Missing variable in vars: {}\n".format(var)) + except ValueError as var: + raise BootManagerException("Variable in vars, shouldn't be: {}\n".format(var)) try: - authorized= BootAPI.call_api_function( vars, "BootCheckAuthentication", () ) + authorized = BootAPI.call_api_function(vars, "BootCheckAuthentication", ()) if authorized == 1: - log.write( "Authentication successful.\n" ) + log.write("Authentication successful.\n") try: - os.unlink( AUTH_FAILURE_COUNT_FILE ) - except OSError, e: + os.unlink(AUTH_FAILURE_COUNT_FILE) + except OSError as e: pass return 1 - except BootManagerException, e: - log.write( "Authentication failed: %s.\n" % e ) + except BootManagerException as e: + log.write("Authentication failed: {}.\n".format(e)) except: # This is ugly. if vars['DISCONNECTED_OPERATION']: - vars['API_SERVER_INST']= None + vars['API_SERVER_INST'] = None return 1 else: raise # increment auth failure - auth_failure_count= 0 + auth_failure_count = 0 try: - auth_failure_count= int(file(AUTH_FAILURE_COUNT_FILE,"r").read().strip()) + auth_failure_count = int(file(AUTH_FAILURE_COUNT_FILE, "r").read().strip()) except IOError: pass except ValueError: @@ -76,16 +76,16 @@ def Run( vars, log ): auth_failure_count += 1 try: - fail_file= file(AUTH_FAILURE_COUNT_FILE,"w") - fail_file.write( str(auth_failure_count) ) + fail_file = file(AUTH_FAILURE_COUNT_FILE, "w") + fail_file.write(str(auth_failure_count)) fail_file.close() except IOError: pass if auth_failure_count >= NUM_AUTH_FAILURES_BEFORE_DEBUG: - log.write( "Maximum number of authentication failures reached.\n" ) - log.write( "Canceling boot process and going into debug mode.\n" ) + log.write("Maximum number of authentication failures reached.\n") + log.write("Canceling boot process and going into debug mode.\n") - raise BootManagerException, "Unable to authenticate node." + raise BootManagerException("Unable to authenticate node.") diff --git a/source/steps/ChainBootNode.py b/source/steps/ChainBootNode.py index 6ea6213..8eac1d1 100644 --- a/source/steps/ChainBootNode.py +++ b/source/steps/ChainBootNode.py @@ -23,7 +23,7 @@ import UpdateNodeConfiguration import StopRunlevelAgent import MakeInitrd -def Run( vars, log ): +def Run(vars, log): """ Load the kernel off of a node and boot to it. This step assumes the disks are mounted on SYSIMG_PATH. @@ -42,112 +42,112 @@ def Run( vars, log ): ROOT_MOUNTED the node root file system is mounted """ - log.write( "\n\nStep: Chain booting node.\n" ) + log.write("\n\nStep: Chain booting node.\n") # make sure we have the variables we need try: - SYSIMG_PATH= vars["SYSIMG_PATH"] + SYSIMG_PATH = vars["SYSIMG_PATH"] if SYSIMG_PATH == "": - raise ValueError, "SYSIMG_PATH" + raise ValueError("SYSIMG_PATH") - PLCONF_DIR= vars["PLCONF_DIR"] + PLCONF_DIR = vars["PLCONF_DIR"] if PLCONF_DIR == "": - raise ValueError, "PLCONF_DIR" + raise ValueError("PLCONF_DIR") # its ok if this is blank - NODE_SESSION= vars["NODE_SESSION"] + NODE_SESSION = vars["NODE_SESSION"] - NODE_MODEL_OPTIONS= vars["NODE_MODEL_OPTIONS"] + NODE_MODEL_OPTIONS = vars["NODE_MODEL_OPTIONS"] - PARTITIONS= vars["PARTITIONS"] + PARTITIONS = vars["PARTITIONS"] if PARTITIONS == None: - raise ValueError, "PARTITIONS" + raise ValueError("PARTITIONS") - except KeyError, var: - raise BootManagerException, "Missing variable in vars: %s\n" % var - except ValueError, var: - raise BootManagerException, "Variable in vars, shouldn't be: %s\n" % var + except KeyError as var: + raise BootManagerException("Missing variable in vars: {}\n".format(var)) + except ValueError as var: + raise BootManagerException("Variable in vars, shouldn't be: {}\n".format(var)) - ROOT_MOUNTED= 0 + ROOT_MOUNTED = 0 if vars.has_key('ROOT_MOUNTED'): - ROOT_MOUNTED= vars['ROOT_MOUNTED'] + ROOT_MOUNTED = vars['ROOT_MOUNTED'] if ROOT_MOUNTED == 0: - log.write( "Mounting node partitions\n" ) + log.write("Mounting node partitions\n") # simply creating an instance of this class and listing the system # block devices will make them show up so vgscan can find the planetlab # volume group systeminfo.get_block_device_list(vars, log) - utils.sysexec( "vgscan", log ) - utils.sysexec( "vgchange -ay planetlab", log ) + utils.sysexec("vgscan", log) + utils.sysexec("vgchange -ay planetlab", log) - utils.makedirs( SYSIMG_PATH ) + utils.makedirs(SYSIMG_PATH) - cmd = "mount %s %s" % (PARTITIONS["root"],SYSIMG_PATH) - utils.sysexec( cmd, log ) - cmd = "mount -t proc none %s/proc" % SYSIMG_PATH - utils.sysexec( cmd, log ) - cmd = "mount %s %s/vservers" % (PARTITIONS["vservers"],SYSIMG_PATH) - utils.sysexec( cmd, log ) + cmd = "mount {} {}".format(PARTITIONS["root"], SYSIMG_PATH) + utils.sysexec(cmd, log) + cmd = "mount -t proc none {}/proc".format(SYSIMG_PATH) + utils.sysexec(cmd, log) + cmd = "mount {} {}/vservers".format(PARTITIONS["vservers"], SYSIMG_PATH) + utils.sysexec(cmd, log) - ROOT_MOUNTED= 1 - vars['ROOT_MOUNTED']= 1 + ROOT_MOUNTED = 1 + vars['ROOT_MOUNTED'] = 1 # write out the session value /etc/planetlab/session try: - session_file_path= "%s/%s/session" % (SYSIMG_PATH,PLCONF_DIR) - session_file= file( session_file_path, "w" ) - session_file.write( str(NODE_SESSION) ) + session_file_path = "{}/{}/session".format(SYSIMG_PATH, PLCONF_DIR) + session_file = file(session_file_path, "w") + session_file.write(str(NODE_SESSION)) session_file.close() - session_file= None - log.write( "Updated /etc/planetlab/session\n" ) - except IOError, e: - log.write( "Unable to write out /etc/planetlab/session, continuing anyway\n" ) + session_file = None + log.write("Updated /etc/planetlab/session\n") + except IOError as e: + log.write("Unable to write out /etc/planetlab/session, continuing anyway\n") # update configuration files - log.write( "Updating configuration files.\n" ) + log.write("Updating configuration files.\n") # avoid using conf_files initscript as we're moving to systemd on some platforms - if (vars['ONE_PARTITION']!='1'): + if (vars['ONE_PARTITION'] != '1'): try: cmd = "/usr/bin/env python /usr/share/NodeManager/conf_files.py --noscripts" - utils.sysexec_chroot( SYSIMG_PATH, cmd, log ) - except IOError, e: - log.write("conf_files failed with \n %s" % e) + utils.sysexec_chroot(SYSIMG_PATH, cmd, log) + except IOError as e: + log.write("conf_files failed with \n {}".format(e)) # update node packages - log.write( "Running node update.\n" ) - if os.path.exists( SYSIMG_PATH + "/usr/bin/NodeUpdate.py" ): + log.write("Running node update.\n") + if os.path.exists(SYSIMG_PATH + "/usr/bin/NodeUpdate.py"): cmd = "/usr/bin/NodeUpdate.py start noreboot" else: # for backwards compatibility cmd = "/usr/local/planetlab/bin/NodeUpdate.py start noreboot" - utils.sysexec_chroot( SYSIMG_PATH, cmd, log ) + utils.sysexec_chroot(SYSIMG_PATH, cmd, log) # Re-generate initrd right before kexec call # this is not required anymore on recent depls. if vars['virt'] == 'vs': - MakeInitrd.Run( vars, log ) + MakeInitrd.Run(vars, log) # the following step should be done by NM - UpdateNodeConfiguration.Run( vars, log ) + UpdateNodeConfiguration.Run(vars, log) - log.write( "Updating ssh public host key with PLC.\n" ) - ssh_host_key= "" + log.write("Updating ssh public host key with PLC.\n") + ssh_host_key = "" try: - ssh_host_key_file= file("%s/etc/ssh/ssh_host_rsa_key.pub"%SYSIMG_PATH,"r") - ssh_host_key= ssh_host_key_file.read().strip() + ssh_host_key_file = file("{}/etc/ssh/ssh_host_rsa_key.pub".format(SYSIMG_PATH), "r") + ssh_host_key = ssh_host_key_file.read().strip() ssh_host_key_file.close() - ssh_host_key_file= None - except IOError, e: + ssh_host_key_file = None + except IOError as e: pass - update_vals= {} - update_vals['ssh_rsa_key']= ssh_host_key - BootAPI.call_api_function( vars, "BootUpdateNode", (update_vals,) ) + update_vals = {} + update_vals['ssh_rsa_key'] = ssh_host_key + BootAPI.call_api_function(vars, "BootUpdateNode", (update_vals,)) # get the kernel version @@ -155,124 +155,127 @@ def Run( vars, log ): if NODE_MODEL_OPTIONS & ModelOptions.SMP: option = 'smp' - log.write( "Copying kernel and initrd for booting.\n" ) + log.write("Copying kernel and initrd for booting.\n") if vars['virt'] == 'vs': - utils.sysexec( "cp %s/boot/kernel-boot%s /tmp/kernel" % (SYSIMG_PATH,option), log ) - utils.sysexec( "cp %s/boot/initrd-boot%s /tmp/initrd" % (SYSIMG_PATH,option), log ) + utils.sysexec("cp {}/boot/kernel-boot{} /tmp/kernel".format(SYSIMG_PATH, option), log) + utils.sysexec("cp {}/boot/initrd-boot{} /tmp/initrd".format(SYSIMG_PATH, option), log) else: # Use chroot to call rpm, b/c the bootimage&nodeimage rpm-versions may not work together try: - kversion = os.popen("chroot %s rpm -qa kernel | tail -1 | cut -c 8-" % SYSIMG_PATH).read().rstrip() + kversion = os.popen("chroot {} rpm -qa kernel | tail -1 | cut -c 8-"\ + .format(SYSIMG_PATH)).read().rstrip() major_version = int(kversion[0]) # Check if the string looks like a kernel version except: # Try a different method for non-rpm-based distributions - kversion = os.popen("ls -lrt %s/lib/modules | tail -1 | awk '{print $9;}'"%SYSIMG_PATH).read().rstrip() + kversion = os.popen("ls -lrt {}/lib/modules | tail -1 | awk '{print $9;}'"\ + .format(SYSIMG_PATH)).read().rstrip() - utils.sysexec( "cp %s/boot/vmlinuz-%s /tmp/kernel" % (SYSIMG_PATH,kversion), log ) - candidates=[] + utils.sysexec("cp {}/boot/vmlinuz-{} /tmp/kernel".format(SYSIMG_PATH, kversion), log) + candidates = [] # f16/18: expect initramfs image here - candidates.append ("/boot/initramfs-%s.img"%(kversion)) + candidates.append ("/boot/initramfs-{}.img".format(kversion)) # f20: uses a uid of some kind, e.g. /boot/543f88c129de443baaa65800cf3927ce//initrd - candidates.append ("/boot/*/%s/initrd"%(kversion)) + candidates.append ("/boot/*/{}/initrd".format(kversion)) # Ubuntu: - candidates.append ("/boot/initrd.img-%s"%(kversion)) + candidates.append ("/boot/initrd.img-{}".format(kversion)) def find_file_in_sysimg (candidates): import glob for pattern in candidates: - matches=glob.glob(SYSIMG_PATH+pattern) - log.write("locating initrd: found %d matches in %s\n"%(len(matches),pattern)) - if matches: return matches[0] - initrd=find_file_in_sysimg(candidates) + matches = glob.glob(SYSIMG_PATH+pattern) + log.write("locating initrd: found {} matches in {}\n".format(len(matches), pattern)) + if matches: + return matches[0] + initrd = find_file_in_sysimg(candidates) if initrd: - utils.sysexec( "cp %s /tmp/initrd" % initrd, log ) + utils.sysexec("cp {} /tmp/initrd".format(initrd), log) else: - raise Exception,"Unable to locate initrd - bailing out" + raise Exception("Unable to locate initrd - bailing out") BootAPI.save(vars) - log.write( "Unmounting disks.\n" ) + log.write("Unmounting disks.\n") - if (vars['ONE_PARTITION']!='1'): - utils.sysexec( "umount %s/vservers" % SYSIMG_PATH, log ) - utils.sysexec( "umount %s/proc" % SYSIMG_PATH, log ) - utils.sysexec_noerr( "umount %s/dev" % SYSIMG_PATH, log ) - utils.sysexec_noerr( "umount %s/sys" % SYSIMG_PATH, log ) - utils.sysexec( "umount %s" % SYSIMG_PATH, log ) - utils.sysexec( "vgchange -an", log ) + if (vars['ONE_PARTITION'] != '1'): + utils.sysexec("umount {}/vservers".format(SYSIMG_PATH), log) + utils.sysexec("umount {}s/proc".format(SYSIMG_PATH), log) + utils.sysexec_noerr("umount {}s/dev".format(SYSIMG_PATH), log) + utils.sysexec_noerr("umount {}s/sys".format(SYSIMG_PATH), log) + utils.sysexec("umount {}s".format(SYSIMG_PATH), log) + utils.sysexec("vgchange -an", log) - ROOT_MOUNTED= 0 - vars['ROOT_MOUNTED']= 0 + ROOT_MOUNTED = 0 + vars['ROOT_MOUNTED'] = 0 # Change runlevel to 'boot' prior to kexec. - StopRunlevelAgent.Run( vars, log ) + StopRunlevelAgent.Run(vars, log) - log.write( "Unloading modules and chain booting to new kernel.\n" ) + log.write("Unloading modules and chain booting to new kernel.\n") # further use of log after Upload will only output to screen log.Upload("/root/.bash_eternal_history") # regardless of whether kexec works or not, we need to stop trying to # run anything - cancel_boot_flag= "/tmp/CANCEL_BOOT" - utils.sysexec( "touch %s" % cancel_boot_flag, log ) + cancel_boot_flag = "/tmp/CANCEL_BOOT" + utils.sysexec("touch {}".format(cancel_boot_flag), log) # on 2.x cds (2.4 kernel) for sure, we need to shutdown everything # to get kexec to work correctly. Even on 3.x cds (2.6 kernel), # there are a few buggy drivers that don't disable their hardware # correctly unless they are first unloaded. - utils.sysexec_noerr( "ifconfig eth0 down", log ) + utils.sysexec_noerr("ifconfig eth0 down", log) - utils.sysexec_noerr( "killall dhclient", log ) + utils.sysexec_noerr("killall dhclient", log) if vars['virt'] == 'vs': - utils.sysexec_noerr( "umount -a -r -t ext2,ext3", log ) + utils.sysexec_noerr("umount -a -r -t ext2,ext3", log) else: - utils.sysexec_noerr( "umount -a -r -t ext2,ext3,btrfs", log ) - utils.sysexec_noerr( "modprobe -r lvm-mod", log ) + utils.sysexec_noerr("umount -a -r -t ext2,ext3,btrfs", log) + utils.sysexec_noerr("modprobe -r lvm-mod", log) # modules that should not get unloaded # unloading cpqphp causes a kernel panic blacklist = [ "floppy", "cpqphp", "i82875p_edac", "mptspi"] try: - modules= file("/tmp/loadedmodules","r") + modules = file("/tmp/loadedmodules","r") for line in modules: - module= string.strip(line) + module = string.strip(line) if module in blacklist : - log.write("Skipping unload of kernel module '%s'.\n"%module) + log.write("Skipping unload of kernel module '{}'.\n".format(module)) elif module != "": - log.write( "Unloading %s\n" % module ) - utils.sysexec_noerr( "modprobe -r %s" % module, log ) + log.write("Unloading {}\n".format(module)) + utils.sysexec_noerr("modprobe -r {}".format(module), log) if "e1000" in module: log.write("Unloading e1000 driver; sleeping 4 seconds...\n") time.sleep(4) modules.close() except IOError: - log.write( "Couldn't read /tmp/loadedmodules, continuing.\n" ) + log.write("Couldn't read /tmp/loadedmodules, continuing.\n") try: - modules= file("/proc/modules", "r") + modules = file("/proc/modules", "r") # Get usage count for USB usb_usage = 0 for line in modules: try: # Module Size UsageCount UsedBy State LoadAddress - parts= string.split(line) + parts = string.split(line) if parts[0] == "usb_storage": usb_usage += int(parts[2]) - except IndexError, e: - log.write( "Couldn't parse /proc/modules, continuing.\n" ) + except IndexError as e: + log.write("Couldn't parse /proc/modules, continuing.\n") modules.seek(0) for line in modules: try: # Module Size UsageCount UsedBy State LoadAddress - parts= string.split(line) + parts = string.split(line) # While we would like to remove all "unused" modules, # you can't trust usage count, especially for things @@ -283,17 +286,17 @@ def Run( vars, log ): # if int(parts[2]) == 0: if False and re.search('_hcd$', parts[0]): if usb_usage > 0: - log.write( "NOT unloading %s since USB may be in use\n" % parts[0] ) + log.write("NOT unloading {} since USB may be in use\n".format(parts[0])) else: - log.write( "Unloading %s\n" % parts[0] ) - utils.sysexec_noerr( "modprobe -r %s" % parts[0], log ) - except IndexError, e: - log.write( "Couldn't parse /proc/modules, continuing.\n" ) + log.write("Unloading {}\n".format(parts[0])) + utils.sysexec_noerr("modprobe -r {}".format(parts[0]), log) + except IndexError as e: + log.write("Couldn't parse /proc/modules, continuing.\n") except IOError: - log.write( "Couldn't read /proc/modules, continuing.\n" ) + log.write("Couldn't read /proc/modules, continuing.\n") - kargs = "root=%s ramdisk_size=8192" % PARTITIONS["mapper-root"] + kargs = "root={} ramdisk_size=8192".format(PARTITIONS["mapper-root"]) if NODE_MODEL_OPTIONS & ModelOptions.SMP: kargs = kargs + " " + "acpi=off" try: @@ -301,28 +304,28 @@ def Run( vars, log ): moreargs = kargsfb.readline() kargsfb.close() moreargs = moreargs.strip() - log.write( 'Parsed in "%s" kexec args from /kargs.txt\n' % moreargs ) + log.write('Parsed in "{}" kexec args from /kargs.txt\n'.format(moreargs)) kargs = kargs + " " + moreargs except IOError: # /kargs.txt does not exist, which is fine. Just kexec with default # kargs, which is ramdisk_size=8192 pass - utils.sysexec_noerr( 'hwclock --systohc --utc ', log ) + utils.sysexec_noerr('hwclock --systohc --utc ', log) utils.breakpoint ("Before kexec"); try: - utils.sysexec( 'kexec --force --initrd=/tmp/initrd --append="%s" /tmp/kernel' % kargs, log) - except BootManagerException, e: + utils.sysexec('kexec --force --initrd=/tmp/initrd --append="{}" /tmp/kernel'.format(kargs), log) + except BootManagerException as e: # if kexec fails, we've shut the machine down to a point where nothing # can run usefully anymore (network down, all modules unloaded, file # systems unmounted. write out the error, and cancel the boot process - log.write( "\n\n" ) - log.write( "-------------------------------------------------------\n" ) - log.write( "kexec failed with the following error. Please report\n" ) - log.write( "this problem to support@planet-lab.org.\n\n" ) - log.write( str(e) + "\n\n" ) - log.write( "The boot process has been canceled.\n" ) - log.write( "-------------------------------------------------------\n\n" ) + log.write("\n\n") + log.write("-------------------------------------------------------\n") + log.write("kexec failed with the following error. Please report\n") + log.write("this problem to support@planet-lab.org.\n\n") + log.write(str(e) + "\n\n") + log.write("The boot process has been canceled.\n") + log.write("-------------------------------------------------------\n\n") return diff --git a/source/steps/CheckForNewDisks.py b/source/steps/CheckForNewDisks.py index 09a001d..480db27 100644 --- a/source/steps/CheckForNewDisks.py +++ b/source/steps/CheckForNewDisks.py @@ -17,7 +17,7 @@ import os import ModelOptions -def Run( vars, log ): +def Run(vars, log): """ Find any new large block devices we can add to the vservers volume group @@ -30,173 +30,172 @@ def Run( vars, log ): ROOT_MOUNTED the node root file system is mounted """ - log.write( "\n\nStep: Checking for unused disks to add to LVM.\n" ) + log.write("\n\nStep: Checking for unused disks to add to LVM.\n") # make sure we have the variables we need try: - SYSIMG_PATH= vars["SYSIMG_PATH"] + SYSIMG_PATH = vars["SYSIMG_PATH"] if SYSIMG_PATH == "": - raise ValueError, "SYSIMG_PATH" + raise ValueError("SYSIMG_PATH") - MINIMUM_DISK_SIZE= int(vars["MINIMUM_DISK_SIZE"]) + MINIMUM_DISK_SIZE = int(vars["MINIMUM_DISK_SIZE"]) - PARTITIONS= vars["PARTITIONS"] + PARTITIONS = vars["PARTITIONS"] if PARTITIONS == None: - raise ValueError, "PARTITIONS" + raise ValueError("PARTITIONS") - NODE_MODEL_OPTIONS= vars["NODE_MODEL_OPTIONS"] - except KeyError, var: - raise BootManagerException, "Missing variable in vars: %s\n" % var - except ValueError, var: - raise BootManagerException, "Variable in vars, shouldn't be: %s\n" % var + NODE_MODEL_OPTIONS = vars["NODE_MODEL_OPTIONS"] + except KeyError as var: + raise BootManagerException("Missing variable in vars: {}\n".format(var)) + except ValueError as var: + raise BootManagerException("Variable in vars, shouldn't be: {}\n".format(var)) - all_devices= systeminfo.get_block_device_list(vars, log) + all_devices = systeminfo.get_block_device_list(vars, log) # will contain the new devices to add to the volume group - new_devices= [] + new_devices = [] # total amount of new space in gb - extended_gb_size= 0 + extended_gb_size = 0 for device in all_devices.keys(): - (major,minor,blocks,gb_size,readonly)= all_devices[device] + (major,minor,blocks,gb_size,readonly) = all_devices[device] if device[:14] == "/dev/planetlab": - log.write( "Skipping device %s in volume group.\n" % device ) + log.write("Skipping device {} in volume group.\n".format(device)) continue if readonly: - log.write( "Skipping read only device %s\n" % device ) + log.write("Skipping read only device {}\n".format(device)) continue if gb_size < MINIMUM_DISK_SIZE: - log.write( "Skipping too small device %s (%4.2f)\n" % - (device,gb_size) ) + log.write("Skipping too small device {} ({:4.2f}) Gb\n"\ + .format(device, gb_size)) continue - log.write( "Checking device %s to see if it is part " \ - "of the volume group.\n" % device ) + log.write("Checking device {} to see if it is part " \ + "of the volume group.\n".format(device)) # this is the lvm partition, if it exists on that device - lvm_partition= InstallPartitionDisks.get_partition_path_from_device( device, vars, log ) - cmd = "pvdisplay %s | grep -q 'planetlab'" % lvm_partition + lvm_partition = InstallPartitionDisks.get_partition_path_from_device(device, vars, log) + cmd = "pvdisplay {} | grep -q 'planetlab'".format(lvm_partition) already_added = utils.sysexec_noerr(cmd, log, shell=True) if already_added: - log.write( "It appears %s is part of the volume group, continuing.\n" % - device ) + log.write("It appears {} is part of the volume group, continuing.\n"\ + .format(device)) continue # just to be extra paranoid, ignore the device if it already has # an lvm partition on it (new disks won't have this, and that is # what this code is for, so it should be ok). - cmd = "parted --script --list %s | grep -q lvm$" % device - has_lvm= utils.sysexec_noerr(cmd, log) + cmd = "parted --script --list {} | grep -q lvm$".format(device) + has_lvm = utils.sysexec_noerr(cmd, log) if has_lvm: - log.write( "It appears %s has lvm already setup on it.\n" % device) + log.write("It appears {} has lvm already setup on it.\n".format(device)) paranoid = False if paranoid: - log.write("To paranoid to add %s to vservers lvm.\n" % device) + log.write("Too paranoid to add {} to vservers lvm.\n".format(device)) continue - if not InstallPartitionDisks.single_partition_device( device, vars, log ): - log.write( "Unable to partition %s, not using it.\n" % device ) + if not InstallPartitionDisks.single_partition_device(device, vars, log): + log.write("Unable to partition {}, not using it.\n".format(device)) continue - log.write( "Successfully partitioned %s\n" % device ) + log.write("Successfully partitioned {}\n".format(device)) if NODE_MODEL_OPTIONS & ModelOptions.RAWDISK: - log.write( "Running on a raw disk node, not using it.\n" ) + log.write("Running on a raw disk node, not using it.\n") continue - part_path= InstallPartitionDisks.get_partition_path_from_device( device, - vars, log ) + part_path = InstallPartitionDisks.get_partition_path_from_device(device, + vars, log) - log.write( "Attempting to add %s to the volume group\n" % device ) + log.write("Attempting to add {} to the volume group\n".format(device)) - if not InstallPartitionDisks.create_lvm_physical_volume( part_path, - vars, log ): - log.write( "Unable to create lvm physical volume %s, not using it.\n" % - part_path ) + if not InstallPartitionDisks.create_lvm_physical_volume(part_path, + vars, log): + log.write("Unable to create lvm physical volume {}, not using it.\n"\ + .format(part_path)) continue - log.write( "Adding %s to list of devices to add to " \ - "planetlab volume group.\n" % device ) + log.write("Adding {} to list of devices to add to " + "planetlab volume group.\n".format(device)) - extended_gb_size= extended_gb_size + gb_size - new_devices.append( part_path ) + extended_gb_size = extended_gb_size + gb_size + new_devices.append(part_path) if len(new_devices) > 0: - log.write( "Extending planetlab volume group.\n" ) + log.write("Extending planetlab volume group.\n") - log.write( "Unmounting disks.\n" ) + log.write("Unmounting disks.\n") try: # backwards compat, though, we should never hit this case post PL 3.2 - os.stat("%s/rcfs/taskclass"%SYSIMG_PATH) - utils.sysexec_chroot_noerr( SYSIMG_PATH, "umount /rcfs", log ) - except OSError, e: + os.stat("{}/rcfs/taskclass".format(SYSIMG_PATH)) + utils.sysexec_chroot_noerr(SYSIMG_PATH, "umount /rcfs", log) + except OSError as e: pass # umount in order to extend disk size - utils.sysexec_noerr( "umount %s/proc" % SYSIMG_PATH, log ) - utils.sysexec_noerr( "umount %s/vservers" % SYSIMG_PATH, log ) - utils.sysexec_noerr( "umount %s" % SYSIMG_PATH, log ) - utils.sysexec( "vgchange -an", log ) + utils.sysexec_noerr("umount {}/proc".format(SYSIMG_PATH), log) + utils.sysexec_noerr("umount {}/vservers".format(SYSIMG_PATH), log) + utils.sysexec_noerr("umount {}".format(SYSIMG_PATH), log) + utils.sysexec("vgchange -an", log) - vars['ROOT_MOUNTED']= 0 + vars['ROOT_MOUNTED'] = 0 while True: - cmd = "vgextend planetlab %s" % string.join(new_devices," ") - if not utils.sysexec_noerr( cmd, log ): - log.write( "Failed to add physical volumes %s to " \ - "volume group, continuing.\n" % string.join(new_devices," ")) + cmd = "vgextend planetlab {}".format(" ".join(new_devices)) + if not utils.sysexec_noerr(cmd, log): + log.write("Failed to add physical volumes {} to "\ + "volume group, continuing.\n".format(" ".join(new_devices))) res = 1 break # now, get the number of unused extents, and extend the vserver # logical volume by that much. - remaining_extents= \ - InstallPartitionDisks.get_remaining_extents_on_vg( vars, log ) + remaining_extents = \ + InstallPartitionDisks.get_remaining_extents_on_vg(vars, log) - log.write( "Extending vservers logical volume.\n" ) - utils.sysexec( "vgchange -ay", log ) - cmd = "lvextend -l +%s %s" % (remaining_extents, PARTITIONS["vservers"]) + log.write("Extending vservers logical volume.\n") + utils.sysexec("vgchange -ay", log) + cmd = "lvextend -l +{} {}".format(remaining_extents, PARTITIONS["vservers"]) if not utils.sysexec_noerr(cmd, log): - log.write( "Failed to extend vservers logical volume, continuing\n" ) + log.write("Failed to extend vservers logical volume, continuing\n") res = 1 break - log.write( "making the ext filesystem match new logical volume size.\n" ) + log.write("making the ext filesystem match new logical volume size.\n") - vars['ROOT_MOUNTED']= 1 - cmd = "mount %s %s" % (PARTITIONS["root"],SYSIMG_PATH) - utils.sysexec_noerr( cmd, log ) - cmd = "mount %s %s/vservers" % \ - (PARTITIONS["vservers"],SYSIMG_PATH) - utils.sysexec_noerr( cmd, log ) - cmd = "resize2fs %s" % PARTITIONS["vservers"] + vars['ROOT_MOUNTED'] = 1 + cmd = "mount {} {}".format(PARTITIONS["root"], SYSIMG_PATH) + utils.sysexec_noerr(cmd, log) + cmd = "mount {} {}/vservers".format(PARTITIONS["vservers"], SYSIMG_PATH) + utils.sysexec_noerr(cmd, log) + cmd = "resize2fs {}".format(PARTITIONS["vservers"]) resize = utils.sysexec_noerr(cmd,log) - utils.sysexec_noerr( "umount %s/vservers" % SYSIMG_PATH, log ) - utils.sysexec_noerr( "umount %s" % SYSIMG_PATH, log ) - vars['ROOT_MOUNTED']= 0 + utils.sysexec_noerr("umount {}/vservers".format(SYSIMG_PATH), log) + utils.sysexec_noerr("umount {}".format(SYSIMG_PATH), log) + vars['ROOT_MOUNTED'] = 0 - utils.sysexec( "vgchange -an", log ) + utils.sysexec("vgchange -an", log) if not resize: - log.write( "Failed to resize vservers partition, continuing.\n" ) + log.write("Failed to resize vservers partition, continuing.\n") res = 1 break else: - log.write( "Extended vservers partition by %4.2f GB\n" % - extended_gb_size ) + log.write("Extended vservers partition by {:4.2f} Gb\n"\ + .format(extended_gb_size)) res = 1 break else: - log.write( "No new disk devices to add to volume group.\n" ) + log.write("No new disk devices to add to volume group.\n") res = 1 return res diff --git a/source/steps/CheckHardwareRequirements.py b/source/steps/CheckHardwareRequirements.py index 39f8785..a3f8677 100644 --- a/source/steps/CheckHardwareRequirements.py +++ b/source/steps/CheckHardwareRequirements.py @@ -18,7 +18,7 @@ import notify_messages import BootAPI -def Run( vars, log ): +def Run(vars, log): """ Make sure the hardware we are running on is sufficient for the PlanetLab OS to be installed on. In the process, identify @@ -44,100 +44,97 @@ def Run( vars, log ): INSTALL_BLOCK_DEVICES list of block devices to install onto """ - log.write( "\n\nStep: Checking if hardware requirements met.\n" ) + log.write("\n\nStep: Checking if hardware requirements met.\n") try: - MINIMUM_MEMORY= int(vars["MINIMUM_MEMORY"]) + MINIMUM_MEMORY = int(vars["MINIMUM_MEMORY"]) if MINIMUM_MEMORY == "": - raise ValueError, "MINIMUM_MEMORY" + raise ValueError("MINIMUM_MEMORY") - NODE_ID= vars["NODE_ID"] + NODE_ID = vars["NODE_ID"] if NODE_ID == "": raise ValueError("NODE_ID") - MINIMUM_DISK_SIZE= int(vars["MINIMUM_DISK_SIZE"]) + MINIMUM_DISK_SIZE = int(vars["MINIMUM_DISK_SIZE"]) # use vs_ or lxc_variants - varname=vars['virt']+"_TOTAL_MINIMUM_DISK_SIZE" - TOTAL_MINIMUM_DISK_SIZE= int(vars[varname]) + varname = vars['virt'] + "_TOTAL_MINIMUM_DISK_SIZE" + TOTAL_MINIMUM_DISK_SIZE = int(vars[varname]) - SKIP_HARDWARE_REQUIREMENT_CHECK= \ - int(vars["SKIP_HARDWARE_REQUIREMENT_CHECK"]) + SKIP_HARDWARE_REQUIREMENT_CHECK = int(vars["SKIP_HARDWARE_REQUIREMENT_CHECK"]) - except KeyError, var: - raise BootManagerException, \ - "Missing variable in install store: %s" % var - except ValueError, var: - raise BootManagerException, \ - "Variable in install store blank, shouldn't be: %s" % var + except KeyError as var: + raise BootManagerException("Missing variable in install store: {}".format(var)) + except ValueError as var: + raise BootManagerException("Variable in install store blank, shouldn't be: {}".format(var)) # lets see if we have enough memory to run - log.write( "Checking for available memory.\n" ) + log.write("Checking for available memory.\n") - total_mem= systeminfo.get_total_phsyical_mem(vars, log) + total_mem = systeminfo.get_total_phsyical_mem(vars, log) if total_mem is None: - raise BootManagerException, "Unable to read total physical memory" + raise BootManagerException("Unable to read total physical memory") if total_mem < MINIMUM_MEMORY: if not SKIP_HARDWARE_REQUIREMENT_CHECK: - log.write( "Insufficient memory to run node: %s kb\n" % total_mem ) - log.write( "Required memory: %s kb\n" % MINIMUM_MEMORY ) + log.write("Insufficient memory to run node: {} kb\n".format(total_mem)) + log.write("Required memory: {} kb\n".format(MINIMUM_MEMORY)) - include_pis= 0 - include_techs= 1 - include_support= 0 + include_pis = 0 + include_techs = 1 + include_support = 0 - sent= 0 + sent = 0 try: - sent= BootAPI.call_api_function( vars, "BootNotifyOwners", - (notify_messages.MSG_INSUFFICIENT_MEMORY, - include_pis, - include_techs, - include_support) ) - except BootManagerException, e: - log.write( "Call to BootNotifyOwners failed: %s.\n" % e ) + sent = BootAPI.call_api_function(vars, "BootNotifyOwners", + (notify_messages.MSG_INSUFFICIENT_MEMORY, + include_pis, + include_techs, + include_support)) + except BootManagerException as e: + log.write("Call to BootNotifyOwners failed: {}.\n".format(e)) if sent == 0: - log.write( "Unable to notify site contacts of problem.\n" ) + log.write("Unable to notify site contacts of problem.\n") else: - log.write( "Notified contacts of problem.\n" ) + log.write("Notified contacts of problem.\n") return 0 else: - log.write( "Memory requirements not met, but running anyway: %s kb\n" - % total_mem ) + log.write("Memory requirements not met, but running anyway: {} kb\n" + .format(total_mem)) else: - log.write( "Looks like we have enough memory: %s kb\n" % total_mem ) + log.write("Looks like we have enough memory: {} kb\n".format(total_mem)) # get a list of block devices to attempt to install on # (may include cdrom devices) - install_devices= systeminfo.get_block_device_list(vars, log) + install_devices = systeminfo.get_block_device_list(vars, log) # save the list of block devices in the log - log.write( "Detected block devices:\n" ) - log.write( repr(install_devices) + "\n" ) + log.write("Detected block devices:\n") + log.write(repr(install_devices) + "\n") if not install_devices or len(install_devices) == 0: - log.write( "No block devices detected.\n" ) + log.write("No block devices detected.\n") - include_pis= 0 - include_techs= 1 - include_support= 0 + include_pis = 0 + include_techs = 1 + include_support = 0 - sent= 0 + sent = 0 try: - sent= BootAPI.call_api_function( vars, "BootNotifyOwners", - (notify_messages.MSG_INSUFFICIENT_DISK, - include_pis, - include_techs, - include_support) ) - except BootManagerException, e: - log.write( "Call to BootNotifyOwners failed: %s.\n" % e ) + sent = BootAPI.call_api_function(vars, "BootNotifyOwners", + (notify_messages.MSG_INSUFFICIENT_DISK, + include_pis, + include_techs, + include_support)) + except BootManagerException as e: + log.write("Call to BootNotifyOwners failed: {}.\n".format(e)) if sent == 0: - log.write( "Unable to notify site contacts of problem.\n" ) + log.write("Unable to notify site contacts of problem.\n") return 0 @@ -148,11 +145,11 @@ def Run( vars, log ): # some size threshold (set in installstore) # also, keep track of the total size for all devices that appear usable - total_size= 0 + total_size = 0 for device in install_devices.keys(): - (major,minor,blocks,gb_size,readonly)= install_devices[device] + major, minor, blocks, gb_size, readonly = install_devices[device] # if the device string starts with # planetlab or dm- (device mapper), ignore it (could be old lvm setup) @@ -161,56 +158,56 @@ def Run( vars, log ): continue if gb_size < MINIMUM_DISK_SIZE: - log.write( "Device is too small to use: %s \n(appears" \ - " to be %4.2f GB)\n" % (device,gb_size) ) + log.write("Device is too small to use: {} \n" + "(appears to be {:4.2f} Gb)\n".format(device, gb_size)) try: del install_devices[device] - except KeyError, e: + except KeyError as e: pass continue if readonly: - log.write( "Device is readonly, not using: %s\n" % device ) + log.write("Device is readonly, not using: {}\n".format(device)) try: del install_devices[device] - except KeyError, e: + except KeyError as e: pass continue # add this sector count to the total count of usable # sectors we've found. - total_size= total_size + gb_size + total_size = total_size + gb_size if len(install_devices) == 0: - log.write( "No suitable block devices found for install.\n" ) + log.write("No suitable block devices found for install.\n") - include_pis= 0 - include_techs= 1 - include_support= 0 + include_pis = 0 + include_techs = 1 + include_support = 0 - sent= 0 + sent = 0 try: - sent= BootAPI.call_api_function( vars, "BootNotifyOwners", - (notify_messages.MSG_INSUFFICIENT_DISK, - include_pis, - include_techs, - include_support) ) - except BootManagerException, e: - log.write( "Call to BootNotifyOwners failed: %s.\n" % e ) + sent = BootAPI.call_api_function(vars, "BootNotifyOwners", + (notify_messages.MSG_INSUFFICIENT_DISK, + include_pis, + include_techs, + include_support)) + except BootManagerException as e: + log.write("Call to BootNotifyOwners failed: {}.\n".format(e)) if sent == 0: - log.write( "Unable to notify site contacts of problem.\n" ) + log.write("Unable to notify site contacts of problem.\n") return 0 # show the devices we found that are usable - log.write( "Usable block devices:\n" ) - log.write( repr(install_devices.keys()) + "\n" ) + log.write("Usable block devices:\n") + log.write(repr(install_devices.keys()) + "\n") # save the list of devices for the following steps - vars["INSTALL_BLOCK_DEVICES"]= install_devices.keys() + vars["INSTALL_BLOCK_DEVICES"] = install_devices.keys() # ensure the total disk size is large enough. if @@ -218,31 +215,31 @@ def Run( vars, log ): # put the node into debug mode. if total_size < TOTAL_MINIMUM_DISK_SIZE: if not SKIP_HARDWARE_REQUIREMENT_CHECK: - log.write( "The total usable disk size of all disks is " \ - "insufficient to be usable as a PlanetLab node.\n" ) - include_pis= 0 - include_techs= 1 - include_support= 0 + log.write("The total usable disk size of all disks is " \ + "insufficient to be usable as a PlanetLab node.\n") + include_pis = 0 + include_techs = 1 + include_support = 0 - sent= 0 + sent = 0 try: - sent= BootAPI.call_api_function( vars, "BootNotifyOwners", - (notify_messages.MSG_INSUFFICIENT_DISK, - include_pis, - include_techs, - include_support) ) - except BootManagerException, e: - log.write( "Call to BootNotifyOwners failed: %s.\n" % e ) + sent = BootAPI.call_api_function(vars, "BootNotifyOwners", + (notify_messages.MSG_INSUFFICIENT_DISK, + include_pis, + include_techs, + include_support)) + except BootManagerException as e: + log.write("Call to BootNotifyOwners failed: {}.\n".format(e)) if sent == 0: - log.write( "Unable to notify site contacts of problem.\n" ) + log.write("Unable to notify site contacts of problem.\n") return 0 else: - log.write( "The total usable disk size of all disks is " \ - "insufficient, but running anyway.\n" ) + log.write("The total usable disk size of all disks is " \ + "insufficient, but running anyway.\n") - log.write( "Total size for all usable block devices: %4.2f GB\n" % total_size ) + log.write("Total size for all usable block devices: {:4.2f} Gb\n".format(total_size)) return 1 diff --git a/source/steps/ConfirmInstallWithUser.py b/source/steps/ConfirmInstallWithUser.py index 8890fcc..7144e15 100644 --- a/source/steps/ConfirmInstallWithUser.py +++ b/source/steps/ConfirmInstallWithUser.py @@ -36,7 +36,7 @@ WARNING : Installing PlanetLab will remove any existing operating system and """ -def Run( vars, log ): +def Run(vars, log): """ Ask the user if we really want to wipe this machine. @@ -44,25 +44,25 @@ def Run( vars, log ): a BootManagerException if anything unexpected occurred. """ - log.write( "\n\nStep: Confirming install with user.\n" ) + log.write("\n\nStep: Confirming install with user.\n") try: - confirmation= "" - install= 0 + confirmation = "" + install = 0 print welcome_message while confirmation not in ("yes","no"): - confirmation= \ - raw_input("Are you sure you wish to continue (yes/no):") - install= confirmation=="yes" - except EOFError, e: + confirmation = \ + raw_input("Are you sure you wish to continue (yes/no): ") + install = confirmation=="yes" + except EOFError as e: pass - except KeyboardInterrupt, e: + except KeyboardInterrupt as e: pass if install: - log.write( "\nUser accepted install.\n" ) + log.write("\nUser accepted install.\n") else: - log.write( "\nUser canceled install.\n" ) + log.write("\nUser canceled install.\n") return install diff --git a/source/steps/GetAndUpdateNodeDetails.py b/source/steps/GetAndUpdateNodeDetails.py index 58e3bf8..b6d20a6 100644 --- a/source/steps/GetAndUpdateNodeDetails.py +++ b/source/steps/GetAndUpdateNodeDetails.py @@ -13,7 +13,7 @@ from Exceptions import * import BootAPI import ModelOptions -def Run( vars, log ): +def Run(vars, log): """ Contact PLC and get the attributes for this node. Also, parse in @@ -44,73 +44,73 @@ def Run( vars, log ): Raise a BootManagerException if anything fails. """ - log.write( "\n\nStep: Retrieving details of node from PLC.\n" ) + log.write("\n\nStep: Retrieving details of node from PLC.\n") # make sure we have the variables we need try: - SKIP_HARDWARE_REQUIREMENT_CHECK= vars["SKIP_HARDWARE_REQUIREMENT_CHECK"] + SKIP_HARDWARE_REQUIREMENT_CHECK = vars["SKIP_HARDWARE_REQUIREMENT_CHECK"] if SKIP_HARDWARE_REQUIREMENT_CHECK == "": - raise ValueError, "SKIP_HARDWARE_REQUIREMENT_CHECK" + raise ValueError("SKIP_HARDWARE_REQUIREMENT_CHECK") - INTERFACE_SETTINGS= vars["INTERFACE_SETTINGS"] + INTERFACE_SETTINGS = vars["INTERFACE_SETTINGS"] if INTERFACE_SETTINGS == "": - raise ValueError, "INTERFACE_SETTINGS" + raise ValueError("INTERFACE_SETTINGS") - WAS_NODE_ID_IN_CONF= vars["WAS_NODE_ID_IN_CONF"] + WAS_NODE_ID_IN_CONF = vars["WAS_NODE_ID_IN_CONF"] if WAS_NODE_ID_IN_CONF == "": - raise ValueError, "WAS_NODE_ID_IN_CONF" + raise ValueError("WAS_NODE_ID_IN_CONF") - WAS_NODE_KEY_IN_CONF= vars["WAS_NODE_KEY_IN_CONF"] + WAS_NODE_KEY_IN_CONF = vars["WAS_NODE_KEY_IN_CONF"] if WAS_NODE_KEY_IN_CONF == "": - raise ValueError, "WAS_NODE_KEY_IN_CONF" + raise ValueError("WAS_NODE_KEY_IN_CONF") - except KeyError, var: - raise BootManagerException, "Missing variable in vars: %s\n" % var - except ValueError, var: - raise BootManagerException, "Variable in vars, shouldn't be: %s\n" % var + except KeyError as var: + raise BootManagerException("Missing variable in vars: {}\n".format(var)) + except ValueError as var: + raise BootManagerException("Variable in vars, shouldn't be: {}\n".format(var)) - node_details= BootAPI.call_api_function( vars, "GetNodes", + node_details = BootAPI.call_api_function(vars, "GetNodes", (vars['NODE_ID'], ['boot_state', 'nodegroup_ids', 'interface_ids', 'model', 'site_id']))[0] - vars['BOOT_STATE']= node_details['boot_state'] - vars['RUN_LEVEL']= node_details['boot_state'] - vars['NODE_MODEL']= string.strip(node_details['model']) + vars['BOOT_STATE'] = node_details['boot_state'] + vars['RUN_LEVEL'] = node_details['boot_state'] + vars['NODE_MODEL'] = string.strip(node_details['model']) vars['SITE_ID'] = node_details['site_id'] - log.write( "Successfully retrieved node record.\n" ) - log.write( "Current boot state: %s\n" % vars['BOOT_STATE'] ) - log.write( "Node make/model: %s\n" % vars['NODE_MODEL'] ) + log.write("Successfully retrieved node record.\n") + log.write("Current boot state: {}\n".format(vars['BOOT_STATE'])) + log.write("Node make/model: {}\n".format(vars['NODE_MODEL'])) # parse in the model options from the node_model string - model= vars['NODE_MODEL'] - options= ModelOptions.Get(model) - vars['NODE_MODEL_OPTIONS']=options + model = vars['NODE_MODEL'] + options = ModelOptions.Get(model) + vars['NODE_MODEL_OPTIONS'] = options # Check if we should skip hardware requirement check if options & ModelOptions.MINHW: - vars['SKIP_HARDWARE_REQUIREMENT_CHECK']=1 - log.write( "node model indicates override to hardware requirements.\n" ) + vars['SKIP_HARDWARE_REQUIREMENT_CHECK'] = 1 + log.write("node model indicates override to hardware requirements.\n") # this contains all the node networks, for now, we are only concerned # in the primary network - interfaces= BootAPI.call_api_function( vars, "GetInterfaces", (node_details['interface_ids'],)) - got_primary= 0 + interfaces = BootAPI.call_api_function(vars, "GetInterfaces", (node_details['interface_ids'],)) + got_primary = 0 for network in interfaces: if network['is_primary'] == 1: - log.write( "Primary network as returned from PLC: %s\n" % str(network) ) - got_primary= 1 + log.write("Primary network as returned from PLC: {}\n".format(network)) + got_primary = 1 break if not got_primary: - raise BootManagerException, "Node did not have a primary network." + raise BootManagerException("Node did not have a primary network.") - vars['INTERFACES']= interfaces + vars['INTERFACES'] = interfaces # call getNodeFlavour and store in VARS['node_flavour'] try: - node_flavour = BootAPI.call_api_function(vars, "GetNodeFlavour", (vars['NODE_ID'], ) ) + node_flavour = BootAPI.call_api_function(vars, "GetNodeFlavour", (vars['NODE_ID'],)) except: - log.write("GetNodeFlavour failed, not fatal if the node flavor is available in ``configuration''\n") + log.write("GetNodeFlavour failed, not fatal if the node flavour is available in ``configuration''\n") pass flavour_keys = [ @@ -122,20 +122,21 @@ def Run( vars, log ): # MyPLC 5.0 workaround # make sure to define 'extensions' even if not yet set - if ('extensions' not in vars or vars['extensions']==''): - vars['extensions']=[] + if 'extensions' not in vars or vars['extensions']=='': + vars['extensions'] = [] for k in flavour_keys: - # Support MyPLC <5.2 - if (not vars.has_key(k)): + # Support MyPLC<5.2 + if k not in vars: try: vars[k] = node_flavour[k] except: exc_type, exc_value, exc_traceback = sys.exc_info() - lines=traceback.format_exception(exc_type,exc_value,exc_traceback) - for line in lines: log.write(line) - raise BootManagerException ("Could not call GetNodeFlavour - need PLCAPI-5.2") + lines = traceback.format_exception(exc_type, exc_value, exc_traceback) + for line in lines: + log.write(line) + raise BootManagerException("Could not call GetNodeFlavour - need PLCAPI-5.2") - log.write ("NodeFlavour as returned from PLC: %s\n"%node_flavour) + log.write ("NodeFlavour as returned from PLC: {}\n".format(node_flavour)) return 1 diff --git a/source/steps/InitializeBootManager.py b/source/steps/InitializeBootManager.py index c98f960..dfe3399 100644 --- a/source/steps/InitializeBootManager.py +++ b/source/steps/InitializeBootManager.py @@ -16,17 +16,17 @@ import utils # locations of boot os version files -BOOT_VERSION_2X_FILE='/usr/bootme/ID' -BOOT_VERSION_3X_FILE='/pl_version' +BOOT_VERSION_2X_FILE = '/usr/bootme/ID' +BOOT_VERSION_3X_FILE = '/pl_version' # minimium version of the boot os we need to run, as a (major,minor) tuple -MINIMUM_BOOT_VERSION= (3,0) +MINIMUM_BOOT_VERSION = (3, 0) # minimum version of python required to run the boot manager -MINIMUM_PYTHON_VERSION= (2,2,0) +MINIMUM_PYTHON_VERSION = (2, 6, 0) -def Run( vars, log ): +def Run(vars, log): """ Setup the boot manager so it can run, do any extra necessary hardware setup (to fix old cd problems) @@ -37,56 +37,53 @@ def Run( vars, log ): BOOT_CD_VERSION A two number tuple of the boot cd version """ - log.write( "\n\nStep: Initializing the BootManager.\n" ) + log.write("\n\nStep: Initializing the BootManager.\n") # Default model option. Required in case we go into debug mode # before we successfully called GetAndUpdateNodeDetails(). - vars["NODE_MODEL_OPTIONS"] = vars.get("NODE_MODEL_OPTIONS",0) + vars["NODE_MODEL_OPTIONS"] = vars.get("NODE_MODEL_OPTIONS", 0) # define the basic partition paths - PARTITIONS= {} - PARTITIONS["root"]= "/dev/planetlab/root" - PARTITIONS["swap"]= "/dev/planetlab/swap" - PARTITIONS["vservers"]= "/dev/planetlab/vservers" + PARTITIONS = {} + PARTITIONS["root"] = "/dev/planetlab/root" + PARTITIONS["swap"] = "/dev/planetlab/swap" + PARTITIONS["vservers"] = "/dev/planetlab/vservers" # Linux 2.6 mounts LVM with device mapper - PARTITIONS["mapper-root"]= "/dev/mapper/planetlab-root" - PARTITIONS["mapper-swap"]= "/dev/mapper/planetlab-swap" - PARTITIONS["mapper-vservers"]= "/dev/mapper/planetlab-vservers" - vars["PARTITIONS"]= PARTITIONS + PARTITIONS["mapper-root"] = "/dev/mapper/planetlab-root" + PARTITIONS["mapper-swap"] = "/dev/mapper/planetlab-swap" + PARTITIONS["mapper-vservers"] = "/dev/mapper/planetlab-vservers" + vars["PARTITIONS"] = PARTITIONS - log.write( "Opening connection to API server\n" ) + log.write("Opening connection to API server\n") try: - api_inst= xmlrpclib.Server( vars['BOOT_API_SERVER'], verbose=0 ) - except KeyError, e: - raise BootManagerException, \ - "configuration file does not specify API server URL" + api_inst = xmlrpclib.Server(vars['BOOT_API_SERVER'], verbose=0) + except KeyError as e: + raise BootManagerException("configuration file does not specify API server URL") - vars['API_SERVER_INST']= api_inst + vars['API_SERVER_INST'] = api_inst - if not __check_boot_version( vars, log ): - raise BootManagerException, \ - "Boot CD version insufficient to run the Boot Manager" + if not __check_boot_version(vars, log): + raise BootManagerException("Boot CD version insufficient to run the Boot Manager") else: - log.write( "Running on boot cd version: %s\n" % - str(vars['BOOT_CD_VERSION']) ) + log.write("Running on boot cd version: {}\n".format(vars['BOOT_CD_VERSION'])) - BOOT_CD_VERSION= vars['BOOT_CD_VERSION'] + BOOT_CD_VERSION = vars['BOOT_CD_VERSION'] # In case we are booted with a kernel that does not have the # device mapper code compiled into the kernel. if not os.path.exists("/dev/mapper"): - log.write( "Loading support for LVM\n" ) - utils.sysexec_noerr( "modprobe dm_mod", log ) + log.write("Loading support for LVM\n") + utils.sysexec_noerr("modprobe dm_mod", log) # for anything that needs to know we are running under the boot cd and # not the runtime os - os.environ['PL_BOOTCD']= "1" + os.environ['PL_BOOTCD'] = "1" return 1 -def __check_boot_version( vars, log ): +def __check_boot_version(vars, log): """ identify which version of the boot os we are running on, and whether or not we can run at all on the given version. later, this will be @@ -120,68 +117,68 @@ def __check_boot_version( vars, log ): try: # check for a 3.x version first - version_file= file(BOOT_VERSION_3X_FILE,'r') - full_version= string.strip(version_file.read()) + version_file = file(BOOT_VERSION_3X_FILE, 'r') + full_version = string.strip(version_file.read()) version_file.close() - version_parts= string.split(full_version) - version= version_parts[-1] + version_parts = string.split(full_version) + version = version_parts[-1] - version_numbers= string.split(version,".") + version_numbers = string.split(version, ".") if len(version_numbers) == 2: - BOOT_OS_MAJOR_VERSION= int(version_numbers[0]) - BOOT_OS_MINOR_VERSION= int(version_numbers[1]) + BOOT_OS_MAJOR_VERSION = int(version_numbers[0]) + BOOT_OS_MINOR_VERSION = int(version_numbers[1]) else: # for 3.x cds, if there are more than two parts # separated by a ., its one of the beta cds. # hardcode as a 3.0 cd - BOOT_OS_MAJOR_VERSION= 3 - BOOT_OS_MINOR_VERSION= 0 + BOOT_OS_MAJOR_VERSION = 3 + BOOT_OS_MINOR_VERSION = 0 - vars['BOOT_CD_VERSION']= (BOOT_OS_MAJOR_VERSION,BOOT_OS_MINOR_VERSION) + vars['BOOT_CD_VERSION'] = (BOOT_OS_MAJOR_VERSION, BOOT_OS_MINOR_VERSION) - if (BOOT_OS_MAJOR_VERSION,BOOT_OS_MINOR_VERSION) >= \ + if (BOOT_OS_MAJOR_VERSION, BOOT_OS_MINOR_VERSION) >= \ MINIMUM_BOOT_VERSION: return 1 - except IOError, e: + except IOError as e: pass - except IndexError, e: + except IndexError as e: pass - except TypeError, e: + except TypeError as e: pass try: # check for a 2.x version first - version_file= file(BOOT_VERSION_2X_FILE,'r') - full_version= string.strip(version_file.read()) + version_file = file(BOOT_VERSION_2X_FILE, 'r') + full_version = string.strip(version_file.read()) version_file.close() - version_parts= string.split(full_version) - version= version_parts[-1] + version_parts = string.split(full_version) + version = version_parts[-1] if version[0] == 'v': - version= version[1:] + version = version[1:] - version_numbers= string.split(version,".") + version_numbers = string.split(version, ".") if len(version_numbers) == 2: - BOOT_OS_MAJOR_VERSION= int(version_numbers[0]) - BOOT_OS_MINOR_VERSION= int(version_numbers[1]) + BOOT_OS_MAJOR_VERSION = int(version_numbers[0]) + BOOT_OS_MINOR_VERSION = int(version_numbers[1]) else: - BOOT_OS_MAJOR_VERSION= int(version_numbers[0]) - BOOT_OS_MINOR_VERSION= int(version_numbers[2]) + BOOT_OS_MAJOR_VERSION = int(version_numbers[0]) + BOOT_OS_MINOR_VERSION = int(version_numbers[2]) - vars['BOOT_CD_VERSION']= (BOOT_OS_MAJOR_VERSION,BOOT_OS_MINOR_VERSION) + vars['BOOT_CD_VERSION'] = (BOOT_OS_MAJOR_VERSION, BOOT_OS_MINOR_VERSION) - if (BOOT_OS_MAJOR_VERSION,BOOT_OS_MINOR_VERSION) >= \ + if (BOOT_OS_MAJOR_VERSION, BOOT_OS_MINOR_VERSION) >= \ MINIMUM_BOOT_VERSION: return 1 - except IOError, e: + except IOError as e: pass - except IndexError, e: + except IndexError as e: pass - except TypeError, e: + except TypeError as e: pass @@ -190,17 +187,17 @@ def __check_boot_version( vars, log ): def _create_cciss_dev_entries(): - def mkccissnod(dev,node): - dev = dev + " b 104 %d" % (node) - cmd = "mknod /dev/cciss/%s" %dev + def mkccissnod(dev, node): + dev = dev + " b 104 {}".format(node) + cmd = "mknod /dev/cciss/{}".format(dev) utils.sysexec_noerr(cmd) node = node + 1 return node node = 0 - for i in range(0,16): - dev = "c0d%d" % i - node = mkccissnod(dev,node) - for j in range(1,16): - subdev = dev + "p%d" % j - node = mkccissnod(subdev,node) + for i in range(0, 16): + dev = "c0d{}".format(i) + node = mkccissnod(dev, node) + for j in range(1, 16): + subdev = "{}p{}".format(dev, j) + node = mkccissnod(subdev, node) diff --git a/source/steps/InstallBootstrapFS.py b/source/steps/InstallBootstrapFS.py index e43d824..9180e55 100644 --- a/source/steps/InstallBootstrapFS.py +++ b/source/steps/InstallBootstrapFS.py @@ -65,7 +65,7 @@ def Run(vars, log): val = PARTITIONS["root"] val = PARTITIONS["swap"] val = PARTITIONS["vservers"] - except KeyError, part: + except KeyError as part: log.write("Missing partition in PARTITIONS: {}\n".format(part)) return 0 diff --git a/source/steps/InstallPartitionDisks.py b/source/steps/InstallPartitionDisks.py index 65d87dd..ca86521 100644 --- a/source/steps/InstallPartitionDisks.py +++ b/source/steps/InstallPartitionDisks.py @@ -18,7 +18,7 @@ import BootServerRequest import BootAPI import ModelOptions -def Run( vars, log ): +def Run(vars, log): """ Setup the block devices for install, partition them w/ LVM @@ -29,129 +29,129 @@ def Run( vars, log ): SWAP_SIZE the size of the swap partition """ - log.write( "\n\nStep: Install: partitioning disks.\n" ) + log.write("\n\nStep: Install: partitioning disks.\n") # make sure we have the variables we need try: - TEMP_PATH= vars["TEMP_PATH"] + TEMP_PATH = vars["TEMP_PATH"] if TEMP_PATH == "": - raise ValueError, "TEMP_PATH" + raise ValueError("TEMP_PATH") - INSTALL_BLOCK_DEVICES= vars["INSTALL_BLOCK_DEVICES"] - if( len(INSTALL_BLOCK_DEVICES) == 0 ): - raise ValueError, "INSTALL_BLOCK_DEVICES is empty" + INSTALL_BLOCK_DEVICES = vars["INSTALL_BLOCK_DEVICES"] + if(len(INSTALL_BLOCK_DEVICES) == 0): + raise ValueError("INSTALL_BLOCK_DEVICES is empty") # use vs_ROOT_SIZE or lxc_ROOT_SIZE as appropriate - varname=vars['virt']+"_ROOT_SIZE" - ROOT_SIZE= vars[varname] + varname = vars['virt'] + "_ROOT_SIZE" + ROOT_SIZE = vars[varname] if ROOT_SIZE == "" or ROOT_SIZE == 0: - raise ValueError, "ROOT_SIZE invalid" + raise ValueError("ROOT_SIZE invalid") - SWAP_SIZE= vars["SWAP_SIZE"] + SWAP_SIZE = vars["SWAP_SIZE"] if SWAP_SIZE == "" or SWAP_SIZE == 0: - raise ValueError, "SWAP_SIZE invalid" + raise ValueError("SWAP_SIZE invalid") - NODE_MODEL_OPTIONS= vars["NODE_MODEL_OPTIONS"] + NODE_MODEL_OPTIONS = vars["NODE_MODEL_OPTIONS"] - PARTITIONS= vars["PARTITIONS"] + PARTITIONS = vars["PARTITIONS"] if PARTITIONS == None: - raise ValueError, "PARTITIONS" + raise ValueError("PARTITIONS") if NODE_MODEL_OPTIONS & ModelOptions.RAWDISK: - VSERVERS_SIZE= "-1" + VSERVERS_SIZE = "-1" if "VSERVERS_SIZE" in vars: - VSERVERS_SIZE= vars["VSERVERS_SIZE"] + VSERVERS_SIZE = vars["VSERVERS_SIZE"] if VSERVERS_SIZE == "" or VSERVERS_SIZE == 0: - raise ValueError, "VSERVERS_SIZE" + raise ValueError("VSERVERS_SIZE") - except KeyError, var: - raise BootManagerException, "Missing variable in vars: %s\n" % var - except ValueError, var: - raise BootManagerException, "Variable in vars, shouldn't be: %s\n" % var + except KeyError as var: + raise BootManagerException("Missing variable in vars: {}\n".format(var)) + except ValueError as var: + raise BootManagerException("Variable in vars, shouldn't be: {}\n".format(var)) - bs_request= BootServerRequest.BootServerRequest(vars) + bs_request = BootServerRequest.BootServerRequest(vars) # disable swap if its on - utils.sysexec_noerr( "swapoff %s" % PARTITIONS["swap"], log ) + utils.sysexec_noerr("swapoff {}".format(PARTITIONS["swap"]), log) # shutdown and remove any lvm groups/volumes - utils.sysexec_noerr( "vgscan", log ) - utils.sysexec_noerr( "vgchange -ay", log ) - utils.sysexec_noerr( "lvremove -f %s" % PARTITIONS["root"], log ) - utils.sysexec_noerr( "lvremove -f %s" % PARTITIONS["swap"], log ) - utils.sysexec_noerr( "lvremove -f %s" % PARTITIONS["vservers"], log ) - utils.sysexec_noerr( "vgchange -an", log ) - utils.sysexec_noerr( "vgremove -f planetlab", log ) - - log.write( "Running vgscan for devices\n" ) - utils.sysexec_noerr( "vgscan", log ) + utils.sysexec_noerr("vgscan", log) + utils.sysexec_noerr("vgchange -ay", log) + utils.sysexec_noerr("lvremove -f {}".format(PARTITIONS["root"]), log) + utils.sysexec_noerr("lvremove -f {}".format(PARTITIONS["swap"]), log) + utils.sysexec_noerr("lvremove -f {}".format(PARTITIONS["vservers"]), log) + utils.sysexec_noerr("vgchange -an", log) + utils.sysexec_noerr("vgremove -f planetlab", log) + + log.write("Running vgscan for devices\n") + utils.sysexec_noerr("vgscan", log) - used_devices= [] + used_devices = [] INSTALL_BLOCK_DEVICES.sort() - for device in INSTALL_BLOCK_DEVICES: - if single_partition_device( device, vars, log ): + for device in INSTALL_BLOCK_DEVICES: + if single_partition_device(device, vars, log): if (len(used_devices) > 0 and (vars['NODE_MODEL_OPTIONS'] & ModelOptions.RAWDISK)): - log.write( "Running in raw disk mode, not using %s.\n" % device ) + log.write("Running in raw disk mode, not using {}.\n".format(device)) else: - used_devices.append( device ) - log.write( "Successfully initialized %s\n" % device ) + used_devices.append(device) + log.write("Successfully initialized {}\n".format(device)) else: - log.write( "Unable to partition %s, not using it.\n" % device ) + log.write("Unable to partition {], not using it.\n".format(device)) continue # list of devices to be used with vgcreate - vg_device_list= "" + vg_device_list = "" # get partitions partitions = [] for device in used_devices: - part_path= get_partition_path_from_device( device, vars, log ) + part_path = get_partition_path_from_device(device, vars, log) partitions.append(part_path) # create raid partition raid_partition = create_raid_partition(partitions, vars, log) if raid_partition != None: partitions = [raid_partition] - log.write("PARTITIONS %s\n" % str(partitions)) + log.write("PARTITIONS {}\n".format(str(partitions))) # initialize the physical volumes for part_path in partitions: - if not create_lvm_physical_volume( part_path, vars, log ): - raise BootManagerException, "Could not create lvm physical volume " \ - "on partition %s" % part_path + if not create_lvm_physical_volume(part_path, vars, log): + raise BootManagerException("Could not create lvm physical volume " + "on partition {}".format(part_path)) vg_device_list = vg_device_list + " " + part_path # create an lvm volume group - utils.sysexec( "vgcreate -s32M planetlab %s" % vg_device_list, log) + utils.sysexec("vgcreate -s32M planetlab {}".format(vg_device_list), log) # create swap logical volume - utils.sysexec( "lvcreate -L%s -nswap planetlab" % SWAP_SIZE, log ) + utils.sysexec("lvcreate -L{} -nswap planetlab".format(SWAP_SIZE), log) # check if we want a separate partition for VMs one_partition = vars['ONE_PARTITION']=='1' if (one_partition): - remaining_extents= get_remaining_extents_on_vg( vars, log ) - utils.sysexec( "lvcreate -l%s -nroot planetlab" % remaining_extents, log ) + remaining_extents = get_remaining_extents_on_vg(vars, log) + utils.sysexec("lvcreate -l{} -nroot planetlab".format(remaining_extents), log) else: - utils.sysexec( "lvcreate -L%s -nroot planetlab" % ROOT_SIZE, log ) + utils.sysexec("lvcreate -L{} -nroot planetlab".format(ROOT_SIZE), log) if vars['NODE_MODEL_OPTIONS'] & ModelOptions.RAWDISK and VSERVERS_SIZE != "-1": - utils.sysexec( "lvcreate -L%s -nvservers planetlab" % VSERVERS_SIZE, log ) - remaining_extents= get_remaining_extents_on_vg( vars, log ) - utils.sysexec( "lvcreate -l%s -nrawdisk planetlab" % remaining_extents, log ) + utils.sysexec("lvcreate -L{} -nvservers planetlab".format(VSERVERS_SIZE), log) + remaining_extents = get_remaining_extents_on_vg(vars, log) + utils.sysexec("lvcreate -l{} -nrawdisk planetlab".format(remaining_extents), log) else: # create vservers logical volume with all remaining space # first, we need to get the number of remaining extents we can use - remaining_extents= get_remaining_extents_on_vg( vars, log ) - utils.sysexec( "lvcreate -l%s -nvservers planetlab" % remaining_extents, log ) + remaining_extents = get_remaining_extents_on_vg(vars, log) + utils.sysexec("lvcreate -l{} -nvservers planetlab".format(remaining_extents), log) # activate volume group (should already be active) - #utils.sysexec( TEMP_PATH + "vgchange -ay planetlab", log ) + #utils.sysexec(TEMP_PATH + "vgchange -ay planetlab", log) # make swap - utils.sysexec( "mkswap -f %s" % PARTITIONS["swap"], log ) + utils.sysexec("mkswap -f {}".format(PARTITIONS["swap"]), log) # check if badhd option has been set option = '' @@ -168,42 +168,42 @@ def Run( vars, log ): fs = 'root' rbp = filesystems[fs] devname = PARTITIONS[fs] - log.write("formatting %s partition (%s)%s.\n" % (fs,devname,txt)) - utils.sysexec( "mkfs.ext2 -q %s -m %d -j %s" % (option,rbp,devname), log ) + log.write("formatting {} partition ({}){}.\n".format(fs, devname, txt)) + utils.sysexec("mkfs.ext2 -q {} -m {} -j {}".format(option, rbp, devname), log) # disable time/count based filesystems checks - utils.sysexec_noerr( "tune2fs -c -1 -i 0 %s" % devname, log) + utils.sysexec_noerr("tune2fs -c -1 -i 0 {}".format(devname), log) # VSERVER filesystem with btrfs to support snapshoting and stuff fs = 'vservers' rbp = filesystems[fs] devname = PARTITIONS[fs] - if vars['virt']=='vs': - log.write("formatting %s partition (%s)%s.\n" % (fs,devname,txt)) - utils.sysexec( "mkfs.ext2 -q %s -m %d -j %s" % (option,rbp,devname), log ) + if vars['virt'] == 'vs': + log.write("formatting {} partition ({}){}.\n".format(fs, devname, txt)) + utils.sysexec("mkfs.ext2 -q {} -m {} -j {}".format(option, rbp, devname)), log) # disable time/count based filesystems checks - utils.sysexec_noerr( "tune2fs -c -1 -i 0 %s" % devname, log) - elif (not one_partition): - log.write("formatting %s btrfs partition (%s).\n" % (fs,devname)) + utils.sysexec_noerr("tune2fs -c -1 -i 0 {}".format(devname), log) + elif not one_partition: + log.write("formatting {} btrfs partition ({}).\n".format(fs, devname)) # early BootCD's seem to come with a version of mkfs.btrfs that does not support -f # let's check for that before invoking it - mkfs="mkfs.btrfs" - if os.system("mkfs.btrfs --help 2>&1 | grep force")==0: - mkfs+=" -f" - mkfs+=" %s"%devname - utils.sysexec( mkfs, log ) + mkfs = "mkfs.btrfs" + if os.system("mkfs.btrfs --help 2>&1 | grep force") == 0: + mkfs += " -f" + mkfs +=" {}".format(devname) + utils.sysexec(mkfs, log) # as of 2013/02 it looks like there's not yet an option to set fsck frequency with btrfs # save the list of block devices in the log - log.write( "Block devices used (in lvm): %s\n" % repr(used_devices)) + log.write("Block devices used (in lvm): {}\n".format(repr(used_devices))) # list of block devices used may be updated - vars["INSTALL_BLOCK_DEVICES"]= used_devices + vars["INSTALL_BLOCK_DEVICES"] = used_devices return 1 import parted -def single_partition_device( device, vars, log ): +def single_partition_device(device, vars, log): """ initialize a disk by removing the old partition tables, and creating a new single partition that fills the disk. @@ -227,28 +227,28 @@ def single_partition_device( device, vars, log ): except: raise -def single_partition_device_1_x ( device, vars, log): +def single_partition_device_1_x (device, vars, log): - lvm_flag= parted.partition_flag_get_by_name('lvm') + lvm_flag = parted.partition_flag_get_by_name('lvm') try: log.write("Using pyparted 1.x\n") # wipe the old partition table - utils.sysexec( "dd if=/dev/zero of=%s bs=512 count=1" % device, log ) + utils.sysexec("dd if=/dev/zero of={} bs=512 count=1".format(device), log) # get the device - dev= parted.PedDevice.get(device) + dev = parted.PedDevice.get(device) # create a new partition table - disk= dev.disk_new_fresh(parted.disk_type_get("msdos")) + disk = dev.disk_new_fresh(parted.disk_type_get("msdos")) # create one big partition on each block device - constraint= dev.constraint_any() + constraint = dev.constraint_any() - new_part= disk.partition_new( + new_part = disk.partition_new( parted.PARTITION_PRIMARY, parted.file_system_type_get("ext2"), - 0, 1 ) + 0, 1) # make it an lvm partition new_part.set_flag(lvm_flag,1) @@ -261,19 +261,19 @@ def single_partition_device_1_x ( device, vars, log): disk.commit() del disk - except BootManagerException, e: - log.write( "BootManagerException while running: %s\n" % str(e) ) + except BootManagerException as e: + log.write("BootManagerException while running: {}\n".format(str(e))) return 0 - except parted.error, e: - log.write( "parted exception while running: %s\n" % str(e) ) + except parted.error as e: + log.write("parted exception while running: {}\n".format(str(e))) return 0 return 1 -def single_partition_device_2_x ( device, vars, log): +def single_partition_device_2_x (device, vars, log): try: log.write("Using pyparted 2.x\n") @@ -282,24 +282,24 @@ def single_partition_device_2_x ( device, vars, log): # create a new partition table def partition_table (device, part_type, fs_type): # wipe the old partition table - utils.sysexec( "dd if=/dev/zero of=%s bs=512 count=1" % device, log ) + utils.sysexec("dd if=/dev/zero of={} bs=512 count=1".format(device), log) # get the device - dev= parted.Device(device) - disk = parted.freshDisk(dev,part_type) + dev = parted.Device(device) + disk = parted.freshDisk(dev, part_type) # create one big partition on each block device - constraint= parted.constraint.Constraint (device=dev) + constraint = parted.constraint.Constraint (device=dev) geometry = parted.geometry.Geometry (device=dev, start=0, end=1) - fs = parted.filesystem.FileSystem (type=fs_type,geometry=geometry) - new_part= parted.partition.Partition (disk, type=parted.PARTITION_NORMAL, + fs = parted.filesystem.FileSystem (type=fs_type, geometry=geometry) + new_part = parted.partition.Partition (disk, type=parted.PARTITION_NORMAL, fs=fs, geometry=geometry) # make it an lvm partition new_part.setFlag(parted.PARTITION_LVM) # actually add the partition to the disk disk.addPartition(new_part, constraint) - disk.maximizePartition(new_part,constraint) + disk.maximizePartition(new_part, constraint) disk.commit() - log.write ("Current disk for %s - partition type %s\n%s\n"%(device,part_type,disk)) - log.write ("Current dev for %s\n%s\n"%(device,dev)) + log.write ("Current disk for {} - partition type {}\n{}\n".format(device, part_type, disk)) + log.write ("Current dev for {}\n{}\n".format(device, dev)) del disk try: @@ -307,8 +307,8 @@ def single_partition_device_2_x ( device, vars, log): except: partition_table (device, 'gpt', 'ext2') - except Exception, e: - log.write( "Exception inside single_partition_device_2_x : %s\n" % str(e) ) + except Exception as e: + log.write("Exception inside single_partition_device_2_x : {}\n".format(str(e))) import traceback traceback.print_exc(file=log) return 0 @@ -317,7 +317,7 @@ def single_partition_device_2_x ( device, vars, log): -def create_lvm_physical_volume( part_path, vars, log ): +def create_lvm_physical_volume(part_path, vars, log): """ make the specificed partition a lvm physical volume. @@ -326,13 +326,13 @@ def create_lvm_physical_volume( part_path, vars, log ): try: # again, wipe any old data, this time on the partition - utils.sysexec( "dd if=/dev/zero of=%s bs=512 count=1" % part_path, log ) + utils.sysexec("dd if=/dev/zero of={} bs=512 count=1".format(part_path), log) ### patch Thierry Parmentelat, required on some hardware import time time.sleep(1) - utils.sysexec( "pvcreate -ffy %s" % part_path, log ) - except BootManagerException, e: - log.write( "create_lvm_physical_volume failed.\n" ) + utils.sysexec("pvcreate -ffy {}".format(part_path), log) + except BootManagerException as e: + log.write("create_lvm_physical_volume failed.\n") return 0 return 1 @@ -344,8 +344,8 @@ def create_raid_partition(partitions, vars, log): """ raid_part = None raid_enabled = False - node_tags = BootAPI.call_api_function( vars, "GetNodeTags", - ({'node_id': vars['NODE_ID']},)) + node_tags = BootAPI.call_api_function(vars, "GetNodeTags", + ({'node_id': vars['NODE_ID']},)) for node_tag in node_tags: if node_tag['tagname'] == 'raid_enabled' and \ node_tag['value'] == '1': @@ -355,62 +355,62 @@ def create_raid_partition(partitions, vars, log): return raid_part try: - log.write( "Software raid enabled.\n" ) + log.write("Software raid enabled.\n") # wipe everything utils.sysexec_noerr("mdadm --stop /dev/md0", log) time.sleep(1) for part_path in partitions: - utils.sysexec_noerr("mdadm --zero-superblock %s " % part_path, log) + utils.sysexec_noerr("mdadm --zero-superblock {} ".format(part_path), log) # assume each partiton is on a separate disk num_parts = len(partitions) if num_parts < 2: - log.write( "Not enough disks for raid. Found: %s\n" % partitions ) - raise BootManagerException("Not enough disks for raid. Found: %s\n" % partitions) + log.write("Not enough disks for raid. Found: {}\n".format(partitions)) + raise BootManagerException("Not enough disks for raid. Found: {}\n".format(partitions)) if num_parts == 2: lvl = 1 else: - lvl = 5 + lvl = 5 # make the array part_list = " ".join(partitions) raid_part = "/dev/md0" - cmd = "mdadm --create %(raid_part)s --chunk=128 --level=raid%(lvl)s " % locals() + \ - "--raid-devices=%(num_parts)s %(part_list)s" % locals() - utils.sysexec(cmd, log) + cmd = "mdadm --create {raid_part} --chunk=128 --level=raid{lvl} "\ + "--raid-devices={num_parts} {part_list}".format(**locals()) + utils.sysexec(cmd, log) - except BootManagerException, e: + except BootManagerException as e: log.write("create_raid_partition failed.\n") raid_part = None return raid_part -def get_partition_path_from_device( device, vars, log ): +def get_partition_path_from_device(device, vars, log): """ given a device, return the path of the first partition on the device """ # those who wrote the cciss driver just had to make it difficult - cciss_test= "/dev/cciss" + cciss_test = "/dev/cciss" if device[:len(cciss_test)] == cciss_test: - part_path= device + "p1" + part_path = device + "p1" else: - part_path= device + "1" + part_path = device + "1" return part_path -def get_remaining_extents_on_vg( vars, log ): +def get_remaining_extents_on_vg(vars, log): """ return the free amount of extents on the planetlab volume group """ c_stdout, c_stdin = popen2.popen2("vgdisplay -c planetlab") - result= string.strip(c_stdout.readline()) + result = string.strip(c_stdout.readline()) c_stdout.close() c_stdin.close() - remaining_extents= string.split(result,":")[15] + remaining_extents = string.split(result, ":")[15] return remaining_extents diff --git a/source/steps/ValidateNodeInstall.py b/source/steps/ValidateNodeInstall.py index 4ae1ff8..a39ee30 100644 --- a/source/steps/ValidateNodeInstall.py +++ b/source/steps/ValidateNodeInstall.py @@ -14,7 +14,7 @@ import systeminfo import ModelOptions -def Run( vars, log ): +def Run(vars, log): """ See if a node installation is valid. More checks should certainly be done in the future, but for now, make sure that the sym links kernel-boot @@ -31,37 +31,37 @@ def Run( vars, log ): ROOT_MOUNTED the node root file system is mounted """ - log.write( "\n\nStep: Validating node installation.\n" ) + log.write("\n\nStep: Validating node installation.\n") # make sure we have the variables we need try: - SYSIMG_PATH= vars["SYSIMG_PATH"] + SYSIMG_PATH = vars["SYSIMG_PATH"] if SYSIMG_PATH == "": - raise ValueError, "SYSIMG_PATH" + raise ValueError("SYSIMG_PATH") - NODE_ID= vars["NODE_ID"] + NODE_ID = vars["NODE_ID"] if NODE_ID == "": - raise ValueError, "NODE_ID" + raise ValueError("NODE_ID") - PLCONF_DIR= vars["PLCONF_DIR"] + PLCONF_DIR = vars["PLCONF_DIR"] if PLCONF_DIR == "": - raise ValueError, "PLCONF_DIR" + raise ValueError("PLCONF_DIR") - NODE_MODEL_OPTIONS= vars["NODE_MODEL_OPTIONS"] + NODE_MODEL_OPTIONS = vars["NODE_MODEL_OPTIONS"] - PARTITIONS= vars["PARTITIONS"] + PARTITIONS = vars["PARTITIONS"] if PARTITIONS == None: - raise ValueError, "PARTITIONS" + raise ValueError("PARTITIONS") - except KeyError, var: - raise BootManagerException, "Missing variable in vars: %s\n" % var - except ValueError, var: - raise BootManagerException, "Variable in vars, shouldn't be: %s\n" % var + except KeyError as var: + raise BootManagerException("Missing variable in vars: {}\n".format(var)) + except ValueError as var: + raise BootManagerException("Variable in vars, shouldn't be: {}\n".format(var)) - ROOT_MOUNTED= 0 + ROOT_MOUNTED = 0 if vars.has_key('ROOT_MOUNTED'): - ROOT_MOUNTED= vars['ROOT_MOUNTED'] + ROOT_MOUNTED = vars['ROOT_MOUNTED'] # mount the root system image if we haven't already. # capture BootManagerExceptions during the vgscan/change and mount @@ -74,14 +74,14 @@ def Run( vars, log ): systeminfo.get_block_device_list(vars, log) try: - utils.sysexec( "vgscan", log ) - utils.sysexec( "vgchange -ay planetlab", log ) - except BootManagerException, e: - log.write( "BootManagerException during vgscan/vgchange: %s\n" % - str(e) ) + utils.sysexec("vgscan", log) + utils.sysexec("vgchange -ay planetlab", log) + except BootManagerException as e: + log.write("BootManagerException during vgscan/vgchange: {}\n"\ + .format(str(e))) return 0 - utils.makedirs( SYSIMG_PATH ) + utils.makedirs(SYSIMG_PATH) # xxx - TODO - need to fsck the btrfs partition if vars['virt'] == 'vs': @@ -92,37 +92,38 @@ def Run( vars, log ): for filesystem in filesystems_tocheck: try: # first run fsck to prevent fs corruption from hanging mount... - log.write( "fsck %s file system\n" % filesystem ) - utils.sysexec("e2fsck -v -p %s" % (PARTITIONS[filesystem]), log, fsck=True) - except BootManagerException, e: - log.write( "BootManagerException during fsck of %s (%s) filesystem : %s\n" % - (filesystem, PARTITIONS[filesystem], str(e)) ) + log.write("fsck {} file system\n".format(filesystem)) + utils.sysexec("e2fsck -v -p {}".format(PARTITIONS[filesystem]), log, fsck=True) + except BootManagerException as e: + log.write("BootManagerException during fsck of {} ({}) filesystem : {}\n"\ + .format(filesystem, PARTITIONS[filesystem], str(e))) try: - log.write( "Trying to recover filesystem errors on %s\n" % filesystem ) - utils.sysexec("e2fsck -v -y %s" % (PARTITIONS[filesystem]),log, fsck=True) - except BootManagerException, e: - log.write( "BootManagerException during trying to recover filesystem errors on %s (%s) filesystem : %s\n" % - (filesystem, PARTITIONS[filesystem], str(e)) ) + log.write("Trying to recover filesystem errors on {}\n".format(filesystem)) + utils.sysexec("e2fsck -v -y {}".format(PARTITIONS[filesystem]), log, fsck=True) + except BootManagerException as e: + log.write("BootManagerException while trying to recover" + "filesystem errors on {} ({}) filesystem : {}\n" + .format(filesystem, PARTITIONS[filesystem], str(e))) return -1 else: # disable time/count based filesystems checks - utils.sysexec_noerr( "tune2fs -c -1 -i 0 %s" % PARTITIONS[filesystem], log) + utils.sysexec_noerr("tune2fs -c -1 -i 0 {}".format(PARTITIONS[filesystem]), log) try: # then attempt to mount them - log.write( "mounting root file system\n" ) - utils.sysexec("mount -t ext3 %s %s" % (PARTITIONS["root"],SYSIMG_PATH),log) - except BootManagerException, e: - log.write( "BootManagerException during mount of /root: %s\n" % str(e) ) + log.write("mounting root file system\n") + utils.sysexec("mount -t ext3 {} {}".format(PARTITIONS["root"], SYSIMG_PATH),log) + except BootManagerException as e: + log.write("BootManagerException during mount of /root: {}\n".format(str(e))) return -2 try: - PROC_PATH = "%s/proc" % SYSIMG_PATH + PROC_PATH = "{}/proc".format(SYSIMG_PATH) utils.makedirs(PROC_PATH) - log.write( "mounting /proc\n" ) - utils.sysexec( "mount -t proc none %s" % PROC_PATH, log ) - except BootManagerException, e: - log.write( "BootManagerException during mount of /proc: %s\n" % str(e) ) + log.write("mounting /proc\n") + utils.sysexec("mount -t proc none {}".format(PROC_PATH), log) + except BootManagerException as e: + log.write("BootManagerException during mount of /proc: {}\n".format(str(e))) return -2 @@ -130,35 +131,37 @@ def Run( vars, log ): if (not one_partition): try: - VSERVERS_PATH = "%s/vservers" % SYSIMG_PATH + VSERVERS_PATH = "{}/vservers".format(SYSIMG_PATH) utils.makedirs(VSERVERS_PATH) - log.write( "mounting vservers partition in root file system\n" ) - if vars['virt']=='vs': - utils.sysexec("mount -t ext3 %s %s" % (PARTITIONS["vservers"], VSERVERS_PATH), log) + log.write("mounting vservers partition in root file system\n") + if vars['virt'] == 'vs': + utils.sysexec("mount -t ext3 {} {}".format(PARTITIONS["vservers"], VSERVERS_PATH), log) else: - utils.sysexec("mount -t btrfs %s %s" % (PARTITIONS["vservers"], VSERVERS_PATH), log) - except BootManagerException, e: - log.write( "BootManagerException during mount of /vservers: %s\n" % str(e) ) + utils.sysexec("mount -t btrfs {} {}".format(PARTITIONS["vservers"], VSERVERS_PATH), log) + except BootManagerException as e: + log.write("BootManagerException while mounting /vservers: {}\n".format(str(e))) return -2 - ROOT_MOUNTED= 1 - vars['ROOT_MOUNTED']= 1 + ROOT_MOUNTED = 1 + vars['ROOT_MOUNTED'] = 1 # check if the base kernel is installed # these 2 links are created by our kernel's post-install scriplet log.write("Checking for a custom kernel\n") try: if vars['virt'] == 'vs': - os.stat("%s/boot/kernel-boot" % SYSIMG_PATH) + os.stat("{}/boot/kernel-boot".format(SYSIMG_PATH)) else: try: - kversion = os.popen("chroot %s rpm -qa kernel | tail -1 | cut -c 8-" % SYSIMG_PATH).read().rstrip() - os.stat("%s/boot/vmlinuz-%s" % (SYSIMG_PATH,kversion)) + kversion = os.popen("chroot {} rpm -qa kernel | tail -1 | cut -c 8-"\ + .format(SYSIMG_PATH)).read().rstrip() + os.stat("{}/boot/vmlinuz-{}".format(SYSIMG_PATH, kversion)) major_version = int(kversion[0]) # Check if the string looks like a kernel version except: - kversion = os.popen("ls -lrt %s/lib/modules | tail -1 | awk '{print $9;}'"%SYSIMG_PATH).read().rstrip() - except OSError, e: - log.write( "Couldn't locate base kernel (you might be using the stock kernel).\n") + kversion = os.popen("ls -lrt {}/lib/modules | tail -1 | awk '{print $9;}'"\ + .format(SYSIMG_PATH)).read().rstrip() + except OSError as e: + log.write("Couldn't locate base kernel (you might be using the stock kernel).\n") return -3 # check if the model specified kernel is installed @@ -166,28 +169,28 @@ def Run( vars, log ): if NODE_MODEL_OPTIONS & ModelOptions.SMP: option = 'smp' try: - os.stat("%s/boot/kernel-boot%s" % (SYSIMG_PATH,option)) - except OSError, e: + os.stat("{}/boot/kernel-boot{}".format(SYSIMG_PATH, option)) + except OSError as e: # smp kernel is not there; remove option from modeloptions # such that the rest of the code base thinks we are just # using the base kernel. NODE_MODEL_OPTIONS = NODE_MODEL_OPTIONS & ~ModelOptions.SMP vars["NODE_MODEL_OPTIONS"] = NODE_MODEL_OPTIONS - log.write( "WARNING: Couldn't locate smp kernel.\n") + log.write("WARNING: Couldn't locate smp kernel.\n") # write out the node id to /etc/planetlab/node_id. if this fails, return # 0, indicating the node isn't a valid install. try: - node_id_file_path= "%s/%s/node_id" % (SYSIMG_PATH,PLCONF_DIR) - node_id_file= file( node_id_file_path, "w" ) - node_id_file.write( str(NODE_ID) ) + node_id_file_path = "{}/{}/node_id".format(SYSIMG_PATH, PLCONF_DIR) + node_id_file = file(node_id_file_path, "w") + node_id_file.write(str(NODE_ID)) node_id_file.close() - node_id_file= None - log.write( "Updated /etc/planetlab/node_id\n" ) - except IOError, e: - log.write( "Unable to write out /etc/planetlab/node_id\n" ) + node_id_file = None + log.write("Updated /etc/planetlab/node_id\n") + except IOError as e: + log.write("Unable to write out /etc/planetlab/node_id\n") return 0 - log.write( "Node installation appears to be ok\n" ) + log.write("Node installation appears to be ok\n") return 1