X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=plc.py;h=5be15c8ea808d9584f036397a47be293a28e463a;hb=refs%2Fheads%2F1.0;hp=42335aaca22058b2cadc28ea38bc9ce4c190453e;hpb=7fad46f10daadc869e71ffc0325724e10a5b8986;p=monitor.git diff --git a/plc.py b/plc.py index 42335aa..5be15c8 100644 --- a/plc.py +++ b/plc.py @@ -5,30 +5,133 @@ # # 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 -XMLRPC_SERVER = 'https://www.planet-lab.org/PLCAPI/' +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 = [] - api = xmlrpclib.Server(XMLRPC_SERVER, verbose=False) + api = xmlrpclib.Server(auth.server, verbose=False) anon = {'AuthMethod': "anonymous"} - allnodes = api.AnonAdmGetNodes(anon, [], ['hostname','boot_state']) - for node in allnodes: - if node['boot_state'] == 'dbg': dbgNodes.append(node['hostname']) + 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 @@ -37,169 +140,225 @@ def nodesDbg(): Returns loginbase for given nodename ''' def siteId(nodename): - api = xmlrpclib.Server(XMLRPC_SERVER, verbose=False) - anon = {'AuthMethod': "anonymous"} - site_id = api.AnonAdmQuerySite (anon, {"node_hostname": 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'] + else: + print "Not nodes returned!!!!" ''' Returns list of slices for a site. ''' def slices(loginbase): - api = xmlrpclib.Server(XMLRPC_SERVER, verbose=False) - return api.SliceListNames (auth.auth, 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(XMLRPC_SERVER, verbose=False) + api = xmlrpclib.Server(auth.server, verbose=False, allow_none=True) anon = {'AuthMethod': "anonymous"} - nodes = [] - site_id = api.AnonAdmQuerySite (anon, {"node_hostname": nodename}) - if len(site_id) == 1: - # PCU uname, pw, etc - try: - sitepcu = api.AdmGetSitePowerControlUnits(auth.auth, site_id[0])[0] - # returns node_id and port - sitepcuports = api.AdmGetPowerControlUnitNodes(auth.auth, sitepcu['pcu_id']) - # Joining feilds - for nodeidports in sitepcuports: - nodeidports.update(api.AnonAdmGetNodes(anon, - [nodeidports['node_id']], ["node_id", "hostname"])[0]) - nodes.append(nodeidports) - - # WHY THE FUCK DOES EVERY XMl+RPC RETURN A FUCKING ARRAY????? - # FURTHER, WHY THE FUCK WOULD YOU RETURN A NODE-ID WHEN SANITY WOULD SUGGEST - # FQDN???? /RANT - for node in nodes: - sitepcu[node['hostname']] = node['port_number'] - - # Sanity Check. Make sure the node is in the return, if not, barf. - if nodename in sitepcu.keys(): - return sitepcu - else: - raise Exception - except Exception, err: - logger.debug("getpcu: %s" % err) - return + 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("Cant find site for %s" % nodename) + 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): - api = xmlrpclib.Server(XMLRPC_SERVER, verbose=False) +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) + print "getSiteNodes: %s" % exc + return nodelist + + +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 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 +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(XMLRPC_SERVER, verbose=False) - anon = {'AuthMethod': "anonymous"} - 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.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) + 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) + +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(XMLRPC_SERVER, verbose=False) - anon = {'AuthMethod': "anonymous"} - 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.auth, node_id[0]) - except Exception, exc: + 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) ''' Freeze all site slices. ''' def suspendSlices(nodename): - api = xmlrpclib.Server(XMLRPC_SERVER, verbose=False) + 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.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(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 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("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(XMLRPC_SERVER, verbose=False) +# 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) + 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): - api = xmlrpclib.Server(XMLRPC_SERVER, verbose=False) - anon = {'AuthMethod': "anonymous"} - siteid = api.AnonAdmQuerySite (anon, {"node_hostname": nodename}) - numslices = api.AdmGetSites(auth.auth, siteid, ["max_slices"])[0]['max_slices'] - if len(siteid) == 1: - logger.info("Removing slice creation for site %s" % siteId(nodename)) - try: - if not config.debug: - api.AdmUpdateSite(auth.auth, siteid[0], {'max_slices': 0}) - return numslices - except Exception, exc: - logger.info("removeSliceCreation: %s" % exc) - else: - logger.debug("Cant find site for %s. Cannot revoke creation." % 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(XMLRPC_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 config.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 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 main(): logger.setLevel(logging.DEBUG) @@ -212,14 +371,14 @@ def main(): #print getpcu("planetlab1.cse.msu.edu") #print getpcu("alice.cs.princeton.edu") #print nodesDbg() - #nodeBootState("alice.cs.princaeton.edu", "boot") + #nodeBootState("alice.cs.princeton.edu", "boot") #freezeSite("alice.cs.princeton.edu") - #removeSliceCreation("alice.cs.princeton.edu") + print removeSliceCreation("alice.cs.princeton.edu") #enableSliceCreation("alice.cs.princeton.edu", 1024) - print getSiteNodes("princeton") + #print getSiteNodes("princeton") #print siteId("alice.cs.princeton.edu") - #print nodePOD("planetlab5.warsaw.rd.tp.pl") + #print nodePOD("alice.cs.princeton.edu") + #print slices("princeton") if __name__=="__main__": - import reboot main()