import utils
# all output is written to this file
-BM_NODE_LOG= "/tmp/bm.log"
+BM_NODE_LOG = "/tmp/bm.log"
VARS_FILE = "configuration"
# the new contents of PATH when the boot manager is running
# removed. everything after the = to the end of the line is
# the value
vars = {}
- vars_file= file(filename,'r')
+ vars_file = file(filename,'r')
validConfFile = True
for line in vars_file:
# if its a comment or a whitespace line, ignore
if line[:1] == "#" or string.strip(line) == "":
continue
- parts= string.split(line,"=")
+ parts = string.split(line,"=")
if len(parts) != 2:
validConfFile = False
- raise Exception( "Invalid line in vars file: %s" % line )
+ raise Exception("Invalid line in vars file: {}".format(line))
- name= string.strip(parts[0])
- value= string.strip(parts[1])
- value= value.replace("'", "") # remove quotes
- value= value.replace('"', "") # remove quotes
- vars[name]= value
+ name = string.strip(parts[0])
+ value = string.strip(parts[1])
+ value = value.replace("'", "") # remove quotes
+ value = value.replace('"', "") # remove quotes
+ vars[name] = value
vars_file.close()
if not validConfFile:
- raise Exception( "Unable to read configuration vars." )
+ raise Exception("Unable to read configuration vars.")
# find out which directory we are running it, and set a variable
# for that. future steps may need to get files out of the bootmanager
# directory
- current_dir= os.getcwd()
- vars['BM_SOURCE_DIR']= current_dir
+ current_dir = os.getcwd()
+ vars['BM_SOURCE_DIR'] = current_dir
return vars
##############################
class log:
- format="%H:%M:%S(%Z) "
+ format = "%H:%M:%S(%Z) "
def __init__(self, OutputFilePath=None):
try:
- self.OutputFile = open( OutputFilePath, "w")
+ self.OutputFile = open(OutputFilePath, "w")
self.OutputFilePath = OutputFilePath
except:
- print( "bootmanager log : Unable to open output file %r, continuing"%OutputFilePath )
+ print("bootmanager log : Unable to open output file {}, continuing"\
+ .format(OutputFilePath))
self.OutputFile = None
self.VARS = None
vars = read_configuration_file(VARS_FILE)
self.VARS = vars
except Exception, e:
- self.LogEntry( str(e) )
+ self.LogEntry(str(e))
return
- def LogEntry(self, str, inc_newline = 1, display_screen = 1 ):
+ def LogEntry(self, str, inc_newline = 1, display_screen = 1):
now = time.strftime(log.format, time.localtime())
if self.OutputFile:
self.OutputFile.write(now + str)
self.write(traceback.format_exc())
# bm log uploading is available back again, as of nodeconfig-5.0-2
- def Upload( self, extra_file=None ):
+ def Upload(self, extra_file=None):
"""
upload the contents of the log to the server
"""
if self.OutputFile is not None:
self.OutputFile.flush()
- self.LogEntry( "Uploading logs to %s" % self.VARS['UPLOAD_LOG_SCRIPT'] )
+ self.LogEntry("Uploading logs to {}".format(self.VARS['UPLOAD_LOG_SCRIPT']))
self.OutputFile.close()
self.OutputFile= None
- hostname= self.VARS['INTERFACE_SETTINGS']['hostname'] + "." + \
- self.VARS['INTERFACE_SETTINGS']['domainname']
+ hostname = self.VARS['INTERFACE_SETTINGS']['hostname'] + "." + \
+ self.VARS['INTERFACE_SETTINGS']['domainname']
bs_request = BootServerRequest.BootServerRequest(self.VARS)
try:
# this was working until f10
# NOTE: for code-reuse, evoke the bash function 'upload_logs';
# by adding --login, bash reads .bash_profile before execution.
# Also, never fail, since this is an optional feature.
- utils.sysexec_noerr( """bash --login -c "upload_logs %s" """ % extra_file, self)
+ utils.sysexec_noerr("""bash --login -c "upload_logs {}" """.format(extra_file), self)
##############################
self.forceState = forceState
# the main logging point
- self.LOG= log
+ self.LOG = log
# set to 1 if we can run after initialization
self.CAN_RUN = 0
if log.VARS:
# this contains a set of information used and updated by each step
- self.VARS= log.VARS
+ self.VARS = log.VARS
else:
return
# not sure what the current PATH is set to, replace it with what
# we know will work with all the boot cds
- os.environ['PATH']= string.join(BIN_PATH,":")
+ os.environ['PATH'] = string.join(BIN_PATH,":")
- self.CAN_RUN= 1
+ self.CAN_RUN = 1
def Run(self):
"""
def _nodeNotInstalled(message='MSG_NODE_NOT_INSTALLED'):
# called by the _xxxState() functions below upon failure
- self.VARS['RUN_LEVEL']= 'failboot'
+ self.VARS['RUN_LEVEL'] = 'failboot'
notify = getattr(notify_messages, message)
- self.VARS['STATE_CHANGE_NOTIFY']= 1
- self.VARS['STATE_CHANGE_NOTIFY_MESSAGE']= notify
+ self.VARS['STATE_CHANGE_NOTIFY'] = 1
+ self.VARS['STATE_CHANGE_NOTIFY_MESSAGE'] = notify
raise BootManagerException, notify
def _bootRun():
except:
pass
- InstallInit.Run( self.VARS, self.LOG )
- ret = ValidateNodeInstall.Run( self.VARS, self.LOG )
+ InstallInit.Run(self.VARS, self.LOG)
+ ret = ValidateNodeInstall.Run(self.VARS, self.LOG)
if ret == 1:
# Thierry - feb. 2013 turning off WriteModprobeConfig for now on lxc
# for one thing this won't work at all with f18, as modules.pcimap
# and second, in any case it's been years now that modprobe.conf was deprecated
# so most likely this code has no actual effect
if self.VARS['virt'] == 'vs':
- WriteModprobeConfig.Run( self.VARS, self.LOG )
- WriteNetworkConfig.Run( self.VARS, self.LOG )
- CheckForNewDisks.Run( self.VARS, self.LOG )
- SendHardwareConfigToPLC.Run( self.VARS, self.LOG )
- ChainBootNode.Run( self.VARS, self.LOG )
+ WriteModprobeConfig.Run(self.VARS, self.LOG)
+ WriteNetworkConfig.Run(self.VARS, self.LOG)
+ CheckForNewDisks.Run(self.VARS, self.LOG)
+ SendHardwareConfigToPLC.Run(self.VARS, self.LOG)
+ ChainBootNode.Run(self.VARS, self.LOG)
elif ret == -1:
_nodeNotInstalled('MSG_NODE_FILESYSTEM_CORRUPT')
elif ret == -2:
# the min. hardware requirements are met, install the
# software, and upon correct installation will switch too
# 'boot' state and chainboot into the production system
- if not CheckHardwareRequirements.Run( self.VARS, self.LOG ):
- self.VARS['RUN_LEVEL']= 'failboot'
+ if not CheckHardwareRequirements.Run(self.VARS, self.LOG):
+ self.VARS['RUN_LEVEL'] = 'failboot'
raise BootManagerException, "Hardware requirements not met."
# runinstaller
- InstallInit.Run( self.VARS, self.LOG )
InstallPartitionDisks.Run( self.VARS, self.LOG )
- InstallBootstrapFS.Run( self.VARS, self.LOG )
- InstallWriteConfig.Run( self.VARS, self.LOG )
- InstallUninitHardware.Run( self.VARS, self.LOG )
- self.VARS['BOOT_STATE']= 'boot'
- self.VARS['STATE_CHANGE_NOTIFY']= 1
- self.VARS['STATE_CHANGE_NOTIFY_MESSAGE']= \
+ InstallInit.Run(self.VARS, self.LOG)
+ InstallBootstrapFS.Run(self.VARS, self.LOG)
+ InstallWriteConfig.Run(self.VARS, self.LOG)
+ InstallUninitHardware.Run(self.VARS, self.LOG)
+ self.VARS['BOOT_STATE'] = 'boot'
+ self.VARS['STATE_CHANGE_NOTIFY'] = 1
+ self.VARS['STATE_CHANGE_NOTIFY_MESSAGE'] = \
notify_messages.MSG_INSTALL_FINISHED
- AnsibleHook.Run( self.VARS, self.LOG )
- UpdateBootStateWithPLC.Run( self.VARS, self.LOG )
+ AnsibleHook.Run(self.VARS, self.LOG)
+ UpdateBootStateWithPLC.Run(self.VARS, self.LOG)
_bootRun()
def _installRun():
# machine, switch to 'reinstall' state and then invoke the reinstall
# logic. See reinstallState logic comments for further
# details.
- if not ConfirmInstallWithUser.Run( self.VARS, self.LOG ):
+ if not ConfirmInstallWithUser.Run(self.VARS, self.LOG):
return 0
- self.VARS['BOOT_STATE']= 'reinstall'
+ self.VARS['BOOT_STATE'] = 'reinstall'
- AnsibleHook.Run( self.VARS, self.LOG )
+ AnsibleHook.Run(self.VARS, self.LOG)
_reinstallRun()
def _debugRun(state='failboot'):
# implements debug logic, which starts the sshd and just waits around
- self.VARS['RUN_LEVEL']=state
- StartDebug.Run( self.VARS, self.LOG )
+ self.VARS['RUN_LEVEL'] = state
+ StartDebug.Run(self.VARS, self.LOG)
# fsck/mount fs if present, and ignore return value if it's not.
- ValidateNodeInstall.Run( self.VARS, self.LOG )
+ ValidateNodeInstall.Run(self.VARS, self.LOG)
def _badstateRun():
# should never happen; log event
- self.LOG.write( "\nInvalid BOOT_STATE = %s\n" % self.VARS['BOOT_STATE'])
+ self.LOG.write("\nInvalid BOOT_STATE = {}\n".format(self.VARS['BOOT_STATE']))
_debugRun()
# setup state -> function hash table
success = 0
try:
- InitializeBootManager.Run( self.VARS, self.LOG )
- ReadNodeConfiguration.Run( self.VARS, self.LOG )
- AuthenticateWithPLC.Run( self.VARS, self.LOG )
- UpdateLastBootOnce.Run( self.VARS, self.LOG )
- StartRunlevelAgent.Run( self.VARS, self.LOG )
- GetAndUpdateNodeDetails.Run( self.VARS, self.LOG )
+ InitializeBootManager.Run(self.VARS, self.LOG)
+ ReadNodeConfiguration.Run(self.VARS, self.LOG)
+ AuthenticateWithPLC.Run(self.VARS, self.LOG)
+ UpdateLastBootOnce.Run(self.VARS, self.LOG)
+ StartRunlevelAgent.Run(self.VARS, self.LOG)
+ GetAndUpdateNodeDetails.Run(self.VARS, self.LOG)
# override machine's current state from the command line
if self.forceState is not None:
- self.VARS['BOOT_STATE']= self.forceState
- UpdateBootStateWithPLC.Run( self.VARS, self.LOG )
+ self.VARS['BOOT_STATE'] = self.forceState
+ UpdateBootStateWithPLC.Run(self.VARS, self.LOG)
stateRun = BootManager.NodeRunStates.get(self.VARS['BOOT_STATE'],_badstateRun)
stateRun()
success = 1
- except KeyError, e:
- self.LOG.write( "\n\nKeyError while running: %s\n" % str(e) )
+ except KeyError as e:
+ self.LOG.write("\n\nKeyError while running: {}\n".format(e))
self.LOG.print_stack ()
- except BootManagerException, e:
- self.LOG.write( "\n\nException while running: %s\n" % str(e) )
+ except BootManagerException as e:
+ self.LOG.write("\n\nException while running: {}\n".format(e))
self.LOG.print_stack ()
- except BootManagerAuthenticationException, e:
- self.LOG.write( "\n\nFailed to Authenticate Node: %s\n" % str(e) )
+ except BootManagerAuthenticationException as e:
+ self.LOG.write("\n\nFailed to Authenticate Node: {}\n".format(e))
self.LOG.print_stack ()
# sets /tmp/CANCEL_BOOT flag
- StartDebug.Run(self.VARS, self.LOG )
+ StartDebug.Run(self.VARS, self.LOG)
# Return immediately b/c any other calls to API will fail
return success
except:
- self.LOG.write( "\n\nImplementation Error\n")
+ self.LOG.write("\n\nImplementation Error\n")
self.LOG.print_stack ()
if not success:
try:
_debugRun()
except BootManagerException, e:
- self.LOG.write( "\n\nException while running: %s\n" % str(e) )
+ self.LOG.write("\n\nException while running: {}\n".format(e))
except:
- self.LOG.write( "\n\nImplementation Error\n")
+ self.LOG.write("\n\nImplementation Error\n")
traceback.print_exc(file=self.LOG.OutputFile)
traceback.print_exc()
# utils.breakpoint ("Entering BootManager::main")
# set to 1 if error occurred
- error= 0
+ error = 0
# all output goes through this class so we can save it and post
# the data back to PlanetLab central
- LOG= log( BM_NODE_LOG )
+ LOG = log(BM_NODE_LOG)
# NOTE: assume CWD is BM's source directory, but never fail
utils.sysexec_noerr("./setup_bash_history_scripts.sh", LOG)
- LOG.LogEntry( "BootManager started at: %s" % \
- time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime()) )
+ LOG.LogEntry("BootManager started at: {}"\
+ .format(time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime())))
try:
forceState = None
if BootManager.NodeRunStates.has_key(fState):
forceState = fState
else:
- LOG.LogEntry("FATAL: cannot force node run state to=%s" % fState)
+ LOG.LogEntry("FATAL: cannot force node run state to={}".format(fState))
error = 1
except:
traceback.print_exc(file=LOG.OutputFile)
traceback.print_exc()
if error:
- LOG.LogEntry( "BootManager finished at: %s" % \
- time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime()) )
+ LOG.LogEntry("BootManager finished at: {}"\
+ .format(time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime())))
LOG.Upload()
return error
try:
- bm= BootManager(LOG,forceState)
+ bm = BootManager(LOG, forceState)
if bm.CAN_RUN == 0:
- LOG.LogEntry( "Unable to initialize BootManager." )
+ LOG.LogEntry("Unable to initialize BootManager.")
else:
- LOG.LogEntry( "Running version %s of BootManager." % bm.VARS['VERSION'] )
- success= bm.Run()
+ LOG.LogEntry("Running version {} of BootManager.".format(bm.VARS['VERSION']))
+ success = bm.Run()
if success:
- LOG.LogEntry( "\nDone!" );
+ LOG.LogEntry("\nDone!");
else:
- LOG.LogEntry( "\nError occurred!" );
+ LOG.LogEntry("\nError occurred!");
error = 1
except:
traceback.print_exc(file=LOG.OutputFile)
traceback.print_exc()
- LOG.LogEntry( "BootManager finished at: %s" % \
- time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime()) )
+ LOG.LogEntry("BootManager finished at: {}"\
+ .format(time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime())))
LOG.Upload()
return error
import BootAPI
-def Run( vars, log ):
+def Run(vars, log):
"""
Download core + extensions bootstrapfs tarballs and install on the hard drive
are mounted.
"""
- log.write( "\n\nStep: Install: bootstrapfs tarball.\n" )
+ log.write("\n\nStep: Install: bootstrapfs tarball.\n")
# make sure we have the variables we need
try:
- SYSIMG_PATH= vars["SYSIMG_PATH"]
+ SYSIMG_PATH = vars["SYSIMG_PATH"]
if SYSIMG_PATH == "":
- raise ValueError, "SYSIMG_PATH"
+ raise ValueError("SYSIMG_PATH")
- PARTITIONS= vars["PARTITIONS"]
+ PARTITIONS = vars["PARTITIONS"]
if PARTITIONS == None:
- raise ValueError, "PARTITIONS"
+ raise ValueError("PARTITIONS")
- NODE_ID= vars["NODE_ID"]
+ NODE_ID = vars["NODE_ID"]
if NODE_ID == "":
- raise ValueError, "NODE_ID"
+ raise ValueError("NODE_ID")
- VERSION=vars['VERSION'] or 'unknown'
+ VERSION = vars['VERSION'] or 'unknown'
- 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))
try:
# make sure the required partitions exist
- val= PARTITIONS["root"]
- val= PARTITIONS["swap"]
- val= PARTITIONS["vservers"]
+ val = PARTITIONS["root"]
+ val = PARTITIONS["swap"]
+ val = PARTITIONS["vservers"]
except KeyError, part:
- log.write( "Missing partition in PARTITIONS: %s\n" % part )
+ log.write("Missing partition in PARTITIONS: {}\n".format(part))
return 0
- bs_request= BootServerRequest.BootServerRequest(vars)
+ bs_request = BootServerRequest.BootServerRequest(vars)
- log.write( "turning on swap space\n" )
- utils.sysexec( "swapon %s" % PARTITIONS["swap"], log )
+ log.write("turning on swap space\n")
+ utils.sysexec("swapon {}".format(PARTITIONS["swap"]), log)
# make sure the sysimg dir is present
- utils.makedirs( SYSIMG_PATH )
+ utils.makedirs(SYSIMG_PATH)
- log.write( "mounting root file system\n" )
- utils.sysexec( "mount -t ext3 %s %s" % (PARTITIONS["root"],SYSIMG_PATH), log )
+ log.write("mounting root file system\n")
+ utils.sysexec("mount -t ext3 {} {}".format(PARTITIONS["root"], SYSIMG_PATH), log)
fstype = 'ext3' if vars['virt']=='vs' else 'btrfs'
one_partition = vars['ONE_PARTITION']=='1'
if (not one_partition):
- log.write( "mounting vserver partition in root file system (type %s)\n"%fstype )
- utils.makedirs( SYSIMG_PATH + "/vservers" )
- utils.sysexec( "mount -t %s %s %s/vservers" % \
- (fstype, PARTITIONS["vservers"], SYSIMG_PATH), log )
+ log.write("mounting vserver partition in root file system (type {})\n".format(fstype))
+ utils.makedirs(SYSIMG_PATH + "/vservers")
+ utils.sysexec("mount -t {} {} {}/vservers"\
+ .format(fstype, PARTITIONS["vservers"], SYSIMG_PATH), log)
if vars['virt']=='lxc':
# NOTE: btrfs quota is supported from version: >= btrfs-progs-0.20 (f18+)
# older versions will not recongize the 'quota' command.
- log.write( "Enabling btrfs quota on %s/vservers\n"%SYSIMG_PATH )
- utils.sysexec_noerr( "btrfs quota enable %s/vservers" % SYSIMG_PATH )
+ log.write("Enabling btrfs quota on {}/vservers\n".format(SYSIMG_PATH))
+ utils.sysexec_noerr("btrfs quota enable {}/vservers".format(SYSIMG_PATH))
- vars['ROOT_MOUNTED']= 1
+ vars['ROOT_MOUNTED'] = 1
# this is now retrieved in GetAndUpdateNodeDetails
nodefamily = vars['nodefamily']
# the 'plain' option is for tests mostly
plain = vars['plain']
if plain:
- download_suffix=".tar"
- uncompress_option=""
+ download_suffix = ".tar"
+ uncompress_option = ""
log.write("Using plain bootstrapfs images\n")
else:
- download_suffix=".tar.bz2"
- uncompress_option="-j"
+ download_suffix = ".tar.bz2"
+ uncompress_option = "-j"
log.write("Using compressed bootstrapfs images\n")
- log.write ("Using nodefamily=%s\n"%(nodefamily))
+ log.write ("Using nodefamily={}\n".format(nodefamily))
if not extensions:
log.write("Installing only core software\n")
else:
- log.write("Requested extensions %r\n" % extensions)
+ log.write("Requested extensions {}\n".format(extensions))
bootstrapfs_names = [ nodefamily ] + extensions
for name in bootstrapfs_names:
- tarball = "bootstrapfs-%s%s"%(name,download_suffix)
- source_file= "/boot/%s" % (tarball)
- dest_file= "%s/%s" % (SYSIMG_PATH, tarball)
+ tarball = "bootstrapfs-{}{}".format(name, download_suffix)
+ source_file = "/boot/{}".format(tarball)
+ dest_file = "{}/{}".format(SYSIMG_PATH, tarball)
- source_hash_file= "/boot/%s.sha1sum" % (tarball)
- dest_hash_file= "%s/%s.sha1sum" % (SYSIMG_PATH, tarball)
+ source_hash_file = "/boot/{}.sha1sum".format(tarball)
+ dest_hash_file = "{}/{}.sha1sum".format(SYSIMG_PATH, tarball)
- time_beg=time.time()
- log.write( "downloading %s\n" % source_file )
+ time_beg = time.time()
+ log.write("downloading {}\n".format(source_file))
# 30 is the connect timeout, 14400 is the max transfer time in
# seconds (4 hours)
- result = bs_request.DownloadFile( source_file, None, None,
+ result = bs_request.DownloadFile(source_file, None, None,
1, 1, dest_file,
30, 14400)
- time_end=time.time()
- duration=int(time_end-time_beg)
- log.write("Done downloading (%s seconds)\n"%duration)
+ time_end = time.time()
+ duration = int(time_end - time_beg)
+ log.write("Done downloading ({} seconds)\n".format(duration))
if result:
# Download SHA1 checksum file
- log.write( "downloading sha1sum for %s\n"%source_file)
- result = bs_request.DownloadFile( source_hash_file, None, None,
+ log.write("downloading sha1sum for {}\n".format(source_file))
+ result = bs_request.DownloadFile(source_hash_file, None, None,
1, 1, dest_hash_file,
30, 14400)
- log.write( "verifying sha1sum for %s\n"%source_file)
+ log.write("verifying sha1sum for {}\n".format(source_file))
if not utils.check_file_hash(dest_file, dest_hash_file):
- raise BootManagerException, "FATAL: SHA1 checksum does not match between %s and %s" % (source_file, source_hash_file)
+ raise BootManagerException(
+ "FATAL: SHA1 checksum does not match between {} and {}"\
+ .format(source_file, source_hash_file))
- time_beg=time.time()
- log.write( "extracting %s in %s\n" % (dest_file,SYSIMG_PATH) )
- result = utils.sysexec( "tar -C %s -xpf %s %s" % (SYSIMG_PATH,dest_file,uncompress_option), log )
- time_end=time.time()
- duration=int(time_end-time_beg)
- log.write( "Done extracting (%s seconds)\n"%duration)
- utils.removefile( dest_file )
+ time_beg = time.time()
+ log.write("extracting {} in {}\n".format(dest_file, SYSIMG_PATH))
+ result = utils.sysexec("tar -C {} -xpf {} {}".format(SYSIMG_PATH, dest_file, uncompress_option), log)
+ time_end = time.time()
+ duration = int(time_end - time_beg)
+ log.write("Done extracting ({} seconds)\n".format(duration))
+ utils.removefile(dest_file)
else:
# the main tarball is required
if name == nodefamily:
- raise BootManagerException, "FATAL: Unable to download main tarball %s from server." % \
- source_file
+ raise BootManagerException(
+ "FATAL: Unable to download main tarball {} from server."\
+ .format(source_file))
# for extensions, just print a warning
else:
- log.write("WARNING: tarball for extension %s not found\n"%(name))
+ log.write("WARNING: tarball for extension {} not found\n".format(name))
# copy resolv.conf from the base system into our temp dir
# so DNS lookups work correctly while we are chrooted
- log.write( "Copying resolv.conf to temp dir\n" )
- utils.sysexec( "cp /etc/resolv.conf %s/etc/" % SYSIMG_PATH, log )
+ log.write("Copying resolv.conf to temp dir\n")
+ utils.sysexec("cp /etc/resolv.conf {}/etc/".format(SYSIMG_PATH), log)
# Copy the boot server certificate(s) and GPG public key to
# /usr/boot in the temp dir.
- log.write( "Copying boot server certificates and public key\n" )
+ log.write("Copying boot server certificates and public key\n")
if os.path.exists("/usr/boot"):
utils.makedirs(SYSIMG_PATH + "/usr")
shutil.copytree("/usr/bootme", SYSIMG_PATH + "/mnt/cdrom/bootme")
# ONE_PARTITION => new distribution type
- if (vars['ONE_PARTITION']!='1'):
+ if (vars['ONE_PARTITION'] != '1'):
# Import the GPG key into the RPM database so that RPMS can be verified
utils.makedirs(SYSIMG_PATH + "/etc/pki/rpm-gpg")
- utils.sysexec("gpg --homedir=/root --export --armor" \
- " --no-default-keyring --keyring %s/usr/boot/pubring.gpg" \
- " >%s/etc/pki/rpm-gpg/RPM-GPG-KEY-planetlab" % (SYSIMG_PATH, SYSIMG_PATH), log)
+ utils.sysexec("gpg --homedir=/root --export --armor"
+ " --no-default-keyring --keyring {}/usr/boot/pubring.gpg"
+ " > {}/etc/pki/rpm-gpg/RPM-GPG-KEY-planetlab".format(SYSIMG_PATH, SYSIMG_PATH), log)
utils.sysexec_chroot(SYSIMG_PATH, "rpm --import /etc/pki/rpm-gpg/RPM-GPG-KEY-planetlab", log)
# keep a log on the installed hdd
- stamp=file(SYSIMG_PATH + "/bm-install.txt",'w')
- now=time.strftime("%Y-%b-%d @ %H:%M %Z", time.gmtime())
- stamp.write("Hard drive installed by BootManager %s\n"%VERSION)
- stamp.write("Finished extraction of bootstrapfs on %s\n"%now)
- stamp.write("Using nodefamily %s\n"%nodefamily)
+ stamp = file(SYSIMG_PATH + "/bm-install.txt", 'a')
+ now = time.strftime("%Y-%b-%d @ %H:%M %Z", time.gmtime())
+ stamp.write("Hard drive installed by BootManager {}\n".format(VERSION))
+ stamp.write("Finished extraction of bootstrapfs on {}\n".format(now))
+ stamp.write("Using nodefamily {}\n".format(nodefamily))
stamp.close()
return 1
import BootAPI
import ModelOptions
-def Run( vars, log ):
+def Run(vars, log):
"""
Writes out the following configuration files for the node:
"""
- log.write( "\n\nStep: Install: Writing configuration files.\n" )
+ log.write( "\n\nStep: Install: Writing configuration files.\n")
# make sure we have the variables we need
try:
- VERSION= vars["VERSION"]
+ VERSION = vars["VERSION"]
if VERSION == "":
- raise ValueError, "VERSION"
+ raise ValueError("VERSION")
- SYSIMG_PATH= vars["SYSIMG_PATH"]
+ SYSIMG_PATH = vars["SYSIMG_PATH"]
if SYSIMG_PATH == "":
- raise ValueError, "SYSIMG_PATH"
+ raise ValueError("SYSIMG_PATH")
- PARTITIONS= vars["PARTITIONS"]
+ PARTITIONS = vars["PARTITIONS"]
if PARTITIONS == None:
- raise ValueError, "PARTITIONS"
+ raise ValueError("PARTITIONS")
- PLCONF_DIR= vars["PLCONF_DIR"]
+ PLCONF_DIR = vars["PLCONF_DIR"]
if PLCONF_DIR == "":
- raise ValueError, "PLCONF_DIR"
+ raise ValueError("PLCONF_DIR")
- INTERFACE_SETTINGS= vars["INTERFACE_SETTINGS"]
+ INTERFACE_SETTINGS = vars["INTERFACE_SETTINGS"]
if INTERFACE_SETTINGS == "":
- raise ValueError, "INTERFACE_SETTINGS"
+ raise ValueError("INTERFACE_SETTINGS")
except KeyError, var:
- raise BootManagerException, "Missing variable in vars: %s\n" % var
+ raise BootManagerException("Missing variable in vars: {}\n".format(var))
except ValueError, var:
- raise BootManagerException, "Variable in vars, shouldn't be: %s\n" % var
+ raise BootManagerException("Variable in vars, shouldn't be: {}\n".format(var))
- log.write( "Setting local time to UTC\n" )
- utils.sysexec_chroot( SYSIMG_PATH,
- "ln -sf /usr/share/zoneinfo/UTC /etc/localtime", log )
+ log.write("Setting local time to UTC\n")
+ utils.sysexec_chroot(SYSIMG_PATH,
+ "ln -sf /usr/share/zoneinfo/UTC /etc/localtime", log)
- log.write( "Creating system directory %s\n" % PLCONF_DIR )
- if not utils.makedirs( "%s/%s" % (SYSIMG_PATH,PLCONF_DIR) ):
- log.write( "Unable to create directory\n" )
+ log.write("Creating system directory {}\n".format(PLCONF_DIR))
+ if not utils.makedirs("{}/{}".format(SYSIMG_PATH, PLCONF_DIR)):
+ log.write("Unable to create directory\n")
return 0
- log.write( "Writing system /etc/fstab\n" )
- fstab= file( "%s/etc/fstab" % SYSIMG_PATH, "w" )
- fstab.write( "%s none swap sw 0 0\n" % \
- PARTITIONS["mapper-swap"] )
- fstab.write( "%s / ext3 defaults 1 1\n" % \
- PARTITIONS["mapper-root"] )
- if (vars['ONE_PARTITION']!='1'):
+ log.write("Writing system /etc/fstab\n")
+ fstab = file("{}/etc/fstab".format(SYSIMG_PATH), "w")
+ fstab.write("{} none swap sw 0 0\n"\
+ .format(PARTITIONS["mapper-swap"]))
+ fstab.write("{} / ext3 defaults 1 1\n"\
+ .format(PARTITIONS["mapper-root"]))
+ if (vars['ONE_PARTITION'] != '1'):
if vars['virt'] == 'vs':
- fstab.write( "%s /vservers ext3 tagxid,defaults 1 2\n" % \
- PARTITIONS["mapper-vservers"] )
+ fstab.write("{} /vservers ext3 tagxid,defaults 1 2\n"\
+ .format(PARTITIONS["mapper-vservers"]))
else:
- fstab.write( "%s /vservers btrfs defaults 1 2\n" % \
- PARTITIONS["mapper-vservers"] )
- fstab.write( "none /proc proc defaults 0 0\n" )
- fstab.write( "none /dev/shm tmpfs defaults 0 0\n" )
- fstab.write( "none /dev/pts devpts defaults 0 0\n" )
+ fstab.write("{} /vservers btrfs defaults 1 2\n"\
+ .format(PARTITIONS["mapper-vservers"]))
+ fstab.write("none /proc proc defaults 0 0\n")
+ fstab.write("none /dev/shm tmpfs defaults 0 0\n")
+ fstab.write("none /dev/pts devpts defaults 0 0\n")
fstab.close()
- log.write( "Writing system /etc/issue\n" )
- issue= file( "%s/etc/issue" % SYSIMG_PATH, "w" )
- issue.write( "PlanetLab Node: \\n\n" )
- issue.write( "Kernel \\r on an \\m\n" )
- issue.write( "http://www.planet-lab.org\n\n" )
+ log.write("Writing system /etc/issue\n")
+ issue= file("{}/etc/issue".format(SYSIMG_PATH), "w")
+ issue.write("PlanetLab Node: \\n\n")
+ issue.write("Kernel \\r on an \\m\n")
+ issue.write("http://www.planet-lab.org\n\n")
issue.close()
- if (vars['ONE_PARTITION']!='1'):
- log.write( "Setting up authentication (non-ssh)\n" )
- utils.sysexec_chroot( SYSIMG_PATH, "authconfig --nostart --kickstart --enablemd5 " \
- "--enableshadow", log )
- utils.sysexec( "sed -e 's/^root\:\:/root\:*\:/g' " \
- "%s/etc/shadow > %s/etc/shadow.new" % \
- (SYSIMG_PATH,SYSIMG_PATH), log )
- utils.sysexec_chroot( SYSIMG_PATH, "mv " \
- "/etc/shadow.new /etc/shadow", log )
- utils.sysexec_chroot( SYSIMG_PATH, "chmod 400 /etc/shadow", log )
+ if (vars['ONE_PARTITION'] != '1'):
+ log.write("Setting up authentication (non-ssh)\n")
+ utils.sysexec_chroot(SYSIMG_PATH, "authconfig --nostart --kickstart --enablemd5 " \
+ "--enableshadow", log)
+ utils.sysexec("sed -e 's/^root\:\:/root\:*\:/g' " \
+ "{}/etc/shadow > {}/etc/shadow.new".format(SYSIMG_PATH, SYSIMG_PATH), log)
+ utils.sysexec_chroot(SYSIMG_PATH, "mv " \
+ "/etc/shadow.new /etc/shadow", log)
+ utils.sysexec_chroot(SYSIMG_PATH, "chmod 400 /etc/shadow", log)
# if we are setup with dhcp, copy the current /etc/resolv.conf into
# the system image so we can run programs inside that need network access
- method= ""
+ method = ""
try:
- method= vars['INTERFACE_SETTINGS']['method']
+ method = vars['INTERFACE_SETTINGS']['method']
except:
pass
if method == "dhcp":
- utils.sysexec( "cp /etc/resolv.conf %s/etc/" % SYSIMG_PATH, log )
+ utils.sysexec("cp /etc/resolv.conf {}/etc/".format(SYSIMG_PATH), log)
- log.write( "Writing node install version\n" )
- utils.makedirs( "%s/etc/planetlab" % SYSIMG_PATH )
- ver= file( "%s/etc/planetlab/install_version" % SYSIMG_PATH, "w" )
- ver.write( "%s\n" % VERSION )
+ log.write("Writing node install version\n")
+ utils.makedirs("{}/etc/planetlab".format(SYSIMG_PATH))
+ ver = file("{}/etc/planetlab/install_version".format(SYSIMG_PATH), "w")
+ ver.write("{}\n".format(VERSION))
ver.close()
- log.write( "Creating ssh host keys\n" )
- key_gen_prog= "/usr/bin/ssh-keygen"
+ log.write("Creating ssh host keys\n")
+ key_gen_prog = "/usr/bin/ssh-keygen"
- log.write( "Generating SSH1 RSA host key:\n" )
- key_file= "/etc/ssh/ssh_host_key"
- utils.sysexec_chroot( SYSIMG_PATH, "%s -q -t rsa1 -f %s -C '' -N ''" %
- (key_gen_prog,key_file), log )
- utils.sysexec( "chmod 600 %s/%s" % (SYSIMG_PATH,key_file), log )
- utils.sysexec( "chmod 644 %s/%s.pub" % (SYSIMG_PATH,key_file), log )
+ log.write("Generating SSH1 RSA host key:\n")
+ key_file = "/etc/ssh/ssh_host_key"
+ utils.sysexec_chroot(SYSIMG_PATH, "{} -q -t rsa1 -f {} -C '' -N ''"\
+ .format(key_gen_prog, key_file), log)
+ utils.sysexec("chmod 600 {}/{}".format(SYSIMG_PATH, key_file), log)
+ utils.sysexec("chmod 644 {}/{}.pub".format(SYSIMG_PATH, key_file), log)
- log.write( "Generating SSH2 RSA host key:\n" )
- key_file= "/etc/ssh/ssh_host_rsa_key"
- utils.sysexec_chroot( SYSIMG_PATH, "%s -q -t rsa -f %s -C '' -N ''" %
- (key_gen_prog,key_file), log )
- utils.sysexec( "chmod 600 %s/%s" % (SYSIMG_PATH,key_file), log )
- utils.sysexec( "chmod 644 %s/%s.pub" % (SYSIMG_PATH,key_file), log )
+ log.write("Generating SSH2 RSA host key:\n")
+ key_file = "/etc/ssh/ssh_host_rsa_key"
+ utils.sysexec_chroot(SYSIMG_PATH, "{} -q -t rsa -f {} -C '' -N ''"\
+ .format(key_gen_prog, key_file), log)
+ utils.sysexec("chmod 600 {}/{}".format(SYSIMG_PATH, key_file), log)
+ utils.sysexec("chmod 644 {}/{}.pub".format(SYSIMG_PATH, key_file), log)
- log.write( "Generating SSH2 DSA host key:\n" )
- key_file= "/etc/ssh/ssh_host_dsa_key"
- utils.sysexec_chroot( SYSIMG_PATH, "%s -q -t dsa -f %s -C '' -N ''" %
- (key_gen_prog,key_file), log )
- utils.sysexec( "chmod 600 %s/%s" % (SYSIMG_PATH,key_file), log )
- utils.sysexec( "chmod 644 %s/%s.pub" % (SYSIMG_PATH,key_file), log )
+ log.write("Generating SSH2 DSA host key:\n")
+ key_file = "/etc/ssh/ssh_host_dsa_key"
+ utils.sysexec_chroot(SYSIMG_PATH, "{} -q -t dsa -f {} -C '' -N ''"\
+ .format(key_gen_prog,key_file), log)
+ utils.sysexec("chmod 600 {}/{}".format(SYSIMG_PATH,key_file), log)
+ utils.sysexec("chmod 644 {}/{}.pub".format(SYSIMG_PATH, key_file), log)
return 1
git://git.onelab.eu / bootmanager.git / commitdiff