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 execption.
 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                 WriteModprobeConfig.Run( self.VARS, self.LOG )
 233                 WriteNetworkConfig.Run( self.VARS, self.LOG )
 234                 CheckForNewDisks.Run( self.VARS, self.LOG )
 235                 SendHardwareConfigToPLC.Run( self.VARS, self.LOG )
 236                 ChainBootNode.Run( self.VARS, self.LOG )
 237             elif ret == -1:
 238                 _nodeNotInstalled('MSG_NODE_FILESYSTEM_CORRUPT')
 239             elif ret == -2:
 240                 _nodeNotInstalled('MSG_NODE_MOUNT_FAILED')
 241             elif ret == -3:
 242                 _nodeNotInstalled('MSG_NODE_MISSING_KERNEL')
 243             else:
 244                 _nodeNotInstalled()
 245
 246         def _reinstallRun():
 247
 248             # starting the fallback/debug ssh daemon for safety:
 249             # if the node install somehow hangs, or if it simply takes ages,
 250             # we can still enter and investigate
 251             try:
 252                 StartDebug.Run(self.VARS, self.LOG, last_resort = False)
 253             except:
 254                 pass
 255
 256             # implements the reinstall logic, which will check whether
 257             # the min. hardware requirements are met, install the
 258             # software, and upon correct installation will switch too
 259             # 'boot' state and chainboot into the production system
 260             if not CheckHardwareRequirements.Run( self.VARS, self.LOG ):
 261                 self.VARS['RUN_LEVEL']= 'failboot'
 262                 raise BootManagerException, "Hardware requirements not met."
 263
 264             # runinstaller
 265             InstallInit.Run( self.VARS, self.LOG )
 266             InstallPartitionDisks.Run( self.VARS, self.LOG )
 267             InstallBootstrapFS.Run( self.VARS, self.LOG )
 268             InstallWriteConfig.Run( self.VARS, self.LOG )
 269             InstallUninitHardware.Run( self.VARS, self.LOG )
 270             self.VARS['BOOT_STATE']= 'boot'
 271             self.VARS['STATE_CHANGE_NOTIFY']= 1
 272             self.VARS['STATE_CHANGE_NOTIFY_MESSAGE']= \
 273                  notify_messages.MSG_INSTALL_FINISHED
 274             UpdateBootStateWithPLC.Run( self.VARS, self.LOG )
 275             _bootRun()
 276
 277         def _installRun():
 278             # implements the new install logic, which will first check
 279             # with the user whether it is ok to install on this
 280             # machine, switch to 'reinstall' state and then invoke the reinstall
 281             # logic.  See reinstallState logic comments for further
 282             # details.
 283             if not ConfirmInstallWithUser.Run( self.VARS, self.LOG ):
 284                 return 0
 285             self.VARS['BOOT_STATE']= 'reinstall'
 286             _reinstallRun()
 287
 288         def _debugRun(state='failboot'):
 289             # implements debug logic, which starts the sshd and just waits around
 290             self.VARS['RUN_LEVEL']=state
 291             StartDebug.Run( self.VARS, self.LOG )
 292             # fsck/mount fs if present, and ignore return value if it's not.
 293             ValidateNodeInstall.Run( self.VARS, self.LOG )
 294
 295         def _badstateRun():
 296             # should never happen; log event
 297             self.LOG.write( "\nInvalid BOOT_STATE = %s\n" % self.VARS['BOOT_STATE'])
 298             _debugRun()
 299
 300         # setup state -> function hash table
 301         BootManager.NodeRunStates['reinstall']  = _reinstallRun
 302         BootManager.NodeRunStates['boot']       = _bootRun
 303         BootManager.NodeRunStates['safeboot']   = lambda : _debugRun('safeboot')
 304         BootManager.NodeRunStates['disabled']   = lambda : _debugRun('disabled')
 305
 306         success = 0
 307         try:
 308             InitializeBootManager.Run( self.VARS, self.LOG )
 309             ReadNodeConfiguration.Run( self.VARS, self.LOG )
 310             AuthenticateWithPLC.Run( self.VARS, self.LOG )
 311             UpdateLastBootOnce.Run( self.VARS, self.LOG )
 312             StartRunlevelAgent.Run( self.VARS, self.LOG )
 313             GetAndUpdateNodeDetails.Run( self.VARS, self.LOG )
 314
 315             # override machine's current state from the command line
 316             if self.forceState is not None:
 317                 self.VARS['BOOT_STATE']= self.forceState
 318                 UpdateBootStateWithPLC.Run( self.VARS, self.LOG )
 319
 320             stateRun = BootManager.NodeRunStates.get(self.VARS['BOOT_STATE'],_badstateRun)
 321             stateRun()
 322             success = 1
 323
 324         except KeyError, e:
 325             self.LOG.write( "\n\nKeyError while running: %s\n" % str(e) )
 326         except BootManagerException, e:
 327             self.LOG.write( "\n\nException while running: %s\n" % str(e) )
 328         except BootManagerAuthenticationException, e:
 329             self.LOG.write( "\n\nFailed to Authenticate Node: %s\n" % str(e) )
 330             # sets /tmp/CANCEL_BOOT flag
 331             StartDebug.Run(self.VARS, self.LOG )
 332             # Return immediately b/c any other calls to API will fail
 333             return success
 334         except:
 335             self.LOG.write( "\n\nImplementation Error\n")
 336             traceback.print_exc(file=self.LOG.OutputFile)
 337             traceback.print_exc()
 338
 339         if not success:
 340             try:
 341                 _debugRun()
 342             except BootManagerException, e:
 343                 self.LOG.write( "\n\nException while running: %s\n" % str(e) )
 344             except:
 345                 self.LOG.write( "\n\nImplementation Error\n")
 346                 traceback.print_exc(file=self.LOG.OutputFile)
 347                 traceback.print_exc()
 348
 349         return success
 350
 351
 352 def main(argv):
 353
 354     import utils
 355     utils.prompt_for_breakpoint_mode()
 356
 357 #    utils.breakpoint ("Entering BootManager::main")
 358
 359     # set to 1 if error occurred
 360     error= 0
 361
 362     # all output goes through this class so we can save it and post
 363     # the data back to PlanetLab central
 364     LOG= log( BM_NODE_LOG )
 365
 366     # NOTE: assume CWD is BM's source directory, but never fail
 367     utils.sysexec_noerr("./setup_bash_history_scripts.sh", LOG)
 368
 369     LOG.LogEntry( "BootManager started at: %s" % \
 370                   time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime()) )
 371
 372     try:
 373         forceState = None
 374         if len(argv) == 2:
 375             fState = argv[1]
 376             if BootManager.NodeRunStates.has_key(fState):
 377                 forceState = fState
 378             else:
 379                 LOG.LogEntry("FATAL: cannot force node run state to=%s" % fState)
 380                 error = 1
 381     except:
 382         traceback.print_exc(file=LOG.OutputFile)
 383         traceback.print_exc()
 384
 385     if error:
 386         LOG.LogEntry( "BootManager finished at: %s" % \
 387                       time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime()) )
 388         LOG.Upload()
 389         return error
 390
 391     try:
 392         bm= BootManager(LOG,forceState)
 393         if bm.CAN_RUN == 0:
 394             LOG.LogEntry( "Unable to initialize BootManager." )
 395         else:
 396             LOG.LogEntry( "Running version %s of BootManager." % bm.VARS['VERSION'] )
 397             success= bm.Run()
 398             if success:
 399                 LOG.LogEntry( "\nDone!" );
 400             else:
 401                 LOG.LogEntry( "\nError occurred!" );
 402                 error = 1
 403     except:
 404         traceback.print_exc(file=LOG.OutputFile)
 405         traceback.print_exc()
 406
 407     LOG.LogEntry( "BootManager finished at: %s" % \
 408                   time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime()) )
 409     LOG.Upload()
 410
 411     return error
 412
 413
 414 if __name__ == "__main__":
 415     error = main(sys.argv)
 416     sys.exit(error)