source/BootManager.py

   1 #!/usr/bin/python -u
   2 #
   3 # Copyright (c) 2003 Intel Corporation
   4 # All rights reserved.
   5 #
   6 # Copyright (c) 2004-2006 The Trustees of Princeton University
   7 # All rights reserved.
   8
   9 import string
  10 import sys, os, traceback
  11 import time
  12 import gzip
  13
  14 from steps import *
  15 from Exceptions import *
  16 import notify_messages
  17 import BootServerRequest
  18 import utils
  19
  20 # all output is written to this file
  21 BM_NODE_LOG= "/tmp/bm.log"
  22 VARS_FILE = "configuration"
  23
  24 # the new contents of PATH when the boot manager is running
  25 BIN_PATH= ('/usr/local/bin',
  26            '/usr/local/sbin',
  27            '/usr/bin',
  28            '/usr/sbin',
  29            '/bin',
  30            '/sbin')
  31
  32 def read_configuration_file(filename):
  33     # read in and store all variables in VARS_FILE into each line
  34     # is in the format name=val (any whitespace around the = is
  35     # removed. everything after the = to the end of the line is
  36     # the value
  37     vars = {}
  38     vars_file= file(filename,'r')
  39     validConfFile = True
  40     for line in vars_file:
  41         # if its a comment or a whitespace line, ignore
  42         if line[:1] == "#" or string.strip(line) == "":
  43             continue
  44
  45         parts= string.split(line,"=")
  46         if len(parts) != 2:
  47             validConfFile = False
  48             raise Exception( "Invalid line in vars file: %s" % line )
  49
  50         name= string.strip(parts[0])
  51         value= string.strip(parts[1])
  52         value= value.replace("'", "")   # remove quotes
  53         value= value.replace('"', "")   # remove quotes
  54         vars[name]= value
  55
  56     vars_file.close()
  57     if not validConfFile:
  58         raise Exception( "Unable to read configuration vars." )
  59
  60     # find out which directory we are running it, and set a variable
  61     # for that. future steps may need to get files out of the bootmanager
  62     # directory
  63     current_dir= os.getcwd()
  64     vars['BM_SOURCE_DIR']= current_dir
  65
  66     return vars
  67
  68 ##############################
  69 class log:
  70
  71     format="%H:%M:%S(%Z) "
  72
  73     def __init__( self, OutputFilePath= None ):
  74         try:
  75             self.OutputFile= open( OutputFilePath, "w")
  76             self.OutputFilePath= OutputFilePath
  77         except:
  78             print( "bootmanager log : Unable to open output file %r, continuing"%OutputFilePath )
  79             self.OutputFile= None
  80
  81         self.VARS = None
  82         try:
  83             vars = read_configuration_file(VARS_FILE)
  84             self.VARS = vars
  85         except Exception, e:
  86             self.LogEntry( str(e) )
  87             return
  88
  89     def LogEntry( self, str, inc_newline= 1, display_screen= 1 ):
  90         now=time.strftime(log.format, time.localtime())
  91         if self.OutputFile:
  92             self.OutputFile.write( now+str )
  93         if display_screen:
  94             sys.stdout.write( now+str )
  95
  96         if inc_newline:
  97             if display_screen:
  98                 sys.stdout.write( "\n" )
  99             if self.OutputFile:
 100                 self.OutputFile.write( "\n" )
 101
 102         if self.OutputFile:
 103             self.OutputFile.flush()
 104
 105     def write( self, str ):
 106         """
 107         make log behave like a writable file object (for traceback
 108         prints)
 109         """
 110         self.LogEntry( str, 0, 1 )
 111
 112     # bm log uploading is available back again, as of nodeconfig-5.0-2
 113     def Upload( self, extra_file=None ):
 114         """
 115         upload the contents of the log to the server
 116         """
 117         if self.OutputFile is not None:
 118             self.OutputFile.flush()
 119
 120             self.LogEntry( "Uploading logs to %s" % self.VARS['UPLOAD_LOG_SCRIPT'] )
 121
 122             self.OutputFile.close()
 123             self.OutputFile= None
 124
 125             hostname= self.VARS['INTERFACE_SETTINGS']['hostname'] + "." + \
 126                       self.VARS['INTERFACE_SETTINGS']['domainname']
 127             bs_request = BootServerRequest.BootServerRequest(self.VARS)
 128             try:
 129                 # this was working until f10
 130                 bs_request.MakeRequest(PartialPath = self.VARS['UPLOAD_LOG_SCRIPT'],
 131                                        GetVars = None, PostVars = None,
 132                                        DoSSL = True, DoCertCheck = True,
 133                                        FormData = ["log=@" + self.OutputFilePath,
 134                                                    "hostname=" + hostname,
 135                                                    "type=bm.log"])
 136             except:
 137                 # new pycurl
 138                 import pycurl
 139                 bs_request.MakeRequest(PartialPath = self.VARS['UPLOAD_LOG_SCRIPT'],
 140                                        GetVars = None, PostVars = None,
 141                                        DoSSL = True, DoCertCheck = True,
 142                                        FormData = [('log',(pycurl.FORM_FILE, self.OutputFilePath)),
 143                                                    ("hostname",hostname),
 144                                                    ("type","bm.log")])
 145         if extra_file is not None:
 146             # NOTE: for code-reuse, evoke the bash function 'upload_logs';
 147             # by adding --login, bash reads .bash_profile before execution.
 148             # Also, never fail, since this is an optional feature.
 149             utils.sysexec_noerr( """bash --login -c "upload_logs %s" """ % extra_file, self)
 150
 151
 152 ##############################
 153 class BootManager:
 154
 155     # file containing initial variables/constants
 156
 157     # the set of valid node run states
 158     NodeRunStates = {'reinstall':None,
 159                      'boot':None,
 160                      'safeboot':None,
 161                      'disabled':None,
 162                      }
 163
 164     def __init__(self, log, forceState):
 165         # override machine's current state from the command line
 166         self.forceState = forceState
 167
 168         # the main logging point
 169         self.LOG= log
 170
 171         # set to 1 if we can run after initialization
 172         self.CAN_RUN = 0
 173
 174         if log.VARS:
 175             # this contains a set of information used and updated by each step
 176             self.VARS= log.VARS
 177         else:
 178             return
 179
 180         # not sure what the current PATH is set to, replace it with what
 181         # we know will work with all the boot cds
 182         os.environ['PATH']= string.join(BIN_PATH,":")
 183
 184         self.CAN_RUN= 1
 185
 186     def Run(self):
 187         """
 188         core boot manager logic.
 189
 190         the way errors are handled is as such: if any particular step
 191         cannot continue or unexpectibly fails, an exception is thrown.
 192         in this case, the boot manager cannot continue running.
 193
 194         these step functions can also return a 0/1 depending on whether
 195         or not it succeeded. In the case of steps like ConfirmInstallWithUser,
 196         a 0 is returned and no exception is thrown if the user chose not
 197         to confirm the install. The same goes with the CheckHardwareRequirements.
 198         If requriements not met, but tests were succesfull, return 0.
 199
 200         for steps that run within the installer, they are expected to either
 201         complete succesfully and return 1, or throw an exception.
 202
 203         For exact return values and expected operations, see the comments
 204         at the top of each of the invididual step functions.
 205         """
 206
 207         def _nodeNotInstalled(message='MSG_NODE_NOT_INSTALLED'):
 208             # called by the _xxxState() functions below upon failure
 209             self.VARS['RUN_LEVEL']= 'failboot'
 210             notify = getattr(notify_messages, message)
 211             self.VARS['STATE_CHANGE_NOTIFY']= 1
 212             self.VARS['STATE_CHANGE_NOTIFY_MESSAGE']= notify
 213             raise BootManagerException, notify
 214
 215         def _bootRun():
 216             # implements the boot logic, which consists of first
 217             # double checking that the node was properly installed,
 218             # checking whether someone added or changed disks, and
 219             # then finally chain boots.
 220
 221             # starting the fallback/debug ssh daemon for safety:
 222             # if the node install somehow hangs, or if it simply takes ages,
 223             # we can still enter and investigate
 224             try:
 225                 StartDebug.Run(self.VARS, self.LOG, last_resort = False)
 226             except:
 227                 pass
 228
 229             InstallInit.Run( self.VARS, self.LOG )
 230             ret = ValidateNodeInstall.Run( self.VARS, self.LOG )
 231             if ret == 1:
 232 # Thierry - feb. 2013 turning off WriteModprobeConfig for now on lxc
 233 # for one thing this won't work at all with f18, as modules.pcimap
 234 # has disappeared (Daniel suggested modules.aliases could be used instead)
 235 # and second, in any case it's been years now that modprobe.conf was deprecated
 236 # so most likely this code has no actual effect
 237                 if self.VARS['virt'] == 'vs':
 238                     WriteModprobeConfig.Run( self.VARS, self.LOG )
 239                 WriteNetworkConfig.Run( self.VARS, self.LOG )
 240                 CheckForNewDisks.Run( self.VARS, self.LOG )
 241                 SendHardwareConfigToPLC.Run( self.VARS, self.LOG )
 242                 ChainBootNode.Run( self.VARS, self.LOG )
 243             elif ret == -1:
 244                 _nodeNotInstalled('MSG_NODE_FILESYSTEM_CORRUPT')
 245             elif ret == -2:
 246                 _nodeNotInstalled('MSG_NODE_MOUNT_FAILED')
 247             elif ret == -3:
 248                 _nodeNotInstalled('MSG_NODE_MISSING_KERNEL')
 249             else:
 250                 _nodeNotInstalled()
 251
 252         def _reinstallRun():
 253
 254             # starting the fallback/debug ssh daemon for safety:
 255             # if the node install somehow hangs, or if it simply takes ages,
 256             # we can still enter and investigate
 257             try:
 258                 StartDebug.Run(self.VARS, self.LOG, last_resort = False)
 259             except:
 260                 pass
 261
 262             # implements the reinstall logic, which will check whether
 263             # the min. hardware requirements are met, install the
 264             # software, and upon correct installation will switch too
 265             # 'boot' state and chainboot into the production system
 266             if not CheckHardwareRequirements.Run( self.VARS, self.LOG ):
 267                 self.VARS['RUN_LEVEL']= 'failboot'
 268                 raise BootManagerException, "Hardware requirements not met."
 269
 270             # runinstaller
 271             InstallInit.Run( self.VARS, self.LOG )
 272             InstallPartitionDisks.Run( self.VARS, self.LOG )
 273             InstallBootstrapFS.Run( self.VARS, self.LOG )
 274             InstallWriteConfig.Run( self.VARS, self.LOG )
 275             InstallUninitHardware.Run( self.VARS, self.LOG )
 276             self.VARS['BOOT_STATE']= 'boot'
 277             self.VARS['STATE_CHANGE_NOTIFY']= 1
 278             self.VARS['STATE_CHANGE_NOTIFY_MESSAGE']= \
 279                  notify_messages.MSG_INSTALL_FINISHED
 280             UpdateBootStateWithPLC.Run( self.VARS, self.LOG )
 281             _bootRun()
 282
 283         def _installRun():
 284             # implements the new install logic, which will first check
 285             # with the user whether it is ok to install on this
 286             # machine, switch to 'reinstall' state and then invoke the reinstall
 287             # logic.  See reinstallState logic comments for further
 288             # details.
 289             if not ConfirmInstallWithUser.Run( self.VARS, self.LOG ):
 290                 return 0
 291             self.VARS['BOOT_STATE']= 'reinstall'
 292             _reinstallRun()
 293
 294         def _debugRun(state='failboot'):
 295             # implements debug logic, which starts the sshd and just waits around
 296             self.VARS['RUN_LEVEL']=state
 297             StartDebug.Run( self.VARS, self.LOG )
 298             # fsck/mount fs if present, and ignore return value if it's not.
 299             ValidateNodeInstall.Run( self.VARS, self.LOG )
 300
 301         def _badstateRun():
 302             # should never happen; log event
 303             self.LOG.write( "\nInvalid BOOT_STATE = %s\n" % self.VARS['BOOT_STATE'])
 304             _debugRun()
 305
 306         # setup state -> function hash table
 307         BootManager.NodeRunStates['reinstall']  = _reinstallRun
 308         BootManager.NodeRunStates['boot']       = _bootRun
 309         BootManager.NodeRunStates['safeboot']   = lambda : _debugRun('safeboot')
 310         BootManager.NodeRunStates['disabled']   = lambda : _debugRun('disabled')
 311
 312         success = 0
 313         try:
 314             InitializeBootManager.Run( self.VARS, self.LOG )
 315             ReadNodeConfiguration.Run( self.VARS, self.LOG )
 316             AuthenticateWithPLC.Run( self.VARS, self.LOG )
 317             UpdateLastBootOnce.Run( self.VARS, self.LOG )
 318             StartRunlevelAgent.Run( self.VARS, self.LOG )
 319             GetAndUpdateNodeDetails.Run( self.VARS, self.LOG )
 320
 321             # override machine's current state from the command line
 322             if self.forceState is not None:
 323                 self.VARS['BOOT_STATE']= self.forceState
 324                 UpdateBootStateWithPLC.Run( self.VARS, self.LOG )
 325
 326             stateRun = BootManager.NodeRunStates.get(self.VARS['BOOT_STATE'],_badstateRun)
 327             stateRun()
 328             success = 1
 329
 330         except KeyError, e:
 331             self.LOG.write( "\n\nKeyError while running: %s\n" % str(e) )
 332         except BootManagerException, e:
 333             self.LOG.write( "\n\nException while running: %s\n" % str(e) )
 334         except BootManagerAuthenticationException, e:
 335             self.LOG.write( "\n\nFailed to Authenticate Node: %s\n" % str(e) )
 336             # sets /tmp/CANCEL_BOOT flag
 337             StartDebug.Run(self.VARS, self.LOG )
 338             # Return immediately b/c any other calls to API will fail
 339             return success
 340         except:
 341             self.LOG.write( "\n\nImplementation Error\n")
 342             traceback.print_exc(file=self.LOG.OutputFile)
 343             traceback.print_exc()
 344
 345         if not success:
 346             try:
 347                 _debugRun()
 348             except BootManagerException, e:
 349                 self.LOG.write( "\n\nException while running: %s\n" % str(e) )
 350             except:
 351                 self.LOG.write( "\n\nImplementation Error\n")
 352                 traceback.print_exc(file=self.LOG.OutputFile)
 353                 traceback.print_exc()
 354
 355         return success
 356
 357
 358 def main(argv):
 359
 360     import utils
 361     utils.prompt_for_breakpoint_mode()
 362
 363 #    utils.breakpoint ("Entering BootManager::main")
 364
 365     # set to 1 if error occurred
 366     error= 0
 367
 368     # all output goes through this class so we can save it and post
 369     # the data back to PlanetLab central
 370     LOG= log( BM_NODE_LOG )
 371
 372     # NOTE: assume CWD is BM's source directory, but never fail
 373     utils.sysexec_noerr("./setup_bash_history_scripts.sh", LOG)
 374
 375     LOG.LogEntry( "BootManager started at: %s" % \
 376                   time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime()) )
 377
 378     try:
 379         forceState = None
 380         if len(argv) == 2:
 381             fState = argv[1]
 382             if BootManager.NodeRunStates.has_key(fState):
 383                 forceState = fState
 384             else:
 385                 LOG.LogEntry("FATAL: cannot force node run state to=%s" % fState)
 386                 error = 1
 387     except:
 388         traceback.print_exc(file=LOG.OutputFile)
 389         traceback.print_exc()
 390
 391     if error:
 392         LOG.LogEntry( "BootManager finished at: %s" % \
 393                       time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime()) )
 394         LOG.Upload()
 395         return error
 396
 397     try:
 398         bm= BootManager(LOG,forceState)
 399         if bm.CAN_RUN == 0:
 400             LOG.LogEntry( "Unable to initialize BootManager." )
 401         else:
 402             LOG.LogEntry( "Running version %s of BootManager." % bm.VARS['VERSION'] )
 403             success= bm.Run()
 404             if success:
 405                 LOG.LogEntry( "\nDone!" );
 406             else:
 407                 LOG.LogEntry( "\nError occurred!" );
 408                 error = 1
 409     except:
 410         traceback.print_exc(file=LOG.OutputFile)
 411         traceback.print_exc()
 412
 413     LOG.LogEntry( "BootManager finished at: %s" % \
 414                   time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime()) )
 415     LOG.Upload()
 416
 417     return error
 418
 419
 420 if __name__ == "__main__":
 421     error = main(sys.argv)
 422     sys.exit(error)