X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=plc.py;h=5be15c8ea808d9584f036397a47be293a28e463a;hb=refs%2Fheads%2F1.0;hp=e78892ea21b95d8d14ae635fa0aa381a1e165ac3;hpb=9406a205fdd2bb9e95c37f63bf3207112ffb2cd3;p=monitor.git diff --git a/plc.py b/plc.py index e78892e..5be15c8 100644 --- a/plc.py +++ b/plc.py @@ -1,341 +1,384 @@ -#!/bin/env python +# +# plc.py # # Helper functions that minipulate the PLC api. # -# Faiyaz Ahmed -# Copyright (C) 2006, 2007 The Trustees of Princeton University +# Faiyaz Ahmed = 10: + print "maximum error count exceeded; exiting..." + sys.exit(1) + else: + print "%s errors have occurred" % global_error_count + raise Exception("ProtocolError continuing") + + def __repr__(self): + return self.api.__repr__() + +def getAPI(url): + return xmlrpclib.Server(url, verbose=False, allow_none=True) + +def getAuthAPI(): + return PLC(auth.auth, auth.server) + + +def getTechEmails(loginbase): + """ + For the given site, return all user email addresses that have the 'tech' role. + """ + api = getAuthAPI() + # get site details. + s = api.GetSites(loginbase)[0] + # get people at site + p = api.GetPersons(s['person_ids']) + # pull out those with the right role. + emails = [ person['email'] for person in filter(lambda x: 'tech' in x['roles'], p) ] + return emails + +def getPIEmails(loginbase): + """ + For the given site, return all user email addresses that have the 'tech' role. + """ + api = getAuthAPI() + # get site details. + s = api.GetSites(loginbase)[0] + # get people at site + p = api.GetPersons(s['person_ids']) + # pull out those with the right role. + emails = [ person['email'] for person in filter(lambda x: 'pi' in x['roles'], p) ] + return emails + +def getSliceUserEmails(loginbase): + """ + For the given site, return all user email addresses that have the 'tech' role. + """ + api = getAuthAPI() + # get site details. + s = api.GetSites(loginbase)[0] + # get people at site + slices = api.GetSlices(s['slice_ids']) + people = [] + for slice in slices: + people += api.GetPersons(slice['person_ids']) + # pull out those with the right role. + emails = [ person['email'] for person in filter(lambda x: 'pi' in x['roles'], people) ] + unique_emails = [ x for x in set(emails) ] + return unique_emails + +''' +Returns list of nodes in dbg as reported by PLC +''' +def nodesDbg(): dbgNodes = [] - allnodes = api.AnonAdmGetNodes(anon, [], ['hostname','boot_state']) - for node in allnodes: - if node['boot_state'] == 'dbg': dbgNodes.append(node['hostname']) + api = xmlrpclib.Server(auth.server, verbose=False) + anon = {'AuthMethod': "anonymous"} + for node in api.GetNodes(anon, {"boot_state":"dbg"},["hostname"]): + dbgNodes.append(node['hostname']) logger.info("%s nodes in debug according to PLC." %len(dbgNodes)) return dbgNodes -def siteId(argv): - """Returns loginbase for given nodename""" - - global api, anon, auth - nodename = argv[0] - site_id = api.AnonAdmQuerySite (anon, {"node_hostname": nodename}) +''' +Returns loginbase for given nodename +''' +def siteId(nodename): + api = xmlrpclib.Server(auth.server, verbose=False, allow_none=True) + site_id = api.GetNodes (auth.auth, {"hostname": nodename}, ['site_id']) if len(site_id) == 1: - loginbase = api.AnonAdmGetSites (anon, site_id, ["login_base"]) + loginbase = api.GetSites (auth.auth, site_id[0], ["login_base"]) return loginbase[0]['login_base'] - -def slices(argv): - """Returns list of slices for a site.""" - - global api, anon, auth - loginbase = argv[0] - if auth is None: - printUsage("requires admin privs") - sys.exit(1) - return api.SliceListNames (auth, loginbase) - -def getpcu(argv): - """Returns dict of PCU info of a given node.""" - - global api, anon, auth - nodename = argv[0].lower() - if auth is None: - printUsage("requires admin privs") - sys.exit(1) - - nodes = [] - site_id = api.AnonAdmQuerySite (anon, {"node_hostname": nodename}) - if len(site_id) == 1: - try: - sitepcus = api.AdmGetSitePowerControlUnits(auth, site_id[0]) - for sitepcu in sitepcus: - sitepcuports = api.AdmGetPowerControlUnitNodes(auth, sitepcu['pcu_id']) - for sitepcuport in sitepcuports: - node_id = [sitepcuport['node_id']] - node = api.AnonAdmGetNodes(anon,node_id,["hostname"]) - if len(node)==0: - continue - node = node[0] - hostname = node['hostname'].lower() - if hostname == nodename: - sitepcu['port_number']=sitepcuport['port_number'] - return sitepcu - - except Exception, err: - logger.debug("getpcu: %s" % err) - return else: - logger.info("Cant find site for %s" % nodename) - - -def getSiteNodes(argv): - """Returns all site nodes for site id (loginbase).""" - global api, anon, auth - loginbase = argv[0] + print "Not nodes returned!!!!" + +''' +Returns list of slices for a site. +''' +def slices(loginbase): + siteslices = [] + api = xmlrpclib.Server(auth.server, verbose=False, allow_none=True) + sliceids = api.GetSites (auth.auth, {"login_base" : loginbase}, ["slice_ids"])[0]['slice_ids'] + for slice in api.GetSlices(auth.auth, {"slice_id" : sliceids}, ["name"]): + siteslices.append(slice['name']) + return siteslices + +''' +Returns dict of PCU info of a given node. +''' +def getpcu(nodename): + api = xmlrpclib.Server(auth.server, verbose=False, allow_none=True) + anon = {'AuthMethod': "anonymous"} + nodeinfo = api.GetNodes(auth.auth, {"hostname": nodename}, ["pcu_ids", "ports"])[0] + if nodeinfo['pcu_ids']: + sitepcu = api.GetPCUs(auth.auth, nodeinfo['pcu_ids'])[0] + sitepcu[nodename] = nodeinfo["ports"][0] + return sitepcu + else: + logger.info("%s doesn't have PCU" % nodename) + return False + +def GetPCUs(filter=None, fields=None): + api = xmlrpclib.Server(auth.server, verbose=False, allow_none=True) + pcu_list = api.GetPCUs(auth.auth, filter, fields) + return pcu_list + +''' +Returns all site nodes for site id (loginbase). +''' +def getSiteNodes(loginbase, fields=None): + api = xmlrpclib.Server(auth.server, verbose=False) nodelist = [] + anon = {'AuthMethod': "anonymous"} try: - site_id = api.AnonAdmQuerySite(anon, {'site_loginbase': "%s" % loginbase}) - node_ids = api.AnonAdmGetSiteNodes(anon, site_id) - for node in api.AnonAdmGetNodes(anon, node_ids["%s" % site_id[0]], ["hostname"]): + nodeids = api.GetSites(anon, {"login_base": loginbase}, fields)[0]['node_ids'] + for node in api.GetNodes(anon, {"node_id": nodeids}, ['hostname']): nodelist.append(node['hostname']) except Exception, exc: logger.info("getSiteNodes: %s" % exc) - nodelist.sort() + print "getSiteNodes: %s" % exc return nodelist -def nodeBootState(argv): - """Sets boot state of a node.""" - global api, anon, auth - if len(argv) <> 2: - printUsage("not enough arguments") - sys.exit(1) - - nodename = argv[0] - state = argv[1] - - if auth is None: - printUsage("requires admin privs") - sys.exit(1) - - node_id = api.AnonAdmQueryNode(anon, {'node_hostname' : nodename}) - if len(node_id) == 1: - logger.info("Setting node %s to %s" %(nodename, state)) - try: - if not config.debug: - api.AdmUpdateNode(auth, node_id[0], {'boot_state': state}) - except Exception, exc: - logger.info("nodeBootState: %s" % exc) - else: - logger.info("Cant find node %s to toggle boot state" % nodename) +def getPersons(filter=None, fields=None): + api = xmlrpclib.Server(auth.server, verbose=False, allow_none=True) + persons = [] + try: + persons = api.GetPersons(auth.auth, filter, fields) + except Exception, exc: + print "getPersons: %s" % exc + logger.info("getPersons: %s" % exc) + return persons + +def getSites(filter=None, fields=None): + api = xmlrpclib.Server(auth.server, verbose=False, allow_none=True) + sites = [] + anon = {'AuthMethod': "anonymous"} + try: + #sites = api.GetSites(anon, filter, fields) + sites = api.GetSites(auth.auth, filter, fields) + except Exception, exc: + traceback.print_exc() + print "getSites: %s" % exc + logger.info("getSites: %s" % exc) + return sites -def nodePOD(argv): - """Sends Ping Of Death to node.""" +def getSiteNodes2(loginbase): + api = xmlrpclib.Server(auth.server, verbose=False) + nodelist = [] + anon = {'AuthMethod': "anonymous"} + try: + nodeids = api.GetSites(anon, {"login_base": loginbase})[0]['node_ids'] + nodelist += getNodes({'node_id':nodeids}) + except Exception, exc: + logger.info("getSiteNodes2: %s" % exc) + return nodelist - global api, anon, auth - nodename = argv[0] - if auth is None: - printUsage("requires admin privs") - sys.exit(1) +def getNodeNetworks(filter=None): + api = xmlrpclib.Server(auth.server, verbose=False, allow_none=True) + nodenetworks = api.GetInterfaces(auth.auth, filter, None) + return nodenetworks + +def getNodes(filter=None, fields=None): + api = xmlrpclib.Server(auth.server, verbose=False, allow_none=True) + nodes = api.GetNodes(auth.auth, filter, fields) + #['boot_state', 'hostname', + #'site_id', 'date_created', 'node_id', 'version', 'interface_ids', + #'last_updated', 'peer_node_id', 'ssh_rsa_key' ]) + return nodes + +''' +Sets boot state of a node. +''' +def nodeBootState(nodename, state): + api = xmlrpclib.Server(auth.server, verbose=False) + try: + return api.UpdateNode(auth.auth, nodename, {'boot_state': state}) + except Exception, exc: + logger.info("nodeBootState: %s" % exc) - node_id = api.AnonAdmQueryNode(anon, {'node_hostname' : nodename}) - if len(node_id) == 1: - logger.info("Sending POD to %s" % nodename) - try: - if not config.debug: - api.AdmRebootNode(auth, node_id[0]) - except Exception, exc: +def updateNodeKey(nodename, key): + api = xmlrpclib.Server(auth.server, verbose=False) + try: + return api.UpdateNode(auth.auth, nodename, {'key': key}) + except Exception, exc: + logger.info("updateNodeKey: %s" % exc) + +''' +Sends Ping Of Death to node. +''' +def nodePOD(nodename): + api = xmlrpclib.Server(auth.server, verbose=False) + logger.info("Sending POD to %s" % nodename) + try: + if not debug: + return api.RebootNode(auth.auth, nodename) + except Exception, exc: logger.info("nodePOD: %s" % exc) - else: - logger.info("Cant find node %s to send POD." % nodename) - -def suspendSlices(argv): - """Freeze all site slices.""" - - global api, anon, auth - if auth is None: - printUsage("requires admin privs") - sys.exit(1) - if argv[0].find(".") <> -1: siteslices = slices([siteId(argv)]) - else: siteslices = slices(argv) - - for slice in siteslices: +''' +Freeze all site slices. +''' +def suspendSlices(nodename): + api = xmlrpclib.Server(auth.server, verbose=False) + for slice in slices(siteId(nodename)): logger.info("Suspending slice %s" % slice) try: - if not config.debug: - api.SliceAttributeAdd(auth, slice, "plc_slice_state", - {"state" : "suspended"}) + if not debug: + api.AddSliceAttribute(auth.auth, slice, "enabled", "0") except Exception, exc: logger.info("suspendSlices: %s" % exc) - -def enableSlices(argv): - """Enable suspended site slices.""" - - global api, anon, auth - if auth is None: - printUsage("requires admin privs") - sys.exit(1) - - api = xmlrpclib.Server(XMLRPC_SERVER, verbose=False) - - if argv[0].find(".") <> -1: siteslices = slices([siteId(argv)]) - else: siteslices = slices(argv) - - for slice in siteslices: - logger.info("unfreezing slice %s" % slice) - api.SliceAttributeDelete(auth, slice, "plc_slice_state") - - -def removeSliceCreation(argv): - """Removes ability to create slices. Returns previous max_slices""" - - global api, anon, auth - if auth is None: - printUsage("requires admin privs") - sys.exit(1) - - name = argv[0] - if name.find(".") <> -1: - siteid = api.AnonAdmQuerySite (anon, {"node_hostname": name}) - loginbase = siteId(name) - else: - siteid = api.AnonAdmQuerySite (anon, {"site_loginbase": name}) - loginbase = name - - numslices = api.AdmGetSites(auth, siteid, ["max_slices"])[0]['max_slices'] - if len(siteid) == 1: - logger.info("Removing slice creation for site %s" % loginbase) +def enableSlices(nodename): + api = xmlrpclib.Server(auth.server, verbose=False, allow_none=True) + for slice in slices(siteId(nodename)): + logger.info("Enabling slices %s" % slice) try: - if not config.debug: - api.AdmUpdateSite(auth, siteid[0], {'max_slices': 0}) - return numslices + if not debug: + slice_list = api.GetSlices(auth.auth, {'name': slice}, None) + if len(slice_list) == 0: + return + slice_id = slice_list[0]['slice_id'] + l_attr = api.GetSliceAttributes(auth.auth, {'slice_id': slice_id}, None) + for attr in l_attr: + if "enabled" == attr['name'] and attr['value'] == "0": + logger.info("Deleted enable=0 attribute from slice %s" % slice) + api.DeleteSliceAttribute(auth.auth, attr['slice_attribute_id']) except Exception, exc: - logger.info("removeSliceCreation: %s" % exc) - else: - logger.debug("Cant find site for %s. Cannot revoke creation." % loginbase) - -def enableSliceCreation(argv): - """QED""" - - global api, anon, auth - if auth is None: - printUsage("requires admin privs") - sys.exit(1) - - if len(argv) <= 2: - printUsage("requires maxslice arg") - sys.exit(1) - - maxslices = int(argv[1]) - name = argv[0] - if name.find(".") <> -1: - siteid = api.AnonAdmQuerySite (anon, {"node_hostname": name}) - loginbase = siteId(name) - else: - siteid = api.AnonAdmQuerySite (anon, {"site_loginbase": name}) - loginbase = name - - if len(siteid) == 1: + logger.info("enableSlices: %s" % exc) + print "exception: %s" % exc + +#I'm commenting this because this really should be a manual process. +#''' +#Enable suspended site slices. +#''' +#def enableSlices(nodename, slicelist): +# api = xmlrpclib.Server(auth.server, verbose=False) +# for slice in slices(siteId(nodename)): +# logger.info("Suspending slice %s" % slice) +# api.SliceAttributeAdd(auth.auth, slice, "plc_slice_state", {"state" : "suspended"}) +# +def enableSliceCreation(nodename): + api = xmlrpclib.Server(auth.server, verbose=False, allow_none=True) + try: + loginbase = siteId(nodename) logger.info("Enabling slice creation for site %s" % loginbase) - try: - if not config.debug: - api.AdmUpdateSite(auth, siteid[0], {"max_slices" : maxslices}) - except Exception, exc: - logger.info("API: %s" % exc) - else: - logger.debug("Cant find site for %s. Cannot enable creation." % loginbase) - - - -USAGE = """ -Usage: %s [-u user] [-p password] [-r role] CMD - -Options: --u PLC account username --p PLC account password --r PLC account role --h This message -""" % sys.argv[0] + if not debug: + logger.info("\tcalling UpdateSite(%s, enabled=True)" % loginbase) + api.UpdateSite(auth.auth, loginbase, {'enabled': True}) + except Exception, exc: + print "ERROR: enableSliceCreation: %s" % exc + logger.info("ERROR: enableSliceCreation: %s" % exc) + +''' +Removes ability to create slices. Returns previous max_slices +''' +def removeSliceCreation(nodename): + print "removeSliceCreation(%s)" % nodename + api = xmlrpclib.Server(auth.server, verbose=False) + try: + loginbase = siteId(nodename) + #numslices = api.GetSites(auth.auth, {"login_base": loginbase}, + # ["max_slices"])[0]['max_slices'] + logger.info("Removing slice creation for site %s" % loginbase) + if not debug: + #api.UpdateSite(auth.auth, loginbase, {'max_slices': 0}) + api.UpdateSite(auth.auth, loginbase, {'enabled': False}) + except Exception, exc: + logger.info("removeSliceCreation: %s" % exc) + +''' +QED +''' +#def enableSliceCreation(nodename, maxslices): +# api = xmlrpclib.Server(auth.server, verbose=False) +# anon = {'AuthMethod': "anonymous"} +# siteid = api.AnonAdmQuerySite (anon, {"node_hostname": nodename}) +# if len(siteid) == 1: +# logger.info("Enabling slice creation for site %s" % siteId(nodename)) +# try: +# if not debug: +# api.AdmUpdateSite(auth.auth, siteid[0], {"max_slices" : maxslices}) +# except Exception, exc: +# logger.info("API: %s" % exc) +# else: +# logger.debug("Cant find site for %s. Cannot enable creation." % nodename) -def printUsage(error = None): - global funclist - if error <> None: - print "%s %s" %(sys.argv[0],error) - print USAGE - print "CMD:" - for name,function in funclist: - print "%20s\t%20s" % (name, function.__doc__) - def main(): - global api, auth, anon - - anon = {"AuthMethod":"anonymous"} - auth = None - user = None - password = None - role = 'admin' - - (opts, argv) = getopt.getopt(sys.argv[1:], "u:p:r:h") - if len(argv)==0: - printUsage() - sys.exit(1) - - for (opt, optval) in opts: - if opt == '-u': - user = optval - elif opt == '-p': - password = optval - elif opt == '-r': - role = optval - elif opt == '-h': - print USAGE - sys.exit(0) - - if user <> None: - if password is None: - try: - password = getpass.getpass() - except (EOFError, KeyboardInterrupt): - print( "" ) - sys.exit(1) - auth = {} - auth['Username'] = user - auth['AuthMethod'] = "password" - auth['AuthString'] = password - auth['Role'] = role - - cmd = functbl.get(argv[0], None) - if cmd is None: - printUsage() - sys.exit(1) - logger.setLevel(logging.DEBUG) ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) formatter = logging.Formatter('logger - %(message)s') ch.setFormatter(formatter) logger.addHandler(ch) - result = cmd(argv[1:]) - print result - -funclist = (("nodesDbg",nodesDbg), - ("siteId", siteId), - ("slices", slices), - ("pcu", getpcu), - ("siteNodes", getSiteNodes), - ("nodeBootState", nodeBootState), - ("nodePOD", nodePOD), - ("freezeSlices", suspendSlices), - ("unfreezeSlices", enableSlices), - ("disableSliceCreation",removeSliceCreation), - ("enableSliceCreation", enableSliceCreation)) - -functbl = {} -for f in funclist: - functbl[f[0]]=f[1] + #print getpcu("kupl2.ittc.ku.edu") + #print getpcu("planetlab1.cse.msu.edu") + #print getpcu("alice.cs.princeton.edu") + #print nodesDbg() + #nodeBootState("alice.cs.princeton.edu", "boot") + #freezeSite("alice.cs.princeton.edu") + print removeSliceCreation("alice.cs.princeton.edu") + #enableSliceCreation("alice.cs.princeton.edu", 1024) + #print getSiteNodes("princeton") + #print siteId("alice.cs.princeton.edu") + #print nodePOD("alice.cs.princeton.edu") + #print slices("princeton") if __name__=="__main__": - import reboot main()