plc.py

   1 #!/bin/env python
   2 #
   3 # Helper functions that minipulate the PLC api.
   4 #
   5 # Faiyaz Ahmed <faiyaza@cs.princeton.edu>
   6 # Copyright (C) 2006, 2007 The Trustees of Princeton University
   7 #
   8 # $Id: plc.py,v 1.10 2007/02/12 19:59:00 mef Exp $
   9 #
  10
  11 from emailTxt import *
  12 import xml, xmlrpclib
  13 import logging
  14 import time
  15 import config
  16 import getpass, getopt
  17 import sys
  18
  19 logger = logging.getLogger("monitor")
  20 XMLRPC_SERVER = 'https://www2.planet-lab.org/PLCAPI/'
  21 api = xmlrpclib.Server(XMLRPC_SERVER, verbose=False, allow_none = True)
  22 auth = None
  23
  24 def nodesDbg(argv):
  25         """Returns list of nodes in dbg as reported by PLC"""
  26
  27         global api, auth
  28         dbgNodes = []
  29         allnodes = api.GetNodes(auth, None, ['hostname','boot_state'])
  30         for node in allnodes:
  31                 if node['boot_state'] == 'dbg': dbgNodes.append(node['hostname'])
  32         logger.info("%d nodes in debug according to PLC." %len(dbgNodes))
  33         return dbgNodes
  34
  35
  36 def siteId(argv):
  37         """Returns loginbase for given nodename"""
  38
  39         global api, auth
  40         nodename = argv[0]
  41         site_ids = api.GetNodes(auth, [nodename], ['site_id'])
  42         if len(site_ids) == 1:
  43                 site_id = [site_ids[0]['site_id']]
  44                 loginbase = api.GetSites (auth, site_id, ["login_base"])
  45                 return loginbase[0]['login_base']
  46
  47 def slices(argv):
  48         """Returns list of slices for a site."""
  49
  50         global api, auth
  51         if len(argv) < 1:
  52                 printUsage("not enough arguments; please provide loginbase")
  53                 sys.exit(1)
  54
  55         loginbase = argv[0]
  56         if auth is None:
  57                 printUsage("requires admin privs")
  58                 sys.exit(1)
  59
  60         slices = api.GetSlices (auth, {'name':"%s_*"%loginbase},['name'])
  61         slices = map(lambda x: x['name'],slices)
  62         return slices
  63
  64 def getpcu(argv):
  65         """Returns dict of PCU info of a given node."""
  66
  67         global api, auth
  68         nodename = argv[0].lower()
  69         if auth is None:
  70                 printUsage("requires admin privs")
  71                 sys.exit(1)
  72
  73         pcus = api.GetNodes(auth, [nodename], ['pcu_ids'])
  74         if len(pcus):
  75                 pcus = map(lambda x: x['pcu_ids'],pcus)[0]
  76                 nodepcus = api.GetPCUs(auth,pcus)
  77         else:
  78                 nodepcus = []
  79         return nodepcus
  80
  81
  82 def getSiteNodes(argv):
  83         """Returns all site nodes for site id (loginbase)."""
  84         global api, auth
  85         if len(argv) < 1:
  86                 printUsage("not enough arguments; please provide loginbase")
  87                 sys.exit(1)
  88
  89         loginbase = argv[0]
  90         nodelist = []
  91         site_ids = api.GetSites(auth, {'login_base': "%s" % loginbase}, ['node_ids'])
  92         if len(site_ids) == 1:
  93                 node_ids = site_ids[0]['node_ids']
  94                 nodes = api.GetNodes(auth,node_ids,['hostname'])
  95                 nodelist = map(lambda x: x['hostname'], nodes)
  96         elif len(site_ids) == 0:
  97                 logger.info("getSiteNodes: can't find site %s" %loginbase)
  98         nodelist.sort()
  99         return nodelist
 100
 101 def renewAllSlices (argv):
 102         """Sets the expiration date of all slices to given date"""
 103         global api, auth
 104
 105         newexp = argv[0]
 106         # convert time string using fmt "%B %d %Y" to epoch integer
 107         try:
 108                 newexp = int(time.mktime(time.strptime(newexp,"%B %d %Y")))
 109         except ValueError, e:
 110                 errormsg = """Expecting date to be in Month Day Year
 111   e.g., April 7 2007
 112   new expiration date provided %s""" % newexp
 113                 printUsage(errormsg)
 114                 sys.exit(1)
 115
 116         slices = api.GetSlices(auth)
 117         for slice in slices:
 118                 name = slice['name']
 119                 exp = int(slice['expires'])
 120                 olddate = time.asctime(time.localtime(exp))
 121                 slice_attributes = api.GetSliceAttributes(auth,slice['slice_attribute_ids'])
 122                 for slice_attribute in slice_attributes:
 123                         if slice_attribute['name'] == "enabled":
 124                                 print "%s is suspended" % name
 125                 if exp < newexp:
 126                         newdate = time.asctime(time.localtime(newexp))
 127                         ret = api.SliceRenew(auth,name,newexp)
 128                         if ret == 0:
 129                                 print "failed to renew %s" %name
 130
 131 def nodeBootState(argv):
 132         """Sets boot state of a node."""
 133
 134         global api, auth
 135         if len(argv) < 1:
 136                 printUsage("not enough arguments")
 137                 sys.exit(1)
 138
 139         if len(argv) >=1:
 140                 nodename = argv[0]
 141         if len(argv) >=2:
 142                 state = argv[1]
 143
 144         if auth is None:
 145                 printUsage("requires admin privs")
 146                 sys.exit(1)
 147
 148         node = api.GetNodes(auth, [nodename], ['node_id','boot_state'])
 149         if len(node) == 1:
 150                 node = node[0]
 151                 try:
 152                         logger.info("%s boot_state=%s" %(nodename, node['boot_state']))
 153                         if len(argv) >=2 and not config.debug:
 154                                 logger.info("Setting node %s boot_state=%s" %(nodename, state))
 155                                 node_id = node['node_id']
 156                                 api.UpdateNode(auth, node_id, {'boot_state': state})
 157                 except Exception, exc:
 158                         logger.info("nodeBootState:  %s" % exc)
 159         else:
 160                 logger.info("Cant find node %s to toggle boot state" % nodename)
 161
 162
 163 def nodePOD(argv):
 164         """Sends Ping Of Death to node."""
 165
 166         global api, auth
 167         if len(argv) < 1:
 168                 printUsage("not enough arguments")
 169                 sys.exit(1)
 170
 171         nodename = argv[0]
 172         if auth is None:
 173                 printUsage("requires admin privs")
 174                 sys.exit(1)
 175
 176         node = api.GetNodes(auth, [nodename], ['node_id'])
 177         if len(node) == 1:
 178                 node = node[0]
 179                 logger.info("Sending POD to %s" % nodename)
 180                 try:
 181                         if not config.debug:
 182                                 api.RebootNode(auth, node['node_id'])
 183                 except Exception, exc:
 184                         logger.info("nodePOD:  %s" % exc)
 185         else:
 186                 logger.info("Cant find node %s to send POD." % nodename)
 187
 188 def suspendSlice(argv):
 189         """Freeze specific slice."""
 190         global api, auth
 191         if auth is None:
 192                 printUsage("requires admin privs")
 193                 sys.exit(1)
 194
 195         slice = argv[0]
 196         logger.info("Suspending slice %s" % slice)
 197         try:
 198                 if not config.debug:
 199                         api.AddSliceAttribute(auth, slice, "enabled", "0")
 200         except Exception, exc:
 201                 logger.info("suspendSlices:  %s" % exc)
 202
 203 def suspendSlices(argv):
 204         """Freeze all site slices."""
 205         global api, auth
 206         if auth is None:
 207                 printUsage("requires admin privs")
 208                 sys.exit(1)
 209
 210         if argv[0].find(".") <> -1: siteslices = slices([siteId(argv)])
 211         else: siteslices = slices(argv)
 212
 213         for slice in siteslices:
 214                 suspendSlice([slice])
 215
 216 def __enableSlice(slice):
 217         logger.info("unfreezing slice %s" % slice['name'])
 218         slice_attributes = api.GetSliceAttributes(auth,slice['slice_attribute_ids'])
 219         for slice_attribute in slice_attributes:
 220                 if slice_attribute['name'] == "enabled":
 221                         api.DeleteSliceAttribute(auth, slice_attribute['slice_attribute_id'])
 222
 223 def enableSlice(arg):
 224         """Enable suspended slice."""
 225         global api, auth
 226         if auth is None:
 227                 printUsage("requires admin privs")
 228                 sys.exit(1)
 229
 230         slicename = arg[0]
 231         gSlices = {'name':slicename}
 232         slice = api.GetSlices(auth,gSlices)
 233         if len(slice) == 1:
 234                 __enableSlice(slice[0])
 235         else:
 236                 logger.info("slice %s not found" % slicename)
 237
 238 def enableSlices(argv):
 239         """Enable suspended site slices."""
 240
 241         global api, auth
 242         if auth is None:
 243                 printUsage("requires admin privs")
 244                 sys.exit(1)
 245
 246         if argv[0].find(".") <> -1:
 247                 slices = api.GetSlices(auth,[siteId(argv)])
 248         else:
 249                 gSlices = {'name':"%s_*"%argv[0]}
 250                 slices = api.GetSlices(auth,gSlices)
 251
 252         for slice in slices:
 253                 __enableSlice(slice)
 254
 255 def setSliceMax(argv):
 256         """Set max_slices for Slice. Returns previous max_slices"""
 257         global api, auth
 258         if auth is None:
 259                 printUsage("requires admin privs")
 260                 sys.exit(1)
 261
 262         name = argv[0]
 263         val = int(argv[1])
 264         if name.find(".") <> -1:
 265                 site_ids = api.GetNodes(auth, [name], ['site_id'])
 266                 if len(site_ids) == 1:
 267                         site_id = [site_ids[0]['site_id']]
 268                         loginbase = api.GetSites (auth, site_id, ["login_base"])
 269                 else:
 270                         printUsage("invalid hostname %s" % name)
 271                         sys.exit(1)
 272         else:
 273                 site_ids = api.GetSites(auth, {'login_base': "%s" % name}, ['site_id'])
 274                 if len(site_ids) == 1:
 275                         siteid = site_ids[0]['site_id']
 276                 loginbase = name
 277
 278         numslices = api.GetSites(auth, [siteid], ["max_slices"])[0]['max_slices']
 279         try:
 280                 api.UpdateSite(auth, siteid, {'max_slices': val})
 281                 logger.info("_SetSliceMax:  %s max_slices was %d set to %d" % (loginbase,numslices,val))
 282                 return numslices
 283         except Exception, exc:
 284                 logger.info("_SetSliceMax:  %s" % exc)
 285
 286
 287 USAGE = """
 288 Usage: %s [-u user] [-p password] [-r role] CMD
 289
 290 Options:
 291 -u      PLC account username
 292 -p      PLC account password
 293 -r      PLC account role
 294 -h      This message
 295 """ % sys.argv[0]
 296
 297 def printUsage(error = None):
 298         global funclist
 299         if error <> None:
 300                 print "%s %s" %(sys.argv[0],error)
 301         print USAGE
 302         print "CMD:"
 303         for name,function in funclist:
 304                 print "%20s\t%20s" % (name, function.__doc__)
 305
 306 def main():
 307         global api, auth
 308
 309         auth = None
 310         user = None
 311         password = None
 312         role = 'admin'
 313
 314         (opts, argv) = getopt.getopt(sys.argv[1:], "u:p:r:h")
 315         if len(argv)==0:
 316                 printUsage()
 317                 sys.exit(1)
 318
 319         for (opt, optval) in opts:
 320                 if opt == '-u':
 321                         user = optval
 322                 elif opt == '-p':
 323                         password = optval
 324                 elif opt == '-r':
 325                         role = optval
 326                 elif opt == '-h':
 327                         print USAGE
 328                         sys.exit(0)
 329
 330         if user <> None:
 331                 if password is None:
 332                         try:
 333                                 password = getpass.getpass()
 334                         except (EOFError, KeyboardInterrupt):
 335                                 print( "" )
 336                                 sys.exit(1)
 337                 auth = {}
 338                 auth['Username'] = user
 339                 auth['AuthMethod'] = "password"
 340                 auth['AuthString'] = password
 341                 auth['Role'] = role
 342
 343         cmd = functbl.get(argv[0], None)
 344         if cmd is None:
 345                 printUsage()
 346                 sys.exit(1)
 347
 348         logger.setLevel(logging.DEBUG)
 349         ch = logging.StreamHandler()
 350         ch.setLevel(logging.DEBUG)
 351         formatter = logging.Formatter('logger - %(message)s')
 352         ch.setFormatter(formatter)
 353         logger.addHandler(ch)
 354         result = cmd(argv[1:])
 355         if result <> None:
 356                 print result
 357
 358 funclist = (("nodesDbg",nodesDbg),
 359             ("siteId", siteId),
 360             ("slices", slices),
 361             ("pcu", getpcu),
 362             ("siteNodes", getSiteNodes),
 363             ("nodeBootState", nodeBootState),
 364             ("nodePOD", nodePOD),
 365             ("freezeSlice", suspendSlice),
 366             ("unfreezeSlice", enableSlice),
 367             ("freezeSlices", suspendSlices),
 368             ("unfreezeSlices", enableSlices),
 369             ("setSliceMax", setSliceMax),
 370             ("renewAllSlices", renewAllSlices))
 371
 372 functbl = {}
 373 for f in funclist:
 374         functbl[f[0]]=f[1]
 375
 376 if __name__=="__main__":
 377         import reboot
 378         main()