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 (file)
--- 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):
 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 = ''
         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
 
 
     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"]
     # 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):
             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
         pass

diff --git a/source/steps/AuthenticateWithPLC.py b/source/steps/AuthenticateWithPLC.py
index 72d5ec2..2e71a1c 100644 (file)
--- a/source/steps/AuthenticateWithPLC.py
+++ b/source/steps/AuthenticateWithPLC.py
@@ -13,10 +13,10 @@ from Exceptions import *
 import BootAPI
 
 
 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.
     """
     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
     """
 
     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:
 
     # 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:
 
     try:

-        authorized= BootAPI.call_api_function( vars, "BootCheckAuthentication", () )
+        authorized = BootAPI.call_api_function(vars, "BootCheckAuthentication", ())

         if authorized == 1:
         if authorized == 1:

-            log.write( "Authentication successful.\n" )
+            log.write("Authentication successful.\n")

 
             try:
 
             try:

-                os.unlink( AUTH_FAILURE_COUNT_FILE )
-            except OSError, e:
+                os.unlink(AUTH_FAILURE_COUNT_FILE)
+            except OSError as e:

                 pass
             
             return 1
                 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']:
     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
             return 1
         else:
             raise
 
     # increment auth failure

-    auth_failure_count= 0
+    auth_failure_count = 0

     try:
     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:
     except IOError:
         pass
     except ValueError:


@@ -76,16 +76,16 @@ def Run( vars, log ):
     auth_failure_count += 1
 
     try:
     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:
         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 (file)
--- a/source/steps/ChainBootNode.py
+++ b/source/steps/ChainBootNode.py
@@ -23,7 +23,7 @@ import UpdateNodeConfiguration
 import StopRunlevelAgent
 import MakeInitrd
 
 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.
     """
     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
     """
 
     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:
 
     # make sure we have the variables we need
     try:

-        SYSIMG_PATH= vars["SYSIMG_PATH"]
+        SYSIMG_PATH = vars["SYSIMG_PATH"]

         if 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 == "":
         if PLCONF_DIR == "":

-            raise ValueError, "PLCONF_DIR"
+            raise ValueError("PLCONF_DIR")

 
         # its ok if this is blank
 
         # 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:
         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'):
     if vars.has_key('ROOT_MOUNTED'):

-        ROOT_MOUNTED= vars['ROOT_MOUNTED']
+        ROOT_MOUNTED = vars['ROOT_MOUNTED']

     
     if ROOT_MOUNTED == 0:
     
     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)
         
 
         # 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:
         
 
     # 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.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
 
     # 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
 
     # 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"
         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
 
         # 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"
             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':
 
     # 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
 
     # 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:
     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.close()

-        ssh_host_key_file= None
-    except IOError, e:
+        ssh_host_key_file = None
+    except IOError as e:

         pass
 
         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
 
 
     # get the kernel version


@@ -155,124 +155,127 @@ def Run( vars, log ):
     if NODE_MODEL_OPTIONS & ModelOptions.SMP:
         option = 'smp'
 
     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':
     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:
     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
             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
         # 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/<kversion>/initrd
         # f20: uses a uid of some kind, e.g. /boot/543f88c129de443baaa65800cf3927ce/<kversion>/initrd

-        candidates.append ("/boot/*/%s/initrd"%(kversion))
+        candidates.append ("/boot/*/{}/initrd".format(kversion))

         # Ubuntu:
         # 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:
         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:
         if initrd:

-            utils.sysexec( "cp %s /tmp/initrd" % initrd, log )
+            utils.sysexec("cp {} /tmp/initrd".format(initrd), log)

         else:
         else:

-            raise Exception,"Unable to locate initrd - bailing out"
+            raise Exception("Unable to locate initrd - bailing out")

 
     BootAPI.save(vars)
 
 
     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.
 
     # 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
 
     # 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.
     
 
     # 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':
         
     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:
     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 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:
         
         for line in modules:

-            module= string.strip(line)
+            module = string.strip(line)

             if module in blacklist :
             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 != "":
             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:
                 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:
 
     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
 
         # 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])
 
                 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
 
         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
 
                 # 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:
                 # 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:
                     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:
     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:
     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()
         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 
 
         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.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
 
         # 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
 
     return

diff --git a/source/steps/CheckForNewDisks.py b/source/steps/CheckForNewDisks.py
index 09a001d..480db27 100644 (file)
--- a/source/steps/CheckForNewDisks.py
+++ b/source/steps/CheckForNewDisks.py
@@ -17,7 +17,7 @@ import os
 import ModelOptions
 
 
 import ModelOptions
 
 

-def Run( vars, log ):
+def Run(vars, log):

     """
     Find any new large block devices we can add to the vservers volume group
     
     """
     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
     """
 
     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:
 
     # make sure we have the variables we need
     try:

-        SYSIMG_PATH= vars["SYSIMG_PATH"]
+        SYSIMG_PATH = vars["SYSIMG_PATH"]

         if 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:
         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
     
     # will contain the new devices to add to the volume group

-    new_devices= []
+    new_devices = []

 
     # total amount of new space in gb
 
     # total amount of new space in gb

-    extended_gb_size= 0
+    extended_gb_size = 0

     
     for device in all_devices.keys():
 
     
     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":
 
         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:
             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:
             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
 
             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
 
         # 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:
         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).
             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:
         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:
             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
         
                 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
 
             continue
 

-        log.write( "Successfully partitioned %s\n" % device )
+        log.write("Successfully partitioned {}\n".format(device))

 
         if NODE_MODEL_OPTIONS & ModelOptions.RAWDISK:
 
         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
 
             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
 
             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:
 
         
 
     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
         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
             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:
 
         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.
                 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):
             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
 
                 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)
             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:
 
             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:
                 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:
                 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
         res = 1
 
     return res

diff --git a/source/steps/CheckHardwareRequirements.py b/source/steps/CheckHardwareRequirements.py
index 39f8785..a3f8677 100644 (file)
--- a/source/steps/CheckHardwareRequirements.py
+++ b/source/steps/CheckHardwareRequirements.py
@@ -18,7 +18,7 @@ import notify_messages
 import BootAPI
 
 
 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
     """
     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
     """
 
     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:
         
     try:

-        MINIMUM_MEMORY= int(vars["MINIMUM_MEMORY"])
+        MINIMUM_MEMORY = int(vars["MINIMUM_MEMORY"])

         if 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")
 
         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
 
         # 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
 
     # 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:
     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:
         
     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:
             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:
                 
             if sent == 0:

-                log.write( "Unable to notify site contacts of problem.\n" )
+                log.write("Unable to notify site contacts of problem.\n")

             else:
             else:

-                log.write( "Notified contacts of problem.\n" )
+                log.write("Notified contacts of problem.\n")

                 
             return 0
         else:
                 
             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:
     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)
 
 
 
     # 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
 
     # 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:
 
     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:
         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:
             
         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
 
 
         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
     # 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():
 
 
     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)
         
         # 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:
             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]
             try:
                 del install_devices[device]

-            except KeyError, e:
+            except KeyError as e:

                 pass
             continue
 
         if readonly:
                 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]
             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.
                 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:
 
 
     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:
         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:
             
         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
 
         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
 
     # 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
 
 
     # 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:
     # 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:
             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:
             
             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:
 
             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
 
     return 1

diff --git a/source/steps/ConfirmInstallWithUser.py b/source/steps/ConfirmInstallWithUser.py
index 8890fcc..7144e15 100644 (file)
--- 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.
 
     """
     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.
     """
 
     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:
     
     try:

-        confirmation= ""
-        install= 0
+        confirmation = ""
+        install = 0

         print welcome_message
         
         while confirmation not in ("yes","no"):
         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
         pass

-    except KeyboardInterrupt, e:
+    except KeyboardInterrupt as e:

         pass
     
     if install:
         pass
     
     if install:

-        log.write( "\nUser accepted install.\n" )
+        log.write("\nUser accepted install.\n")

     else:
     else:

-        log.write( "\nUser canceled install.\n" )
+        log.write("\nUser canceled install.\n")

         
     return install
         
     return install

diff --git a/source/steps/GetAndUpdateNodeDetails.py b/source/steps/GetAndUpdateNodeDetails.py
index 58e3bf8..b6d20a6 100644 (file)
--- a/source/steps/GetAndUpdateNodeDetails.py
+++ b/source/steps/GetAndUpdateNodeDetails.py
@@ -13,7 +13,7 @@ from Exceptions import *
 import BootAPI
 import ModelOptions
 
 import BootAPI
 import ModelOptions
 

-def Run( vars, log ):
+def Run(vars, log):

     """
 
     Contact PLC and get the attributes for this node. Also, parse in
     """
 
     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.
     """
 
     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:
 
     # 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 == "":
         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 == "":
         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 == "":
         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 == "":
         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['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'] 
     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
     
     # 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:
 
     # 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
 
     # 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:
     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:
             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:
     
     # 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:
     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 = [
         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
 
     # 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:
 
     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()
             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
 
     return 1

diff --git a/source/steps/InitializeBootManager.py b/source/steps/InitializeBootManager.py
index c98f960..dfe3399 100644 (file)
--- a/source/steps/InitializeBootManager.py
+++ b/source/steps/InitializeBootManager.py
@@ -16,17 +16,17 @@ import utils
 
 
 # locations of boot os version files
 
 
 # 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
 
 # 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 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)
     """
     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
     """
 
     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().
 
     # 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
 
     # 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
     # 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:
     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:
     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"):
     
     # 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
 
     # 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
 
 
 
         
     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
     """
     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
 
     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_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:
         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
         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
 
                MINIMUM_BOOT_VERSION:
             return 1
 

-    except IOError, e:
+    except IOError as e:

         pass
         pass

-    except IndexError, e:
+    except IndexError as e:

         pass
         pass

-    except TypeError, e:
+    except TypeError as e:

         pass
 
 
     try:
         # check for a 2.x version first
         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_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':
         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:
         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:
         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
 
            MINIMUM_BOOT_VERSION:
             return 1
 

-    except IOError, e:
+    except IOError as e:

         pass
         pass

-    except IndexError, e:
+    except IndexError as e:

         pass
         pass

-    except TypeError, e:
+    except TypeError as e:

         pass
 
 
         pass
 
 


@@ -190,17 +187,17 @@ def __check_boot_version( vars, log ):
 
 
 def _create_cciss_dev_entries():
 
 
 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
         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 (file)
--- 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"]
         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   
 
         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 (file)
--- a/source/steps/InstallPartitionDisks.py
+++ b/source/steps/InstallPartitionDisks.py
@@ -18,7 +18,7 @@ import BootServerRequest
 import BootAPI
 import ModelOptions
 
 import BootAPI
 import ModelOptions
 

-def Run( vars, log ):
+def Run(vars, log):

     """
     Setup the block devices for install, partition them w/ LVM
     
     """
     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
     """
 
     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:
         
     # make sure we have the variables we need
     try:

-        TEMP_PATH= vars["TEMP_PATH"]
+        TEMP_PATH = vars["TEMP_PATH"]

         if 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
 
         # 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:
         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:
         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:
         if PARTITIONS == None:

-            raise ValueError, "PARTITIONS"
+            raise ValueError("PARTITIONS")

 
         if NODE_MODEL_OPTIONS & ModelOptions.RAWDISK:
 
         if NODE_MODEL_OPTIONS & ModelOptions.RAWDISK:

-            VSERVERS_SIZE= "-1"
+            VSERVERS_SIZE = "-1"

             if "VSERVERS_SIZE" in vars:
             if "VSERVERS_SIZE" in vars:

-                VSERVERS_SIZE= vars["VSERVERS_SIZE"]
+                VSERVERS_SIZE = vars["VSERVERS_SIZE"]

                 if VSERVERS_SIZE == "" or VSERVERS_SIZE == 0:
                 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
 
     
     # 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
 
     # 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()
 
     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)):
             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:
             else:

-                used_devices.append( device )
-                log.write( "Successfully initialized %s\n" % device )
+                used_devices.append(device)
+                log.write("Successfully initialized {}\n".format(device))

         else:
         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
             continue
 
     # list of devices to be used with vgcreate

-    vg_device_list= ""
+    vg_device_list = ""

 
     # get partitions
     partitions = []
     for device in used_devices:
 
     # 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]      
         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:
     # 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
         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
 
     # 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):
 
     # 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:
     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":
         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
         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)
 
     # 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
 
     # 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 = ''
 
     # check if badhd option has been set
     option = ''


@@ -168,42 +168,42 @@ def Run( vars, log ):
     fs = 'root'
     rbp = filesystems[fs]
     devname = PARTITIONS[fs]
     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
     # 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]
 
     # 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
         # 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
         # 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
         # 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
 
     # list of block devices used may be updated

-    vars["INSTALL_BLOCK_DEVICES"]= used_devices
+    vars["INSTALL_BLOCK_DEVICES"] = used_devices

 
     return 1
 
 
 import parted
 
     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.
     """
     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
 
     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
     
     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
 
         # get the device

-        dev= parted.PedDevice.get(device)
+        dev = parted.PedDevice.get(device)

 
         # create a new partition table
 
         # 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
 
         # 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"),
             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)
 
         # 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
             
         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
 
         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
 
 
 
         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")
 
     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
         # 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
             # 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
             # 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)
             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)
                                                   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()
             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:
             del disk
 
         try:


@@ -307,8 +307,8 @@ def single_partition_device_2_x ( device, vars, log):
         except:
             partition_table (device, 'gpt', 'ext2')
 
         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
         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.
 
     """
     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
 
     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)
         ### 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
         return 0
 
     return 1


@@ -344,8 +344,8 @@ def create_raid_partition(partitions, vars, log):
     """ 
     raid_part = None
     raid_enabled = False
     """ 
     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':
     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:
         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:
         # 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:
 
         # 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:
         if num_parts == 2:
             lvl = 1
         else:

-            lvl = 5   
+            lvl = 5

         
         # make the array
         part_list = " ".join(partitions)
         raid_part = "/dev/md0"
         
         # 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  
 
 
         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
     """
     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:
     if device[:len(cciss_test)] == cciss_test:

-        part_path= device + "p1"
+        part_path = device + "p1"

     else:
     else:

-        part_path= device + "1"
+        part_path = device + "1"

 
     return part_path
 
 
 
 
     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")
     """
     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()
     c_stdout.close()
     c_stdin.close()

-    remaining_extents= string.split(result,":")[15]
+    remaining_extents = string.split(result, ":")[15]

     
     return remaining_extents
     
     return remaining_extents

diff --git a/source/steps/ValidateNodeInstall.py b/source/steps/ValidateNodeInstall.py
index 4ae1ff8..a39ee30 100644 (file)
--- a/source/steps/ValidateNodeInstall.py
+++ b/source/steps/ValidateNodeInstall.py
@@ -14,7 +14,7 @@ import systeminfo
 import ModelOptions
 
 
 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
     """
     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
     """
 
     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:
 
     # make sure we have the variables we need
     try:

-        SYSIMG_PATH= vars["SYSIMG_PATH"]
+        SYSIMG_PATH = vars["SYSIMG_PATH"]

         if 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 == "":
         if NODE_ID == "":

-            raise ValueError, "NODE_ID"
+            raise ValueError("NODE_ID")

 
 

-        PLCONF_DIR= vars["PLCONF_DIR"]
+        PLCONF_DIR = vars["PLCONF_DIR"]

         if 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:
         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'):
     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
 
     # 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:
         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
             
             return 0
             

-        utils.makedirs( SYSIMG_PATH )
+        utils.makedirs(SYSIMG_PATH)

 
         # xxx - TODO - need to fsck the btrfs partition
         if vars['virt'] == 'vs':
 
         # 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...
         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:
                 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
                     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
 
         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:
             return -2
             
         try:

-            PROC_PATH = "%s/proc" % SYSIMG_PATH
+            PROC_PATH = "{}/proc".format(SYSIMG_PATH)

             utils.makedirs(PROC_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
 
 
             return -2
 
 


@@ -130,35 +131,37 @@ def Run( vars, log ):
 
         if (not one_partition):
             try:
 
         if (not one_partition):
             try:

-                VSERVERS_PATH = "%s/vservers" % SYSIMG_PATH
+                VSERVERS_PATH = "{}/vservers".format(SYSIMG_PATH)

                 utils.makedirs(VSERVERS_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:
                 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
 
                 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':
         
     # 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:
         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:
                 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
         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:
     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
             # 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:
             
     # 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.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
 
         return 0
 

-    log.write( "Node installation appears to be ok\n" )
+    log.write("Node installation appears to be ok\n")

     
     return 1
     
     return 1