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.9 2007/02/12 19:54:56 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 suspendSlices(argv):
 189         """Freeze all site slices."""
 190
 191         global api, auth
 192         if auth is None:
 193                 printUsage("requires admin privs")
 194                 sys.exit(1)
 195
 196         if argv[0].find(".") <> -1: siteslices = slices([siteId(argv)])
 197         else: siteslices = slices(argv)
 198
 199         for slice in siteslices:
 200                 logger.info("Suspending slice %s" % slice)
 201                 try:
 202                         if not config.debug:
 203                                 api.AddSliceAttribute(auth, slice, "plc_slice_state", "suspended")
 204                 except Exception, exc:
 205                         logger.info("suspendSlices:  %s" % exc)
 206
 207
 208 def enableSlices(argv):
 209         """Enable suspended site slices."""
 210
 211         global api, auth
 212         if auth is None:
 213                 printUsage("requires admin privs")
 214                 sys.exit(1)
 215
 216         if argv[0].find(".") <> -1:
 217                 slices = api.GetSlices(auth,[siteId(argv)])
 218         else:
 219                 gSlices = {'name':"%s_*"%argv[0]}
 220                 slices = api.GetSlices(auth,gSlices)
 221
 222         for slice in slices:
 223                 logger.info("unfreezing slice %s" % slice['name'])
 224                 slice_attributes = api.GetSliceAttributes(auth,slice['slice_attribute_ids'])
 225                 for slice_attribute in slice_attributes:
 226                         if slice_attribute['name'] == "plc_slice_state":
 227                                 api.DeleteSliceAttribute(auth, slice_attribute['slice_attribute_id'])
 228
 229 def setSliceMax(argv):
 230         """Set max_slices for Slice. Returns previous max_slices"""
 231         global api, auth
 232         if auth is None:
 233                 printUsage("requires admin privs")
 234                 sys.exit(1)
 235
 236         name = argv[0]
 237         val = int(argv[1])
 238         if name.find(".") <> -1:
 239                 site_ids = api.GetNodes(auth, [name], ['site_id'])
 240                 if len(site_ids) == 1:
 241                         site_id = [site_ids[0]['site_id']]
 242                         loginbase = api.GetSites (auth, site_id, ["login_base"])
 243                 else:
 244                         printUsage("invalid hostname %s" % name)
 245                         sys.exit(1)
 246         else:
 247                 site_ids = api.GetSites(auth, {'login_base': "%s" % name}, ['site_id'])
 248                 if len(site_ids) == 1:
 249                         siteid = site_ids[0]['site_id']
 250                 loginbase = name
 251
 252         numslices = api.GetSites(auth, [siteid], ["max_slices"])[0]['max_slices']
 253         try:
 254                 api.UpdateSite(auth, siteid, {'max_slices': val})
 255                 logger.info("_SetSliceMax:  %s max_slices was %d set to %d" % (loginbase,numslices,val))
 256                 return numslices
 257         except Exception, exc:
 258                 logger.info("_SetSliceMax:  %s" % exc)
 259
 260
 261 USAGE = """
 262 Usage: %s [-u user] [-p password] [-r role] CMD
 263
 264 Options:
 265 -u      PLC account username
 266 -p      PLC account password
 267 -r      PLC account role
 268 -h      This message
 269 """ % sys.argv[0]
 270
 271 def printUsage(error = None):
 272         global funclist
 273         if error <> None:
 274                 print "%s %s" %(sys.argv[0],error)
 275         print USAGE
 276         print "CMD:"
 277         for name,function in funclist:
 278                 print "%20s\t%20s" % (name, function.__doc__)
 279
 280 def main():
 281         global api, auth
 282
 283         auth = None
 284         user = None
 285         password = None
 286         role = 'admin'
 287
 288         (opts, argv) = getopt.getopt(sys.argv[1:], "u:p:r:h")
 289         if len(argv)==0:
 290                 printUsage()
 291                 sys.exit(1)
 292
 293         for (opt, optval) in opts:
 294                 if opt == '-u':
 295                         user = optval
 296                 elif opt == '-p':
 297                         password = optval
 298                 elif opt == '-r':
 299                         role = optval
 300                 elif opt == '-h':
 301                         print USAGE
 302                         sys.exit(0)
 303
 304         if user <> None:
 305                 if password is None:
 306                         try:
 307                                 password = getpass.getpass()
 308                         except (EOFError, KeyboardInterrupt):
 309                                 print( "" )
 310                                 sys.exit(1)
 311                 auth = {}
 312                 auth['Username'] = user
 313                 auth['AuthMethod'] = "password"
 314                 auth['AuthString'] = password
 315                 auth['Role'] = role
 316
 317         cmd = functbl.get(argv[0], None)
 318         if cmd is None:
 319                 printUsage()
 320                 sys.exit(1)
 321
 322         logger.setLevel(logging.DEBUG)
 323         ch = logging.StreamHandler()
 324         ch.setLevel(logging.DEBUG)
 325         formatter = logging.Formatter('logger - %(message)s')
 326         ch.setFormatter(formatter)
 327         logger.addHandler(ch)
 328         result = cmd(argv[1:])
 329         if result <> None:
 330                 print result
 331
 332 funclist = (("nodesDbg",nodesDbg),
 333             ("siteId", siteId),
 334             ("slices", slices),
 335             ("pcu", getpcu),
 336             ("siteNodes", getSiteNodes),
 337             ("nodeBootState", nodeBootState),
 338             ("nodePOD", nodePOD),
 339             ("freezeSlices", suspendSlices),
 340             ("unfreezeSlices", enableSlices),
 341             ("setSliceMax", setSliceMax),
 342             ("renewAllSlices", renewAllSlices))
 343
 344 functbl = {}
 345 for f in funclist:
 346         functbl[f[0]]=f[1]
 347
 348 if __name__=="__main__":
 349         import reboot
 350         main()