def main():
manager = HenManager()
manager.initLogging()
# doc = minidom.Document()
# nodesTag = doc.createElement("nodes")
# doc.appendChild(nodesTag)
#
# nodes = manager.getNodes("all")
# for nodeTypeDictionary in nodes.values():
# for node in nodeTypeDictionary.values():
#
# nodeTag = doc.createElement("node")
# nodesTag.appendChild(nodeTag)
# targetNode = node.getNodeID()
# nodeTag.setAttribute("id", targetNode)
#
# print doc.toprettyxml(indent = ' ')
print "Cache-Control: no-store, no-cache, must-revalidate"
print "Content-type: text/xml\n\n"
print "<nodes>"
nodes = manager.getNodes("all")
for nodeTypeDictionary in nodes.values():
for node in nodeTypeDictionary.values():
print "\t<node id=\"" + node.getNodeID() + "\"/>"
print "</nodes>"
def writeDHCPConfig(self):
"""\brief Writes the dhcp config file
"""
dnsServer = self.getDHCPConfigInfo().getDomainNameServers()
self.__outputFile = open(self.__outputFilename, "w")
manager = HenManager()
nodes = manager.getNodes("all", "all")
# if (not self.__parser):
# print "error: parser is null"
# return
# self.__parser.parseAll()
# nodes = self.__parser.getNodes("all", "all")
# write initial block
self.__writeStartingBlock()
# process each subnet
subnetInfoList = self.getDHCPConfigInfo().getSubnetInfoList()
for subnetInfo in subnetInfoList:
self.__writeSubnetBlock(subnetInfo)
if (subnetInfo.getSubnetType() == "experimental"):
for nodeType in nodes.keys():
for node in nodes[nodeType].values():
interfacesList = node.getInterfaces("management")
if (interfacesList != None):
for interface in interfacesList:
self.__writeNode(node.getNodeID(), interface,
node.getNetbootable(),
dnsServer, node.getNodeType(),
subnetInfo.getDomainName())
elif (subnetInfo.getSubnetType() == "infrastructure"):
for nodeType in nodes.keys():
for node in nodes[nodeType].values():
interfacesList = node.getInterfaces("infrastructure")
if (interfacesList != None):
for interface in interfacesList:
self.__writeNode(node.getNodeID(), interface,
node.getNetbootable(),
dnsServer, node.getNodeType(),
subnetInfo.getDomainName())
elif (subnetInfo.getSubnetType() == "virtual"):
for nodeType in nodes.keys():
for node in nodes[nodeType].values():
interfacesList = node.getInterfaces("virtual")
if (interfacesList != None):
for interface in interfacesList:
self.__writeNode(node.getNodeID(), interface,
node.getNetbootable(),
dnsServer, node.getNodeType(),
subnetInfo.getDomainName())
self.__writeEndingBlock()
self.__closeFile()
return 0
def interfaceid_to_mac(node_str,interface_str):
manager = HenManager()
manager.initLogging()
nodes = manager.getNodes("all","all")
for nt in nodes:
for nn in nodes[nt]:
if nodes[nt][nn].getNodeID().upper() == str(node_str).upper():
mac = getmac_from_interface(nodes[nt][nn],interface_str)
return mac
return None
def writeDHCPConfig(self):
"""\brief Writes the dhcp config file
"""
dnsServer = self.getDHCPConfigInfo().getDomainNameServers()
self.__outputFile = open(self.__outputFilename, "w")
manager = HenManager()
nodes = manager.getNodes("all","all")
# if (not self.__parser):
# print "error: parser is null"
# return
# self.__parser.parseAll()
# nodes = self.__parser.getNodes("all", "all")
# write initial block
self.__writeStartingBlock()
# process each subnet
subnetInfoList = self.getDHCPConfigInfo().getSubnetInfoList()
for subnetInfo in subnetInfoList:
self.__writeSubnetBlock(subnetInfo)
if (subnetInfo.getSubnetType() == "experimental"):
for nodeType in nodes.keys():
for node in nodes[nodeType].values():
interfacesList = node.getInterfaces("management")
if (interfacesList != None):
for interface in interfacesList:
self.__writeNode(node.getNodeID(), interface, node.getNetbootable(), dnsServer, node.getNodeType(), subnetInfo.getDomainName())
elif (subnetInfo.getSubnetType() == "infrastructure"):
for nodeType in nodes.keys():
for node in nodes[nodeType].values():
interfacesList = node.getInterfaces("infrastructure")
if (interfacesList != None):
for interface in interfacesList:
self.__writeNode(node.getNodeID(), interface, node.getNetbootable(), dnsServer, node.getNodeType(), subnetInfo.getDomainName())
elif (subnetInfo.getSubnetType() == "virtual"):
for nodeType in nodes.keys():
for node in nodes[nodeType].values():
interfacesList = node.getInterfaces("virtual")
if (interfacesList != None):
for interface in interfacesList:
self.__writeNode(node.getNodeID(), interface, node.getNetbootable(), dnsServer, node.getNodeType(), subnetInfo.getDomainName())
self.__writeEndingBlock()
self. __closeFile()
return 0
class ConfigReader(Daemon):
"""\brief Implements basic config daemon functionality.
"""
__version = "Config Daemon v0.1 (simple)"
__henManager = None
def __init__(self):
Daemon.__init__(self)
self.__henManager = HenManager()
self.__registerMethods()
def __registerMethods(self):
self.registerMethodHandler("get_object_for_id", self.getObjectForId)
self.registerMethodHandler("stop_daemon", self.stopDaemon)
def __sendReply(self,prot,code,seq,payload):
if (code == 0):
code = 200
else:
code = 422 # returnCodes[422] = "error executing command"
prot.sendReply(code, seq, payload)
def getObjectForId(self,prot,seq,ln,payload):
nodes = self.__henManager.getNodes("all")
for ntk in nodes:
#print "ntk ",str(ntk)
for nk in nodes[ntk]:
#print "nk ",str(nk)
if nodes[ntk][nk].getNodeID() == payload:
payload=pickle.dumps(nodes[ntk][nk])
code = 0
self.__sendReply(prot,code,seq,payload)
return
payload = "not found"
code = -1
self.__sendReply(prot,code,seq,payload)
def stopDaemon(self,prot,seq,ln,payload):
"""\brief Stops the daemon and all threads
This method will first stop any more incoming queries, then wait for
any update tasks to complete, before stopping itself.
"""
log.info("stopDaemon called.")
prot.sendReply(200, seq, "Accepted stop request.")
log.debug("Sending stopDaemon() response")
self.acceptConnections(False)
log.info("Stopping ConfigDaemon (self)")
self.stop()
class ConfigReader(Daemon):
"""\brief Implements basic config daemon functionality.
"""
__version = "Config Daemon v0.1 (simple)"
__henManager = None
def __init__(self):
Daemon.__init__(self)
self.__henManager = HenManager()
self.__registerMethods()
def __registerMethods(self):
self.registerMethodHandler("get_object_for_id", self.getObjectForId)
self.registerMethodHandler("stop_daemon", self.stopDaemon)
def __sendReply(self, prot, code, seq, payload):
if (code == 0):
code = 200
else:
code = 422 # returnCodes[422] = "error executing command"
prot.sendReply(code, seq, payload)
def getObjectForId(self, prot, seq, ln, payload):
nodes = self.__henManager.getNodes("all")
for ntk in nodes:
#print "ntk ",str(ntk)
for nk in nodes[ntk]:
#print "nk ",str(nk)
if nodes[ntk][nk].getNodeID() == payload:
payload = pickle.dumps(nodes[ntk][nk])
code = 0
self.__sendReply(prot, code, seq, payload)
return
payload = "not found"
code = -1
self.__sendReply(prot, code, seq, payload)
def stopDaemon(self, prot, seq, ln, payload):
"""\brief Stops the daemon and all threads
This method will first stop any more incoming queries, then wait for
any update tasks to complete, before stopping itself.
"""
log.info("stopDaemon called.")
prot.sendReply(200, seq, "Accepted stop request.")
log.debug("Sending stopDaemon() response")
self.acceptConnections(False)
log.info("Stopping ConfigDaemon (self)")
self.stop()
def check_port(computer_str,interface_str):
print computer_str,interface_str,
switch_str = ""
port_str = ""
computer = None
interface = None
switch = None
port = None
switch_obj = None
manager = HenManager()
manager.initLogging()
nodes = manager.getNodes("all")
for node_type in nodes:
for node in nodes[node_type]:
if nodes[node_type][node].getNodeID() == computer_str:
computer = nodes[node_type][node]
break
if computer != None:
interfaces = computer.getInterfaces()
for interface_type in interfaces:
for iface in interfaces[interface_type]:
if iface.getInterfaceID() == interface_str:
switch_str = iface.getSwitch()
port_str = iface.getPort()
for node_type in nodes:
for node in nodes[node_type]:
#print node,switch_str
if nodes[node_type][node].getNodeID() == switch_str:
switch = nodes[node_type][node]
break
if switch != None:
switch_obj = switch.getInstance()
if switch_obj != None:
port_internal_id = switch_obj.getPortInternalID(port_str)
if (switch_obj.getPortStatus(port_str) == 1):
print "up",
else:
print "down"
#print switch_obj.getPortsSpeedByInternalID([port_internal_id])[0][1]
print switch_obj.getPortTdr(port_str)
def run(self,argv):
if len(argv) != 2:
print "Usage :"+argv[0]+" <powerswitch name>"
sys.exit(1)
self.target_name = argv[1]
manager = HenManager()
manager.initLogging()
nodes = manager.getNodes("powerswitch","all")
self.target = None
for node in nodes.values():
if (node.getNodeID() == self.target_name):
self.target = node.getInstance()
if self.target == None:
print "Unknown powerswitch "+argv[1]
sys.exit(1)
self.run_tests()
def old(self):
BASE_URL="cgi-bin/gui/components/network/"
manager = HenManager()
manager.initLogging()
links = manager.getLinks("all","all")
graph = pydot.Dot()
switches = manager.getNodes("switch")
for switch in switches.values():
if self.__switchStatuses.has_key(switch.getNodeID()):
if self.__switchStatuses[switch.getNodeID()] == 1:
graph.add_node(pydot.Node(switch.getNodeID(),URL=BASE_URL+\
"switchinfocgi.py?id="+switch.getNodeID(),\
style="filled",color="chartreuse1"))
else:
graph.add_node(pydot.Node(switch.getNodeID(),URL=BASE_URL+\
"switchinfocgi.py?id="+switch.getNodeID(),\
style="filled",color="firebrick"))
else:
graph.add_node(pydot.Node(switch.getNodeID(),URL=BASE_URL+\
"switchinfocgi.py?id="+switch.getNodeID()))
for linktype in links.values():
for link in linktype.values():
members = link.getLinkMembers()
graph.add_edge(pydot.Edge(str(members[0].getDeviceId()),\
str(members[1].getDeviceId()),label=link.getLinkId(),\
arrowhead="none",headlabel=str(members[1].getDevicePort().\
replace('GigabitEthernet ','').replace('Management','M')),\
taillabel=str(members[0].getDevicePort().\
replace('GigabitEthernet','')),fontsize=8,\
tooltip=link.getLinkId(),\
URL=BASE_URL+"linkinfocgi.py?id="+link.getLinkId()))
# prog='circo' isn't bad
print graph.create_svg(prog='dot')
class DetectorDaemon(threading.Thread):
def __init__(self, d, debug):
self.__debug = debug
self.__device_list = d
self.__run = True
self.__nodes = {}
self.__running = []
self.__man_ips = {}
self.__inf_ips = {}
self.__symlinksRoot = "/export/machines/"
if self.__debug:
self.__etcRoot = "/usr/local/hen/etc/daemons/autodetectiond/debug/"
else:
self.__etcRoot = "/usr/local/hen/etc/daemons/autodetectiond/"
self.load_data()
self.show_stats()
threading.Thread.__init__(self)
def show_stats(self):
count = 0
string = "Number of free management ips :"
for i in self.__man_ips:
if self.__man_ips[i] == "free":
count = count + 1
string = string + str(count)
log.info(string)
count = 0
string = "Number of free infrastructure ips :"
for i in self.__inf_ips:
if self.__inf_ips[i] == "free":
count = count + 1
string = string + str(count)
log.info(string)
def load_data(self):
log.info("Loading Data")
self.__manager = HenManager()
for i in range(1, 254):
self.__man_ips["192.168.0." + str(i)] = "free"
self.__inf_ips["192.168.1." + str(i)] = "free"
n = self.__manager.getNodes("all", "all")
for nt in n:
for node in n[nt].values():
try:
man_ip = node.getInterfaces("management")
inf_ip = node.getInterfaces("infrastructure")
if man_ip != []:
self.__nodes[man_ip[0].getIP()] = node
self.__man_ips[str(man_ip[0].getIP())] = node.getNodeID()
if inf_ip != []:
self.__nodes[inf_ip[0].getIP()] = node
self.__inf_ips[str(inf_ip[0].getIP())] = node.getNodeID()
except:
pass
self.show_stats()
def getFreeIp(self, type_str):
if type_str == "infrastructure":
for i in self.__inf_ips:
if self.__inf_ips[i] == "free":
return i
return "no free infrastructure ip"
elif type_str == "management":
for i in self.__man_ips:
if self.__man_ips[i] == "free":
return i
return "no free infrastructure ip"
else:
return "unknown ip type " + type_str
def writeXML(self, node, old=False):
xmlstring = self.__manager.parser.writeNodePhysicalFileString(node, self.__debug)
print xmlstring
filename = self.__etcRoot + node.getNodeID() + ".xml"
if old:
filename = filename + ".old"
try:
if not self.__debug:
theFile = open(filename, "w")
theFile.write(xmlstring)
theFile.close()
else:
print "Would write to file ", filename
print xmlstring
except Exception, e:
log.info("error while writing xml file for " + str(node.getNodeID()))
log.info(str(e))
return -1
class ComputerControl(Daemon):
"""\brief Implements basic computer daemon functionality.
"""
__version = "Computer Daemon v0.1 (simple)"
__henManager = None
def __init__(self):
Daemon.__init__(self)
self.__henManager = HenManager()
# Allow specialized instance dictionary to be created in hm
# self.__henManager.createNodeInstances()
self.__registerMethods()
self.__computerID = self.__getComputerID()
self.__computerInfo = self.__henManager.getNodes("computer")[self.__computerID]
self.__ifaceIDtoNameMappings = self.__getIfaceMappings()
def getComputerManagementIP(self):
# Get the management ip address so that we can bind to it.
interfaces = self.__computerInfo.getInterfaces("management")
try:
return interfaces[0].getIP()
except:
return "0.0.0.0"
def __getComputerID(self):
# Prints the name of the node that the script is run from. To do so it matches the mac addresses of
# all running interfaces against the mac addresses in the testbed's database. Prints None if no match is found
# First create a list containing the mac addresses of all the running interfaces
macAddresses = []
macAddressMatcher = re.compile("(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}")
lines = commands.getstatusoutput("ifconfig")[1].splitlines()
for line in lines:
matchObject = macAddressMatcher.search(line)
if matchObject:
macAddresses.append(line[matchObject.start() : matchObject.end()].upper())
# Now match the created list against all of the management mac addresses in the testbed's database
# for computer nodes
self.__henManager.initLogging()
nodes = self.__henManager.getNodes("computer", "all")
nodeName = None
for node in nodes.values():
for interface in node.getInterfaces("management"):
for macAddress in macAddresses:
if macAddress == interface.getMAC().upper():
nodeName = node.getNodeID()
if nodeName == None:
nodes = self.__henManager.getNodes("virtualcomputer", "all")
for node in nodes.values():
for interface in node.getInterfaces("management"):
for macAddress in macAddresses:
if macAddress == interface.getMAC().upper():
nodeName = node.getNodeID()
return nodeName
def __getIfaceMappings(self):
mappings = {}
# Supports only Linux for now
interfaces = self.__computerInfo.getInterfaces("experimental")
ifacesInfo = commands.getstatusoutput("ifconfig -a | grep HWaddr")[1].splitlines()
for interface in interfaces:
for infoLine in ifacesInfo:
if infoLine.find(interface.getMAC()) != -1:
mappings[interface.getInterfaceID()] = infoLine[: infoLine.find(" ")]
return mappings
def __registerMethods(self):
self.registerMethodHandler("get_computer_id", self.getComputerID)
self.registerMethodHandler("autodetect", self.autodetect)
self.registerMethodHandler("execute_command", self.executeCommand)
self.registerMethodHandler("gcc_compile", self.gccCompile)
self.registerMethodHandler("cat", self.cat)
self.registerMethodHandler("make", self.make)
self.registerMethodHandler("mkdir", self.mkdir)
self.registerMethodHandler("untar", self.untar)
self.registerMethodHandler("add_route", self.addRoute)
self.registerMethodHandler("delete_route", self.delRoute)
self.registerMethodHandler("config_iface", self.configIface)
self.registerMethodHandler("click-align", self.clickAlign)
self.registerMethodHandler("click-install", self.clickInstall)
self.registerMethodHandler("click-uninstall", self.clickUninstall)
self.registerMethodHandler("load_module", self.loadModule)
self.registerMethodHandler("unload_module", self.unloadModule)
self.registerMethodHandler("linux_forwarding_on", self.linuxForwardingOn)
self.registerMethodHandler("linux_forwarding_off", self.linuxForwardingOff)
def __sendReply(self, prot, code, seq, payload):
if code == 0:
code = 200
else:
code = 422 # returnCodes[422] = "error executing command"
prot.sendReply(code, seq, payload)
def autodetect(self, prot, seq, ln, payload):
pass
def getComputerID(self, prot, seq, ln, payload):
self.__sendReply(prot, "0", seq, self.__computerID)
def executeCommand(self, prot, seq, ln, payload):
(code, payload) = commands.getstatusoutput(payload)
self.__sendReply(prot, code, seq, payload)
def gccCompile(self, prot, seq, ln, payload):
(workDir, filename) = pickle.loads(payload)
name = filename[: filename.find(".")]
(code, payload) = commands.getstatusoutput("cd " + worDir + " ; g++ -o " + name + " " + filename)
self.__sendReply(prot, code, seq, payload)
def cat(self, prot, seq, ln, payload):
# print "got cat command"
payload = pickle.loads(payload)[0]
(code, payload) = commands.getstatusoutput("cat " + str(payload))
self.__sendReply(prot, code, seq, payload)
def make(self, prot, seq, ln, payload):
(workDir, makeTarget) = pickle.loads(payload)
(code, payload) = commands.getstatusoutput("cd " + workDir + " ; make -f " + makeTarget)
self.__sendReply(prot, code, seq, payload)
def mkdir(self, prot, seq, ln, payload):
code = os.mkdir(payload)
self.__sendReply(prot, code, seq, "")
def untar(self, prot, seq, ln, payload):
(tarPath, targetDir) = pickle.loads(payload)
(code, payload) = commands.getstatusoutput("tar -xf " + path + " -C " + targetDir)
self.__sendReply(prot, code, seq, payload)
def addRoute(self, prot, seq, ln, payload):
(network, netmask, gateway, interface) = pickle.loads(payload)
(code, payload) = commands.getstatusoutput(
"route add -net " + network + " netmask " + netmask + " gw " + gateway + " dev " + interface
)
self.__sendReply(prot, code, seq, payload)
def delRoute(self, prot, seq, ln, payload):
(network, netmask) = pickle.loads(payload)
(code, payload) = commands.getstatusoutput("route del -net " + network + " netmask " + netmask)
self.__sendReply(prot, code, seq, payload)
def configIface(self, prot, seq, ln, payload):
(interfaceID, address, mask, status) = pickle.loads(payload)
try:
cmd = "ifconfig " + self.__ifaceIDtoNameMappings[interfaceID] + " "
except KeyError:
log.error("Key error " + str(self.__ifaceIDtoNameMappings))
(code, payload) = (400, "Key error for interface")
self.__sendReply(prot, code, seq, payload)
return
if status == "on":
cmd += address + " netmask " + mask + " up"
else:
cmd += "down"
(code, payload) = commands.getstatusoutput(cmd)
self.__sendReply(prot, code, seq, payload)
def clickAlign(self, prot, seq, ln, payload):
(clickAlignPath, configFile) = pickle.loads(payload)
basePath = configFile[: configFile.rfind("/")]
filename = configFile[configFile.rfind("/") + 1 : configFile.find(".")]
newPathToFile = basePath + "/" + filename + "-aligned.click'"
(code, payload) = commands.getstatusoutput(clickAlignPath + " " + configFile + " > " + newPathToFile)
self.__sendReply(prot, code, seq, payload)
def clickInstall(self, prot, seq, ln, payload):
(clickInstallPath, configFile, numberThreads) = pickle.loads(payload)
cmd = click - installPath + " "
if int(numberThreads) != 0:
cmd += "--threads=" + numberThreads + " "
cmd += configFile
(code, payload) = commands.getstatusoutput(cmd)
self.__sendReply(prot, code, seq, payload)
def clickUninstall(self, prot, seq, ln, payload):
(code, payload) = commands.getstatusoutput(payload)
self.__sendReply(prot, code, seq, payload)
def loadModule(self, prot, seq, ln, payload):
(code, payload) = commands.getstatusoutput("insmod " + payload)
self.__sendReply(prot, code, seq, payload)
def unloadModule(self, prot, seq, ln, payload):
(code, payload) = commands.getstatusoutput("rmmod " + payload)
self.__sendReply(prot, code, seq, payload)
def linuxForwardingOn(self, prot, seq, ln, payload):
(code, payload) = commands.getstatusoutput("echo '1' \> /proc/sys/net/ipv4/ip_forward")
self.__sendReply(prot, code, seq, payload)
def linuxForwardingOff(self, prot, seq, ln, payload):
(code, payload) = commands.getstatusoutput("echo '0' \> /proc/sys/net/ipv4/ip_forward")
self.__sendReply(prot, code, seq, payload)
def stopDaemon(self, prot, seq, ln, payload):
"""\brief Stops the daemon and all threads
This method will first stop any more incoming queries, then wait for
any update tasks to complete, before stopping itself.
"""
log.info("stopDaemon called.")
prot.sendReply(200, seq, "Accepted stop request.")
log.debug("Sending stopDaemon() response")
self.acceptConnections(False)
log.info("Stopping ComputerDaemon (self)")
self.stop()
def createVLAN(switch,name,id,ports=None):
vlan = VLAN(name,id,ports,None)
if switch.createVLAN(vlan) != 0:
print "Error creating vlan"
def deleteVLAN(switch,name,id):
vlan = VLAN(name,id,[],None)
if switch.deleteVLAN(vlan) != 0:
print "Error removing vlan"
print "Content-type: text/html\n\n"
print "<html><title></title><head>"
manager = HenManager()
manager.initLogging()
nodes = manager.getNodes("switch")
for n in nodes.values():
portsBlackList = []
s = n.getInstance()
#s.setSwitchName(n.getNodeID())
if s != None:
#printVlans(s)
deleteVLAN(s,"B",4)
#createVLAN(s,"A",3,["GigabitEthernet2/1/1","GigabitEthernet2/1/2","GigabitEthernet2/1/3","GigabitEthernet2/1/4"])
#createVLAN(s,"B",4,["GigabitEthernet2/1/5","GigabitEthernet2/1/6","GigabitEthernet2/1/7","GigabitEthernet2/1/8"])
#addPorts(s,"vlana",["GigabitEthernet2/1/1","GigabitEthernet2/1/2","GigabitEthernet2/1/3"])
#deletePorts(s,"vlana",["GigabitEthernet2/1/1","GigabitEthernet2/1/2","GigabitEthernet2/1/3"])
#
#addPorts(s,"henexp",[107,106,101])
#deletePorts(s,"henexp",[108,109,110,111,112,115,116,117])
p = auxiliary.protocol.Protocol(None)
# read connection info from user
# host = raw_input("host name (localhost):")
# if (host==""):
# host = "localhost"
# try:
# port = int(raw_input("port (1105):"))
# except:
## port = 1105
host = DaemonPorts().powerDaemonHost
port = DaemonPorts().powerDaemonPort
print "connecting to " + host + "port " + str(port)
p.open(host, port)
# send state!
payload = "10," + pickle.dumps(hm.getNodes("all"))
# p.sendRequest("set_config",payload,state_check)
# p.readAndProcess()
p.doSynchronousCall("set_config", payload)
# read smth from the user
while True:
method = raw_input("method:")
payload = raw_input("payload:")
# p.sendRequest(method,payload,handler)
# p.readAndProcess()
print p.doSynchronousCall(method, payload)
for i in temp:
sys.path.append(i)
from henmanager import HenManager
###########################################################################################
# Main execution
###########################################################################################
print "Content-Type: text/xml"
print ""
print ""
print "<row>"
manager = HenManager("/usr/local/hen/etc/configs/config" )
racks = manager.getInfrastructures("rack")
nodes = manager.getNodes("all", "all")
rackNodes = {}
for key in racks.keys():
rackNodes[key] = []
for nodeTypeDictionary in nodes.values():
for node in nodeTypeDictionary.values():
location = node.getPhysicalLocation()
if (location != None):
if rackNodes.has_key(location.getRackName()):
s = '<node id="' + str(node.getNodeID())
s += '" type="physicallocation-' + str(node.getNodeType())
if (location.getRackStartUnit() != None):
s += '" rackstartunit="' + str(location.getRackStartUnit())
class DetectorDaemon(threading.Thread):
def __init__(self, d, debug):
self.__debug = debug
self.__device_list = d
self.__run = True
self.__nodes = {}
self.__running = []
self.__man_ips = {}
self.__inf_ips = {}
self.__symlinksRoot = "/export/machines/"
if self.__debug:
self.__etcRoot = "/usr/local/hen/etc/daemons/autodetectiond/debug/"
else:
self.__etcRoot = "/usr/local/hen/etc/daemons/autodetectiond/"
self.load_data()
self.show_stats()
threading.Thread.__init__(self)
def show_stats(self):
count = 0
string = "Number of free management ips :"
for i in self.__man_ips:
if self.__man_ips[i] == "free":
count = count + 1
string = string + str(count)
log.info(string)
count = 0
string = "Number of free infrastructure ips :"
for i in self.__inf_ips:
if self.__inf_ips[i] == "free":
count = count + 1
string = string + str(count)
log.info(string)
def load_data(self):
log.info("Loading Data")
self.__manager = HenManager()
for i in range(1, 254):
self.__man_ips["192.168.0." + str(i)] = "free"
self.__inf_ips["192.168.1." + str(i)] = "free"
n = self.__manager.getNodes("all", "all")
for nt in n:
for node in n[nt].values():
try:
man_ip = node.getInterfaces("management")
inf_ip = node.getInterfaces("infrastructure")
if man_ip != []:
self.__nodes[man_ip[0].getIP()] = node
self.__man_ips[str(
man_ip[0].getIP())] = node.getNodeID()
if inf_ip != []:
self.__nodes[inf_ip[0].getIP()] = node
self.__inf_ips[str(
inf_ip[0].getIP())] = node.getNodeID()
except:
pass
self.show_stats()
def getFreeIp(self, type_str):
if type_str == "infrastructure":
for i in self.__inf_ips:
if self.__inf_ips[i] == "free":
return i
return "no free infrastructure ip"
elif type_str == "management":
for i in self.__man_ips:
if self.__man_ips[i] == "free":
return i
return "no free infrastructure ip"
else:
return "unknown ip type " + type_str
def writeXML(self, node, old=False):
xmlstring = self.__manager.parser.writeNodePhysicalFileString(
node, self.__debug)
print xmlstring
filename = self.__etcRoot + node.getNodeID() + ".xml"
if old:
filename = filename + ".old"
try:
if not self.__debug:
theFile = open(filename, "w")
theFile.write(xmlstring)
theFile.close()
else:
print "Would write to file ", filename
print xmlstring
except Exception, e:
log.info("error while writing xml file for " +
str(node.getNodeID()))
log.info(str(e))
return -1
#! /usr/bin/env python
from henmanager import HenManager
from auxiliary.hen import Node, SwitchNode, VLAN, Port
manager = HenManager()
manager.initLogging()
nodes = manager.getNodes("switch")
theSwitch = None
for node in nodes.values():
# print node
if (node.getNodeID() == "switch1"):
print node.getNodeID()
theSwitch = node.getInstance()
vlans = theSwitch.getFullVLANInfo()
for vlan in vlans:
print vlan
#res = theSwitch.getVLANToInterfacesTable()
#for p in res:
# print str(p) + " res " + str(res[p])
from auxiliary.protocol import Protocol
import datetime
powerdaemon = Protocol(None)
powerdaemon.open(DaemonLocations.powerDaemon[0], DaemonLocations.powerDaemon[1])
version = powerdaemon.doSynchronousCall("get_config_version","")
print "Version is "+str(version[0][2])
tics = os.stat('/usr/local/hen/etc/physical/topology.xml')[ST_MTIME]
t = datetime.datetime.fromtimestamp(tics)
lastAccess=str(t.strftime('%Y-%m-%d'))
print "Last access time is "+lastAccess
if (str(lastAccess)!=str(version[0][2])):
print "Setting new config"
from henmanager import HenManager
hm = HenManager()
payload = lastAccess + ","+ pickle.dumps(hm.getNodes("all"))
print "Result is:"+str(powerdaemon.doSynchronousCall("set_config",payload))
def addLink(tag,action,old,new):
print "AddLink got "+tag,action,old,new
def removeLink(tag,action,old,new):
print "RemoveLink got "+tag,action,old,new
def changePowerState(tag,action,node,attr):
print "changePowerState got "+tag,action,node,attr
id = node.xpath("ancestor::node")[0].attributes[(None,'id')].value
param = str(id)+","+str(attr.value)
print "Calling powerdaemon power with param "+param
import datetime
powerdaemon = Protocol(None)
powerdaemon.open(DaemonLocations.powerDaemon[0],
DaemonLocations.powerDaemon[1])
version = powerdaemon.doSynchronousCall("get_config_version", "")
print "Version is " + str(version[0][2])
tics = os.stat('/usr/local/hen/etc/physical/topology.xml')[ST_MTIME]
t = datetime.datetime.fromtimestamp(tics)
lastAccess = str(t.strftime('%Y-%m-%d'))
print "Last access time is " + lastAccess
if (str(lastAccess) != str(version[0][2])):
print "Setting new config"
from henmanager import HenManager
hm = HenManager()
payload = lastAccess + "," + pickle.dumps(hm.getNodes("all"))
print "Result is:" + str(
powerdaemon.doSynchronousCall("set_config", payload))
def addLink(tag, action, old, new):
print "AddLink got " + tag, action, old, new
def removeLink(tag, action, old, new):
print "RemoveLink got " + tag, action, old, new
def changePowerState(tag, action, node, attr):
print "changePowerState got " + tag, action, node, attr
id = node.xpath("ancestor::node")[0].attributes[(None, 'id')].value
#!/usr/local/bin/python
from henmanager import HenManager
import time
import resource
import gc
manager = HenManager()
manager.initLogging()
switches = manager.getNodes("all","all")
alive_list =['switch14', 'switch5', 'serviceprocessor16', 'sensor1', 'serviceprocessor20','serviceprocessor22','serviceprocessor42','serviceprocessor43','serviceprocessor44', 'powerswitch3', 'switch1', 'switch2', 'switch3' , 'switch4' ,'switch8', 'computer71' ]
switch = {}
#sn = {}
#switch_node = None
for a in switches.values():
for sw in a.values():
for h in alive_list:
if sw.getNodeID() == h:
try:
switch[sw.getNodeID()] = sw.getInstance()
except:
pass
num = 1
while True:
print "run ",num
for s in switch.keys():
print s
#sn[s] = switch[s].getSensorReadings()
class HardwareDetectionRunner:
__prot = None
__host = None
__port = None
__hm = None
__interfaceNames = None
__data = None
def __init__(self, host, port):
self.__prot = auxiliary.protocol.Protocol(None)
self.__host = host
self.__port = port
self.__data = ""
self.__hm = HenManager()
def run(self):
"""\brief Runs all the necessary detection methods."""
print "Running hardware detection:"
print "\tRetrieving experimental interface names..."
self.getExperimentalInterfacesNames()
print "\tPolling interfaces..."
self.pollInterfaces()
# Sometimes mii-tool will report no link if this sleep time is not here
print "Waiting " + str(AUTONEGOTIATION_WAIT_TIME) + \
" seconds for autonegotiation to finish",
self.waitForAutonegotiation()
print "Retrieving number of processors..."
self.getNumberProcessors()
print "Retrieving number of cores..."
self.getNumberCores()
print "Retrieving no-carrier-sense MACs..."
self.getNoCarrierMACs()
print "Retrieving output from lshw..."
self.getLSHWOutput()
print "Polling interfaces once to seed fdb"
self.pollInterfaces()
print "Sending results to AutodetectDaemon... "
self.sendData()
print "Polling interfaces continually..."
while 1:
self.pollInterfaces()
time.sleep(POLL_INTERFACE_INTERVAL)
def waitForAutonegotiation(self):
"""\brief Prints a dot per second whilst waiting for the number of
seconds defined by AUTONEGOTIATION_WAIT_TIME
"""
ticks = AUTONEGOTIATION_WAIT_TIME
while ticks > 0:
print '.',
ticks -= 1
time.sleep(1)
def pollInterfaces(self):
for interfaceName in self.__interfaceNames:
cmd = "/sbin/ifconfig " + interfaceName + " up"
os.system(cmd)
cmd = "etherwake -i " + interfaceName + " 00:11:22:33:44:55"
os.system(cmd)
def getExperimentalInterfacesNames(self):
# First create a list containing the mac addresses of all the interfaces
macAddresses = []
macAddressMatcher = re.compile('(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}')
lines = commands.getstatusoutput("ifconfig -a")[1].splitlines()
for line in lines:
matchObject = macAddressMatcher.search(line)
if (matchObject):
macAddresses.append(\
line[matchObject.start():matchObject.end()].upper())
# Find which of these is the management interface so we can filter it out
nodes = self.__hm.getNodes("computer", "all")
for node in nodes.values():
managementMACAddress = \
node.getInterfaces("management")[0].getMAC().upper()
if (managementMACAddress in macAddresses):
break
self.__interfaceNames = []
for macAddress in macAddresses:
if (macAddress != managementMACAddress):
# We need to convert the mac addresses to interface names
self.__interfaceNames.append(commands.getstatusoutput(\
"ifconfig -a | grep " + macAddress + \
" | awk '{print $1}'")[1])
def getNumberProcessors(self):
data = commands.getstatusoutput(\
"cat /proc/cpuinfo | grep 'physical id'")[1]
data = data.split("\n")
uniqueIDs = []
for line in data:
processorID = line[line.find(":") + 1:]
if (processorID not in uniqueIDs):
uniqueIDs.append(processorID)
self.__data += "<numbercpus>%s</numbercpus>" % str(len(uniqueIDs))
def getNumberCores(self):
data = commands.getstatusoutput(\
"cat /proc/cpuinfo | grep 'cpu cores'")[1]
cores = 1
try:
data = data.split("\n")[0]
cores = int(data[data.find(":") + 1:])
except:
pass
self.__data += "<numbercorespercpu>%s</numbercorespercpu>" % str(cores)
def getNoCarrierMACs(self):
self.__data += "<nocarriermacs>"
data = commands.getstatusoutput("mii-tool")[1]
data = data.split("\n")
counter = 0
for line in data:
if (line.find("no link") != -1):
ifaceName = line[:line.find(":")]
data = commands.getstatusoutput(\
"ifconfig " + ifaceName)[1].split("\n")[0]
macAddress = data[data.find("HWaddr") + 7:].strip()
self.__data += str(macAddress).upper()
counter += 1
if (counter != len(noCarrierMACs)):
self.__data += ","
self.__data += "</nocarriermacs>"
def getLSHWOutput(self):
self.__data += commands.getstatusoutput("/usr/sbin/lshw -xml")[1]
def sendData(self):
"""\brief Connects to the autodetectdaemon and sends the data created
by the detection code.
"""
self.__prot.open(self.__host, self.__port)
self.__prot.sendRequest("receive_detectiondata", \
self.__data, \
self.responseHandler)
self.__prot.readAndProcess()
def responseHandler(self, code, seq, size, payload):
"""\brief Handles the response from the autodetectdaemon. We can add
code here for re-sending the data, if need be.
"""
if code == 200:
print "Data successfully received by AutodetectDaemon"
self.__prot.close()
else:
print "ERROR: Received code[%s] from daemon. Payload = %s" % \
(str(code), str(payload))
class AutodetectManager(Daemon):
__hen_manager = None
__hardware_processor = None
def __init__(self):
Daemon.__init__(self)
self.__hen_manager = HenManager()
self.__hen_manager.initLogging()
self.__hardware_processor = LSHardwareProcessor(self.__hen_manager, \
self.__parseMacTableURL())
self.__registerMethods()
def __parseMacTableURL(self):
"""\brief Parses the Hen config file, and returns the MACTABLE_URL
\return macTableURL - the value of MACTABLE_URL in the Hen config
"""
configFile = ConfigParser.ConfigParser()
configFile.read(HEN_CONFIG)
return configFile.get('AUTODETECT', 'MACTABLE_URL')
def __registerMethods(self):
self.registerMethodHandler("receive_detectiondata", \
self.receiveDetectionData)
self.registerMethodHandler("enable_debug_mode", \
self.enableDebugMode)
self.registerMethodHandler("disable_debug_mode", \
self.disableDebugMode)
def enableDebugMode(self,prot,seq,ln,payload):
self.__hardware_processor.enableDebugMode()
prot.sendReply(200, seq, "")
def disableDebugMode(self,prot,seq,ln,payload):
self.__hardware_processor.disableDebugMode()
prot.sendReply(200, seq, "")
def receiveDetectionData(self,prot,seq,ln,payload):
"""\brief Method called when detection data is received from
autodetectclient scripts being run on remote hosts.
"""
log.debug("receiveDetectionData() called.")
(nodeid, addr) = self.__ipAddressToNodeID(prot.getSocket())
if not nodeid or not addr:
log.warning("Bad results from __ipAddressToNodeID().")
prot.sendReply(500, seq, \
"Failure: Daemon could not resolve IP to nodeid.")
return
log.info("received data from %s (%s)" % (str(addr), str(nodeid)))
prot.sendReply(200, seq, "")
self.__hardware_processor.parseFileAndPrint(nodeid, payload)
def __ipAddressToNodeID(self, sock):
"""\brief Retrieves the IP address of the connected client, then tries
to look up a nodeid for it from HenManager
\param sock - socket on which the client is connected
\return nodeid - id of node to which IP address belongs, -1 if not
found
"""
try:
(addr, port) = sock.getpeername()
log.debug("addr %" + str(addr))
computerNodes = self.__hen_manager.getNodes("computer", "all")
for computerNode in computerNodes.values():
interfaces = computerNode.getInterfaces("management")
for interface in interfaces:
if (interface.getIP() == addr):
return (computerNode.getNodeID(), addr)
except:
pass
return (None, None)
class AutodetectManager(Daemon):
__hen_manager = None
__hardware_processor = None
def __init__(self):
Daemon.__init__(self)
self.__hen_manager = HenManager()
self.__hen_manager.initLogging()
self.__hardware_processor = LSHardwareProcessor(self.__hen_manager, \
self.__parseMacTableURL())
self.__registerMethods()
def __parseMacTableURL(self):
"""\brief Parses the Hen config file, and returns the MACTABLE_URL
\return macTableURL - the value of MACTABLE_URL in the Hen config
"""
configFile = ConfigParser.ConfigParser()
configFile.read(HEN_CONFIG)
return configFile.get('AUTODETECT', 'MACTABLE_URL')
def __registerMethods(self):
self.registerMethodHandler("receive_detectiondata", \
self.receiveDetectionData)
self.registerMethodHandler("enable_debug_mode", \
self.enableDebugMode)
self.registerMethodHandler("disable_debug_mode", \
self.disableDebugMode)
def enableDebugMode(self, prot, seq, ln, payload):
self.__hardware_processor.enableDebugMode()
prot.sendReply(200, seq, "")
def disableDebugMode(self, prot, seq, ln, payload):
self.__hardware_processor.disableDebugMode()
prot.sendReply(200, seq, "")
def receiveDetectionData(self, prot, seq, ln, payload):
"""\brief Method called when detection data is received from
autodetectclient scripts being run on remote hosts.
"""
log.debug("receiveDetectionData() called.")
(nodeid, addr) = self.__ipAddressToNodeID(prot.getSocket())
if not nodeid or not addr:
log.warning("Bad results from __ipAddressToNodeID().")
prot.sendReply(500, seq, \
"Failure: Daemon could not resolve IP to nodeid.")
return
log.info("received data from %s (%s)" % (str(addr), str(nodeid)))
prot.sendReply(200, seq, "")
self.__hardware_processor.parseFileAndPrint(nodeid, payload)
def __ipAddressToNodeID(self, sock):
"""\brief Retrieves the IP address of the connected client, then tries
to look up a nodeid for it from HenManager
\param sock - socket on which the client is connected
\return nodeid - id of node to which IP address belongs, -1 if not
found
"""
try:
(addr, port) = sock.getpeername()
log.debug("addr %" + str(addr))
computerNodes = self.__hen_manager.getNodes("computer", "all")
for computerNode in computerNodes.values():
interfaces = computerNode.getInterfaces("management")
for interface in interfaces:
if (interface.getIP() == addr):
return (computerNode.getNodeID(), addr)
except:
pass
return (None, None)
#!/usr/bin/env python
import os, sys, commands
from henmanager import HenManager
manager = HenManager()
nodes = manager.getNodes("computer")
user = ""
usage = "usage: reservations.py [computerid] [computerid]\n"
usage += "usage: reservations.py all\n"
usage += "usage: reservations.py model [dell2950|dell1950|dell1850|sunx4100|sunv20z|delloptiplex]\n"
usage += "usage: reservations.py user [username]"
if (len(sys.argv) < 2):
print usage
os._exit(0)
if (sys.argv[1] == "model"):
if (len(sys.argv) != 3):
print usage
os._exit(0)
elif (sys.argv[2] == "dell2950"):
beginID = "computer81"
endID = "computer100"
elif (sys.argv[2] == "dell1950"):
beginID = "computer56"
endID = "computer80"
elif (sys.argv[2] == "dell1850"):
beginID = "computer21"
endID = "computer25"
class ReservationDBManager:
def __init__(self,
filename,
rightsFilename,
notificationsFilename,
dbsRoot,
maxNumWeeks=2,
debug=False):
self.__daemonEMail = "*****@*****.**"
self.__filename = filename
self.__rightsFilename = rightsFilename
self.__notificationsFilename = notificationsFilename
self.__notifications = {}
self.__dbsRoot = dbsRoot
self.__maxNumWeeks = maxNumWeeks
self.__reservations = {}
self.__rights = {}
self.__nextID = 0
self.__xmldoc = None
self.__rightsXmldoc = None
self.__henManager = HenManager()
self.__symlinksRoot = "/export/machines/"
self.__smtpServerName = "smtp.cs.ucl.ac.uk"
self.__parser = ReservationDBParser(filename, rightsFilename,
notificationsFilename,
self.__dbsRoot)
self.__notifier = None
self.__debug = debug
self.mytime = datetime.date.today()
# Start the early notification thread
self.__notifier = ReservationExpiryNotifier(self.__daemonEMail, \
self.__smtpServerName, \
self.__filename, \
self.__rightsFilename, \
self.__notificationsFilename, \
self.__dbsRoot,
self.__debug)
if not self.__debug:
self.__notifier.start()
# used to test email sending
def getNotifier(self):
return self.__notifier
def reloadHenDB(self):
self.__henManager = HenManager()
return 0
def startDB(self):
# First parse reservations database
(result, self.__xmldoc) = self.__parser.openDB(self.__filename)
if (result < 0):
log.info("error while opening database!")
return -1
elif (result == 1):
log.info(
"warning: no database file found (one will be created when a reservation is made)"
)
self.__nextID = 1
else:
(result,
self.__reservations) = self.__parser.parseDB(self.__xmldoc)
# ignore -1, this means that there are no 'reservations' tags
if (result < 0 and result != -1):
log.info("error while parsing database!")
return -1
else:
self.__nextID = self.__findHighestID() + 1
self.cleanExpired()
# Now parse reservation rights database
(result,
self.__rightsXmldoc) = self.__parser.openDB(self.__rightsFilename)
if (result < 0 or result == 1):
log.info("error while opening reservation rights database!")
return -1
(result,
self.__rights) = self.__parser.parseRightsDB(self.__rightsXmldoc)
if (result < 0):
log.info("error while parsing rights database!")
return -1
return 0
def release(self, username, reservationID):
if (not self.__reservations.has_key(username)):
return "unknown user"
released = False
reservationsBackup = self.__reservations
userReservations = self.__reservations[username]
for userReservation in userReservations:
if (str(userReservation.getReservationID()) == str(reservationID)):
userReservations.remove(userReservation)
self.__removeNotifications(userReservation.getReservationID())
released = True
break
if (not released):
return "reservation id not found"
if (self.__parser.writeDBToDisk(self.__reservations) < 0):
self.__reservations = reservationsBackup
return "error while writing to database, release failed"
self.__nextID = self.__findHighestID() + 1
return "reservation released"
def releaseDevices(self, username, devices):
if (not self.__reservations.has_key(username)):
return "unknown user"
reservationsBackup = self.__reservations
released = []
userReservations = self.__reservations[username]
for userReservation in userReservations:
for device in userReservation.getDevices():
if (device in devices):
userReservation.getDevices().remove(device)
released.append(device)
# Remove any reservations with no devices in them
for x in range(len(userReservations) - 1, -1, -1):
if (len(userReservations[x].getDevices()) == 0):
del userReservations[x]
if (len(released) == 0):
return "none of the devices were found in your reservations"
if (self.__parser.writeDBToDisk(self.__reservations) < 0):
self.__reservations = reservationsBackup
return "error while writing to database, release failed"
self.__nextID = self.__findHighestID() + 1
string = "released: "
for device in released:
string += str(device) + ", "
string = string[:len(string) - 2]
return string
def renew(self, username, reservationID, endDate):
# Check for expired reservations first and release them
self.cleanExpired()
currentDate = self.__getCurrentDate() #datetime.date.today()
if (endDate <= currentDate):
return "renewal failed: supplied end date is in the past"
maxDate = currentDate + timedelta(weeks=self.__getMaxWeeks(
username, self.__getReservedDevicesByID(reservationID)))
trimmedDate = False
if (endDate > maxDate):
endDate = maxDate
trimmedDate = True
if (self.__reservations.has_key(username)):
for userReservation in self.__reservations[username]:
if (int(userReservation.getReservationID()) == int(
reservationID)):
oldDate = userReservation.getEndDate()
userReservation.setEndDate(endDate)
self.__removeNotifications(
userReservation.getReservationID())
if (self.__parser.writeDBToDisk(self.__reservations) < 0):
userReservation.setEndDate(oldDate)
return "error while writing to database, renew failed"
message = "reservation renewed (new end date=" + str(
self.__convertDateToString(endDate)) + ")"
if (trimmedDate):
message += "\nnote: the desired date was ignored because the max allocation period is " + \
str(self.__maxNumWeeks) + " week(s)"
return message
return "no reservation found for id=" + str(
reservationID) + " and username="******"add"):
for device in devices:
if (self.__isDeviceInUse(device)):
return "reservation failed: " + str(
device) + " already reserved"
if (self.__reservations.has_key(username)):
for userReservation in self.__reservations[username]:
if (int(userReservation.getReservationID()) == int(
reservationID)):
oldDevices = userReservation.getEndDate()
oldEmail = userReservation.getEmail()
if (opType == "add"):
userReservation.appendDevices(devices)
elif (opType == "remove"):
userReservation.removeDevices(devices)
if (email != None):
userReservation.setEmail(email)
if (self.__parser.writeDBToDisk(self.__reservations) < 0):
userReservation.setDevices(oldDevices)
if (email != None):
userReservation.setEmail(oldEmail)
return "error while writing to database, update failed"
message = "reservation updated"
return message
return "no reservation found for id=" + str(
reservationID) + " and username="******"reservation failed: supplied end date is in the past"
maxDate = currentDate + timedelta(
weeks=self.__getMaxWeeks(username, devices))
trimmedDate = False
if (endDate > maxDate):
endDate = maxDate
trimmedDate = True
# First make sure that the devices are free
for device in devices:
if (self.__isDeviceInUse(device)):
return "reservation failed: " + str(
device) + " already reserved"
# Add to in-memory db
reservationID = self.__getNextID()
if (not self.__reservations.has_key(username)):
self.__reservations[username] = []
entry = ReservationEntry(username, email, devices, endDate,
reservationID)
self.__reservations[username].append(entry)
# Write-out to on-disk db
if (self.__parser.writeDBToDisk(self.__reservations) < 0):
self.__reservations[username].remove(entry)
return "reservation failed: could not write database to disk"
message = "reservation succeeded (id = " + str(reservationID) + ", " + \
"end date=" + str(self.__convertDateToString(endDate)) + ")"
if (trimmedDate):
message += "\nnote: the desired date was ignored because the max allocation period is " + \
str(self.__maxNumWeeks) + " week(s)"
return message
def getReservationsInfo(self, username):
if username == "all":
info = ""
for name in self.__reservations:
for reservation in self.__reservations[name]:
info += reservation.getInfoStr() + " " + str(name) + "\n"
return info
if (not self.__reservations.has_key(username)):
return "no info"
info = ""
if len(self.__reservations[username]) == 0:
return "no info"
for reservation in self.__reservations[username]:
info += reservation.getInfoStr() + "\n"
info.rstrip('\n')
return info
def inUseBy(self, username):
devices = []
if (not self.__reservations.has_key(username)):
return devices
for reservation in self.__reservations[username]:
for reservedDevice in reservation.getDevices():
devices.append(reservedDevice)
return devices
def getFreeDevices(self):
allDevices = self.__henManager.getNodes("computer").keys()
allDevices.extend(self.__henManager.getNodes("virtualcomputer").keys())
freeDevices = []
reservedDevices = self.__getReservedDevices()
for device in allDevices:
if (device not in reservedDevices):
freeDevices.append(device)
return freeDevices
def cleanExpired(self):
currentDate = self.__getCurrentDate() #datetime.date.today()
for username in self.__reservations.keys():
userReservations = self.__reservations[username]
for userReservation in userReservations:
if (userReservation.getEndDate() < currentDate):
self.release(username, userReservation.getReservationID())
dirListing = self.__listDirectory(
userReservation.getDevices())
self.__removeNotifications(
userReservation.getReservationID())
self.__clearSymLinks(userReservation.getDevices())
self.__poweroff(userReservation.getDevices())
self.__sendEmailExpired(userReservation, dirListing)
log.info("cleaned expired reservation: " +
str(userReservation))
return 0
def getOwners(self, devices):
results = []
for device in devices:
owner = self.__getOwner(device)
results.append((device, owner))
return results
def __parseNotifications(self):
(result, xmldoc) = self.__parser.openDB(self.__notificationsFilename)
if (result < 0):
log.info("error while opening notifications database!")
return -1
elif (result == 1):
log.info("warning, no notifications database file found")
return 1
else:
(result,
self.__notifications) = self.__parser.parseNotificationsDB(xmldoc)
# ignore -1, this means that there are no 'notifications' tags
if (result < 0 and result != -1):
log.info("error while parsing notifications database!")
return -1
return 0
def __removeNotifications(self, reservationID):
if (self.__parseNotifications() != 0):
return
try:
del self.__notifications[int(reservationID)]
except:
log.info("warning: no notifications to delete for id=" +
str(reservationID))
self.__parser.writeNotificationsDBToDisk(self.__notifications)
def __getCurrentDate(self):
if not self.__debug:
return datetime.date.today()
else:
return self.mytime
def __getMaxWeeks(self, username, devices):
if (not self.__rights.has_key(username) or len(devices) == 0):
return self.__maxNumWeeks
minRightWeeks = 99999
foundDevs = []
rights = self.__rights[username]
for device in devices:
for right in rights:
if (device in right.getDevices()):
foundDevs.append(device)
if (right.getMaxWeeks() < minRightWeeks):
minRightWeeks = right.getMaxWeeks()
if (set(devices) == set(foundDevs)):
return minRightWeeks
return self.__maxNumWeeks
def __listDirectory(self, devices):
dirListing = ""
for device in devices:
dirListing += str(device) + " :\n"
dirListing += commands.getoutput('find ' + self.__symlinksRoot +
device + ' -print ')
dirListing += "\n"
return dirListing
def __clearSymLinks(self, devices):
# temp suspend clearing links , adam 12/08/2008
return
for device in devices:
if not self.__debug:
os.system("rm " + self.__symlinksRoot + device + "/*")
else:
print "would run : rm " + self.__symlinksRoot + device + "/*"
def __poweroff(self, devices):
# temp suspend poweroff , adam 12/08/2008
return
for device in devices:
if not self.__debug:
self.__henManager.powerSilent(device, "poweroff")
else:
print "would turn off " + str(device)
def __sendEmailExpired(self, reservation, dirListing=None):
subject = "Your reservation (id = " + str(
reservation.getReservationID()) + ") has expired"
body = "The reservation you had made has expired and has been removed from the system. " + \
"If you still wish to use the devices you had reserved you will have to create a new " + \
"reservation by logging on to hen.cs.ucl.ac.uk and running the command 'hm reservation'."
if dirListing != None:
body += "The directory listings for your machines were :\n"
body += dirListing
if not self.__debug:
smtpClient = SMTPClient(self.__smtpServerName)
smtpClient.sendEmail(reservation.getEmail(), self.__daemonEMail,
subject, body)
smtpClient.close()
else:
print "would send email."
print "to :" + str(reservation.getEmail())
print "subject :" + subject
print "via :" + self.__smtpServerName
print "body :" + body
def __findHighestID(self):
highestID = 0
for username in self.__reservations.keys():
userReservations = self.__reservations[username]
for userReservation in userReservations:
if (int(userReservation.getReservationID()) > highestID):
highestID = int(userReservation.getReservationID())
return highestID
def __getNextID(self):
theID = self.__nextID
self.__nextID += 1
return theID
def __isDeviceInUse(self, device):
return (self.__getOwner(device) != None)
def __getOwner(self, device):
for username in self.__reservations.keys():
userReservations = self.__reservations[username]
for userReservation in userReservations:
for reservedDevice in userReservation.getDevices():
if (reservedDevice == device):
return username
return None
def __getReservedDevices(self):
reservedDevices = []
for username in self.__reservations.keys():
userReservations = self.__reservations[username]
for userReservation in userReservations:
for device in userReservation.getDevices():
reservedDevices.append(device)
return reservedDevices
def __getReservedDevicesByID(self, reservationID):
for username in self.__reservations.keys():
userReservations = self.__reservations[username]
for userReservation in userReservations:
if (userReservation.getReservationID() == reservationID):
return userReservation.getDevices()
return []
def __printReservations(self):
for username in self.__reservations.keys():
userReservations = self.__reservations[username]
email = userReservations[0].getEmail()
log.info("\nuser: "******"(" + str(email) + ")" + \
"\n---------------------------------")
for userReservation in userReservations:
log.info(userReservation.getDateDevStr())
def __printRights(self):
for username in self.__rights.keys():
userRights = self.__rights[username]
email = userRights[0].getEmail()
log.info("\nuser: "******"(" + str(email) + ")" + \
"\n---------------------------------")
for userRight in userRights:
log.info(userRight.getDebugStr())
def __convertDateToString(self, date):
return str(date.day) + "/" + str(date.month) + "/" + str(date.year)
# First create a list containing the mac addresses of all the running interfaces
macAddresses = []
macAddressMatcher = re.compile('(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}')
lines = commands.getstatusoutput("ifconfig")[1].splitlines()
for line in lines:
matchObject = macAddressMatcher.search(line)
if (matchObject):
macAddresses.append(
line[matchObject.start():matchObject.end()].upper())
# Now match the created list against all of the management mac addresses in the testbed's database
# for computer nodes
manager = HenManager()
manager.initLogging()
nodes = manager.getNodes("computer", "all")
nodeName = None
for node in nodes.values():
for interface in node.getInterfaces("management"):
for macAddress in macAddresses:
if (macAddress == interface.getMAC().upper()):
nodeName = node.getNodeID()
if nodeName == None:
nodes = manager.getNodes("virtualcomputer", "all")
for node in nodes.values():
for interface in node.getInterfaces("management"):
for macAddress in macAddresses:
if (macAddress == interface.getMAC().upper()):
nodeName = node.getNodeID()
print nodeName
from henmanager import HenManager
# First create a list containing the mac addresses of all the running interfaces
macAddresses = []
macAddressMatcher = re.compile("(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}")
lines = commands.getstatusoutput("ifconfig")[1].splitlines()
for line in lines:
matchObject = macAddressMatcher.search(line)
if matchObject:
macAddresses.append(line[matchObject.start() : matchObject.end()].upper())
# Now match the created list against all of the management mac addresses in the testbed's database
# for computer nodes
manager = HenManager()
manager.initLogging()
nodes = manager.getNodes("computer", "all")
nodeName = None
for node in nodes.values():
for interface in node.getInterfaces("management"):
for macAddress in macAddresses:
if macAddress == interface.getMAC().upper():
nodeName = node.getNodeID()
if nodeName == None:
nodes = manager.getNodes("virtualcomputer", "all")
for node in nodes.values():
for interface in node.getInterfaces("management"):
for macAddress in macAddresses:
if macAddress == interface.getMAC().upper():
nodeName = node.getNodeID()
print nodeName
#!/usr/local/bin/python
from henmanager import HenManager
import time
import resource
import gc
manager = HenManager()
manager.initLogging()
switches = manager.getNodes("switch", "all")
switch = None
#switch_node = None
for sw in switches.values():
if sw.getNodeID() == "switch5":
#switch_node = sw
switch = sw.getInstance()
while True:
sn = switch.getSensorReadings()
print sn,
print resource.getrusage(resource.RUSAGE_SELF)[2]
try:
pnodeid = switch.getPowerNodeID()
if (pnodeid == "None" or pnodeid == "none"):
pass
(st,msg) = manager.powerSilent(switch.getNodeID(), "status", \
pnodeid)
print "power status[%S], message[%s]" % (st, msg)
except:
for i in temp:
sys.path.append(i)
#os.environ["PATH"] += ":/usr/local/bin:/usr/bin"
from henmanager import HenManager
###########################################################################################
# Main execution
###########################################################################################
print "Content-Type: text/xml"
print ""
print ""
print "<row>"
manager = HenManager("/usr/local/hen/etc/configs/config")
racks = manager.getInfrastructures("rack", "all")
nodes = manager.getNodes("all", "all")
for key in racks.keys():
r = manager.getInfrastructures("rack")[key]
s = '<rack id="' + str(r.getID()) + \
'" rowposition="' + str(r.getRowPosition()) + \
'" height="' + str(r.getPhysicalSize().getNumberUnits())
if (r.getPhysicalSize().getWidth() == "75"):
s += '" width="wide" >'
elif (r.getPhysicalSize().getWidth() == "60"):
s += '" width="narrow" >'
else:
s += '" width="wide" >'
print s
class ReservationDBManager:
def __init__(self, filename, rightsFilename, notificationsFilename, dbsRoot, maxNumWeeks=2,debug=False):
self.__daemonEMail = "*****@*****.**"
self.__filename = filename
self.__rightsFilename = rightsFilename
self.__notificationsFilename = notificationsFilename
self.__notifications = {}
self.__dbsRoot = dbsRoot
self.__maxNumWeeks = maxNumWeeks
self.__reservations = {}
self.__rights = {}
self.__nextID = 0
self.__xmldoc = None
self.__rightsXmldoc = None
self.__henManager = HenManager()
self.__symlinksRoot = "/export/machines/"
self.__smtpServerName = "smtp.cs.ucl.ac.uk"
self.__parser = ReservationDBParser(filename, rightsFilename, notificationsFilename, self.__dbsRoot)
self.__notifier = None
self.__debug = debug
self.mytime = datetime.date.today()
# Start the early notification thread
self.__notifier = ReservationExpiryNotifier(self.__daemonEMail, \
self.__smtpServerName, \
self.__filename, \
self.__rightsFilename, \
self.__notificationsFilename, \
self.__dbsRoot,
self.__debug)
if not self.__debug:
self.__notifier.start()
# used to test email sending
def getNotifier(self):
return self.__notifier
def reloadHenDB(self):
self.__henManager = HenManager()
return 0
def startDB(self):
# First parse reservations database
(result, self.__xmldoc) = self.__parser.openDB(self.__filename)
if (result < 0):
log.info("error while opening database!")
return -1
elif (result == 1):
log.info("warning: no database file found (one will be created when a reservation is made)")
self.__nextID = 1
else:
(result, self.__reservations) = self.__parser.parseDB(self.__xmldoc)
# ignore -1, this means that there are no 'reservations' tags
if (result < 0 and result != -1):
log.info("error while parsing database!")
return -1
else:
self.__nextID = self.__findHighestID() + 1
self.cleanExpired()
# Now parse reservation rights database
(result, self.__rightsXmldoc) = self.__parser.openDB(self.__rightsFilename)
if (result < 0 or result == 1):
log.info("error while opening reservation rights database!")
return -1
(result, self.__rights) = self.__parser.parseRightsDB(self.__rightsXmldoc)
if (result < 0):
log.info("error while parsing rights database!")
return -1
return 0
def release(self, username, reservationID):
if (not self.__reservations.has_key(username)):
return "unknown user"
released = False
reservationsBackup = self.__reservations
userReservations = self.__reservations[username]
for userReservation in userReservations:
if (str(userReservation.getReservationID()) == str(reservationID)):
userReservations.remove(userReservation)
self.__removeNotifications(userReservation.getReservationID())
released = True
break
if (not released):
return "reservation id not found"
if (self.__parser.writeDBToDisk(self.__reservations) < 0):
self.__reservations = reservationsBackup
return "error while writing to database, release failed"
self.__nextID = self.__findHighestID() + 1
return "reservation released"
def releaseDevices(self, username, devices):
if (not self.__reservations.has_key(username)):
return "unknown user"
reservationsBackup = self.__reservations
released = []
userReservations = self.__reservations[username]
for userReservation in userReservations:
for device in userReservation.getDevices():
if (device in devices):
userReservation.getDevices().remove(device)
released.append(device)
# Remove any reservations with no devices in them
for x in range(len(userReservations) - 1, -1, -1):
if (len(userReservations[x].getDevices()) == 0):
del userReservations[x]
if (len(released) == 0):
return "none of the devices were found in your reservations"
if (self.__parser.writeDBToDisk(self.__reservations) < 0):
self.__reservations = reservationsBackup
return "error while writing to database, release failed"
self.__nextID = self.__findHighestID() + 1
string = "released: "
for device in released:
string += str(device) + ", "
string = string[:len(string) - 2]
return string
def renew(self, username, reservationID, endDate):
# Check for expired reservations first and release them
self.cleanExpired()
currentDate = self.__getCurrentDate() #datetime.date.today()
if (endDate <= currentDate):
return "renewal failed: supplied end date is in the past"
maxDate = currentDate + timedelta(weeks=self.__getMaxWeeks(username, self.__getReservedDevicesByID(reservationID)))
trimmedDate = False
if (endDate > maxDate):
endDate = maxDate
trimmedDate = True
if (self.__reservations.has_key(username)):
for userReservation in self.__reservations[username]:
if (int(userReservation.getReservationID()) == int(reservationID)):
oldDate = userReservation.getEndDate()
userReservation.setEndDate(endDate)
self.__removeNotifications(userReservation.getReservationID())
if (self.__parser.writeDBToDisk(self.__reservations) < 0):
userReservation.setEndDate(oldDate)
return "error while writing to database, renew failed"
message = "reservation renewed (new end date=" + str(self.__convertDateToString(endDate)) + ")"
if (trimmedDate):
message += "\nnote: the desired date was ignored because the max allocation period is " + \
str(self.__maxNumWeeks) + " week(s)"
return message
return "no reservation found for id=" + str(reservationID) + " and username="******"add"):
for device in devices:
if (self.__isDeviceInUse(device)):
return "reservation failed: " + str(device) + " already reserved"
if (self.__reservations.has_key(username)):
for userReservation in self.__reservations[username]:
if (int(userReservation.getReservationID()) == int(reservationID)):
oldDevices = userReservation.getEndDate()
oldEmail = userReservation.getEmail()
if (opType == "add"):
userReservation.appendDevices(devices)
elif (opType == "remove"):
userReservation.removeDevices(devices)
if (email != None):
userReservation.setEmail(email)
if (self.__parser.writeDBToDisk(self.__reservations) < 0):
userReservation.setDevices(oldDevices)
if (email != None):
userReservation.setEmail(oldEmail)
return "error while writing to database, update failed"
message = "reservation updated"
return message
return "no reservation found for id=" + str(reservationID) + " and username="******"reservation failed: supplied end date is in the past"
maxDate = currentDate + timedelta(weeks=self.__getMaxWeeks(username, devices))
trimmedDate = False
if (endDate > maxDate):
endDate = maxDate
trimmedDate = True
# First make sure that the devices are free
for device in devices:
if (self.__isDeviceInUse(device)):
return "reservation failed: " + str(device) + " already reserved"
# Add to in-memory db
reservationID = self.__getNextID()
if (not self.__reservations.has_key(username)):
self.__reservations[username] = []
entry = ReservationEntry(username, email, devices, endDate, reservationID)
self.__reservations[username].append(entry)
# Write-out to on-disk db
if (self.__parser.writeDBToDisk(self.__reservations) < 0):
self.__reservations[username].remove(entry)
return "reservation failed: could not write database to disk"
message = "reservation succeeded (id = " + str(reservationID) + ", " + \
"end date=" + str(self.__convertDateToString(endDate)) + ")"
if (trimmedDate):
message += "\nnote: the desired date was ignored because the max allocation period is " + \
str(self.__maxNumWeeks) + " week(s)"
return message
def getReservationsInfo(self, username):
if username == "all":
info = ""
for name in self.__reservations:
for reservation in self.__reservations[name]:
info += reservation.getInfoStr() +" "+str(name)+"\n"
return info
if (not self.__reservations.has_key(username)):
return "no info"
info = ""
if len(self.__reservations[username]) == 0:
return "no info"
for reservation in self.__reservations[username]:
info += reservation.getInfoStr() + "\n"
info.rstrip('\n')
return info
def inUseBy(self, username):
devices = []
if (not self.__reservations.has_key(username)):
return devices
for reservation in self.__reservations[username]:
for reservedDevice in reservation.getDevices():
devices.append(reservedDevice)
return devices
def getFreeDevices(self):
allDevices = self.__henManager.getNodes("computer").keys()
allDevices.extend(self.__henManager.getNodes("virtualcomputer").keys())
freeDevices = []
reservedDevices = self.__getReservedDevices()
for device in allDevices:
if (device not in reservedDevices):
freeDevices.append(device)
return freeDevices
def cleanExpired(self):
currentDate = self.__getCurrentDate() #datetime.date.today()
for username in self.__reservations.keys():
userReservations = self.__reservations[username]
for userReservation in userReservations:
if (userReservation.getEndDate() < currentDate):
self.release(username, userReservation.getReservationID())
dirListing = self.__listDirectory(userReservation.getDevices())
self.__removeNotifications(userReservation.getReservationID())
self.__clearSymLinks(userReservation.getDevices())
self.__poweroff(userReservation.getDevices())
self.__sendEmailExpired(userReservation,dirListing)
log.info("cleaned expired reservation: " + str(userReservation))
return 0
def getOwners(self, devices):
results = []
for device in devices:
owner = self.__getOwner(device)
results.append((device, owner))
return results
def __parseNotifications(self):
(result, xmldoc) = self.__parser.openDB(self.__notificationsFilename)
if (result < 0):
log.info("error while opening notifications database!")
return -1
elif (result == 1):
log.info("warning, no notifications database file found")
return 1
else:
(result, self.__notifications) = self.__parser.parseNotificationsDB(xmldoc)
# ignore -1, this means that there are no 'notifications' tags
if (result < 0 and result != -1):
log.info("error while parsing notifications database!")
return -1
return 0
def __removeNotifications(self, reservationID):
if (self.__parseNotifications() != 0):
return
try:
del self.__notifications[int(reservationID)]
except:
log.info("warning: no notifications to delete for id=" + str(reservationID))
self.__parser.writeNotificationsDBToDisk(self.__notifications)
def __getCurrentDate(self):
if not self.__debug:
return datetime.date.today()
else :
return self.mytime
def __getMaxWeeks(self, username, devices):
if (not self.__rights.has_key(username) or len(devices) == 0):
return self.__maxNumWeeks
minRightWeeks = 99999
foundDevs = []
rights = self.__rights[username]
for device in devices:
for right in rights:
if (device in right.getDevices()):
foundDevs.append(device)
if (right.getMaxWeeks() < minRightWeeks):
minRightWeeks = right.getMaxWeeks()
if (set(devices) == set(foundDevs)):
return minRightWeeks
return self.__maxNumWeeks
def __listDirectory(self, devices):
dirListing = ""
for device in devices:
dirListing += str(device)+" :\n"
dirListing += commands.getoutput('find ' + self.__symlinksRoot + device + ' -print ')
dirListing += "\n"
return dirListing
def __clearSymLinks(self, devices):
# temp suspend clearing links , adam 12/08/2008
return
for device in devices:
if not self.__debug:
os.system("rm " + self.__symlinksRoot + device + "/*")
else:
print "would run : rm " + self.__symlinksRoot + device + "/*"
def __poweroff(self, devices):
# temp suspend poweroff , adam 12/08/2008
return
for device in devices:
if not self.__debug:
self.__henManager.powerSilent(device, "poweroff")
else:
print "would turn off "+str(device)
def __sendEmailExpired(self, reservation,dirListing=None):
subject = "Your reservation (id = " + str(reservation.getReservationID()) + ") has expired"
body = "The reservation you had made has expired and has been removed from the system. " + \
"If you still wish to use the devices you had reserved you will have to create a new " + \
"reservation by logging on to hen.cs.ucl.ac.uk and running the command 'hm reservation'."
if dirListing != None:
body += "The directory listings for your machines were :\n"
body += dirListing
if not self.__debug:
smtpClient = SMTPClient(self.__smtpServerName)
smtpClient.sendEmail(reservation.getEmail(), self.__daemonEMail, subject, body)
smtpClient.close()
else:
print "would send email."
print "to :"+str(reservation.getEmail())
print "subject :"+subject
print "via :"+self.__smtpServerName
print "body :"+body
def __findHighestID(self):
highestID = 0
for username in self.__reservations.keys():
userReservations = self.__reservations[username]
for userReservation in userReservations:
if (int(userReservation.getReservationID()) > highestID):
highestID = int(userReservation.getReservationID())
return highestID
def __getNextID(self):
theID = self.__nextID
self.__nextID += 1
return theID
def __isDeviceInUse(self, device):
return (self.__getOwner(device) != None)
def __getOwner(self, device):
for username in self.__reservations.keys():
userReservations = self.__reservations[username]
for userReservation in userReservations:
for reservedDevice in userReservation.getDevices():
if (reservedDevice == device):
return username
return None
def __getReservedDevices(self):
reservedDevices = []
for username in self.__reservations.keys():
userReservations = self.__reservations[username]
for userReservation in userReservations:
for device in userReservation.getDevices():
reservedDevices.append(device)
return reservedDevices
def __getReservedDevicesByID(self, reservationID):
for username in self.__reservations.keys():
userReservations = self.__reservations[username]
for userReservation in userReservations:
if (userReservation.getReservationID() == reservationID):
return userReservation.getDevices()
return []
def __printReservations(self):
for username in self.__reservations.keys():
userReservations = self.__reservations[username]
email = userReservations[0].getEmail()
log.info("\nuser: "******"(" + str(email) + ")" + \
"\n---------------------------------")
for userReservation in userReservations:
log.info(userReservation.getDateDevStr())
def __printRights(self):
for username in self.__rights.keys():
userRights = self.__rights[username]
email = userRights[0].getEmail()
log.info("\nuser: "******"(" + str(email) + ")" + \
"\n---------------------------------")
for userRight in userRights:
log.info(userRight.getDebugStr())
def __convertDateToString(self, date):
return str(date.day) + "/" + str(date.month) + "/" + str(date.year)
class HardwareDetectionRunner:
__prot = None
__host = None
__port = None
__hm = None
__interfaceNames = None
__data = None
def __init__(self, host, port):
self.__prot = auxiliary.protocol.Protocol(None)
self.__host = host
self.__port = port
self.__data = ""
self.__hm = HenManager()
def run(self):
"""\brief Runs all the necessary detection methods."""
print "Running hardware detection:"
print "\tRetrieving experimental interface names..."
self.getExperimentalInterfacesNames()
print "\tPolling interfaces..."
self.pollInterfaces()
# Sometimes mii-tool will report no link if this sleep time is not here
print "Waiting " + str(AUTONEGOTIATION_WAIT_TIME) + \
" seconds for autonegotiation to finish",
self.waitForAutonegotiation()
print "Retrieving number of processors..."
self.getNumberProcessors()
print "Retrieving number of cores..."
self.getNumberCores()
print "Retrieving no-carrier-sense MACs..."
self.getNoCarrierMACs()
print "Retrieving output from lshw..."
self.getLSHWOutput()
print "Polling interfaces once to seed fdb"
self.pollInterfaces()
print "Sending results to AutodetectDaemon... "
self.sendData()
print "Polling interfaces continually..."
while 1:
self.pollInterfaces()
time.sleep(POLL_INTERFACE_INTERVAL)
def waitForAutonegotiation(self):
"""\brief Prints a dot per second whilst waiting for the number of
seconds defined by AUTONEGOTIATION_WAIT_TIME
"""
ticks = AUTONEGOTIATION_WAIT_TIME
while ticks > 0:
print '.',
ticks -= 1
time.sleep(1)
def pollInterfaces(self):
for interfaceName in self.__interfaceNames:
cmd = "/sbin/ifconfig " + interfaceName + " up"
os.system(cmd)
cmd = "etherwake -i " + interfaceName + " 00:11:22:33:44:55"
os.system(cmd)
def getExperimentalInterfacesNames(self):
# First create a list containing the mac addresses of all the interfaces
macAddresses = []
macAddressMatcher = re.compile('(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}')
lines = commands.getstatusoutput("ifconfig -a")[1].splitlines()
for line in lines:
matchObject = macAddressMatcher.search(line)
if (matchObject):
macAddresses.append(\
line[matchObject.start():matchObject.end()].upper())
# Find which of these is the management interface so we can filter it out
nodes = self.__hm.getNodes("computer", "all")
for node in nodes.values():
managementMACAddress = \
node.getInterfaces("management")[0].getMAC().upper()
if (managementMACAddress in macAddresses):
break
self.__interfaceNames = []
for macAddress in macAddresses:
if (macAddress != managementMACAddress):
# We need to convert the mac addresses to interface names
self.__interfaceNames.append(commands.getstatusoutput(\
"ifconfig -a | grep " + macAddress + \
" | awk '{print $1}'")[1])
def getNumberProcessors(self):
data = commands.getstatusoutput(\
"cat /proc/cpuinfo | grep 'physical id'")[1]
data = data.split("\n")
uniqueIDs = []
for line in data:
processorID = line[line.find(":") + 1:]
if (processorID not in uniqueIDs):
uniqueIDs.append(processorID)
self.__data += "<numbercpus>%s</numbercpus>" % str(len(uniqueIDs))
def getNumberCores(self):
data = commands.getstatusoutput(\
"cat /proc/cpuinfo | grep 'cpu cores'")[1]
cores = 1
try:
data = data.split("\n")[0]
cores = int(data[data.find(":") + 1:])
except:
pass
self.__data += "<numbercorespercpu>%s</numbercorespercpu>" % str(cores)
def getNoCarrierMACs(self):
self.__data += "<nocarriermacs>"
data = commands.getstatusoutput("mii-tool")[1]
data = data.split("\n")
counter = 0
for line in data:
if (line.find("no link") != -1):
ifaceName = line[:line.find(":")]
data = commands.getstatusoutput(\
"ifconfig " + ifaceName)[1].split("\n")[0]
macAddress = data[data.find("HWaddr") + 7:].strip()
self.__data += str(macAddress).upper()
counter += 1
if (counter != len(noCarrierMACs)):
self.__data += ","
self.__data += "</nocarriermacs>"
def getLSHWOutput(self):
self.__data += commands.getstatusoutput("/usr/sbin/lshw -xml")[1]
def sendData(self):
"""\brief Connects to the autodetectdaemon and sends the data created
by the detection code.
"""
self.__prot.open(self.__host, self.__port)
self.__prot.sendRequest("receive_detectiondata", \
self.__data, \
self.responseHandler)
self.__prot.readAndProcess()
def responseHandler(self,code,seq,size,payload):
"""\brief Handles the response from the autodetectdaemon. We can add
code here for re-sending the data, if need be.
"""
if code == 200:
print "Data successfully received by AutodetectDaemon"
self.__prot.close()
else:
print "ERROR: Received code[%s] from daemon. Payload = %s" % \
(str(code), str(payload))
p = auxiliary.protocol.Protocol(None)
#read connection info from user
#host = raw_input("host name (localhost):")
#if (host==""):
# host = "localhost"
#try:
# port = int(raw_input("port (1105):"))
#except:
## port = 1105
host = DaemonPorts().powerDaemonHost
port = DaemonPorts().powerDaemonPort
print "connecting to " + host + "port " + str(port)
p.open(host, port)
#send state!
payload = "10," + pickle.dumps(hm.getNodes("all"))
#p.sendRequest("set_config",payload,state_check)
#p.readAndProcess()
p.doSynchronousCall("set_config", payload)
#read smth from the user
while True:
method = raw_input("method:")
payload = raw_input("payload:")
#p.sendRequest(method,payload,handler)
#p.readAndProcess()
print p.doSynchronousCall(method, payload)
class ComputerControl(Daemon):
"""\brief Implements basic computer daemon functionality.
"""
__version = "Computer Daemon v0.1 (simple)"
__henManager = None
def __init__(self):
Daemon.__init__(self)
self.__henManager = HenManager()
# Allow specialized instance dictionary to be created in hm
# self.__henManager.createNodeInstances()
self.__registerMethods()
self.__computerID = self.__getComputerID()
self.__computerInfo = self.__henManager.getNodes("computer")[self.__computerID]
self.__ifaceIDtoNameMappings = self.__getIfaceMappings()
def getComputerManagementIP(self):
# Get the management ip address so that we can bind to it.
interfaces = self.__computerInfo.getInterfaces("management")
try:
return interfaces[0].getIP()
except:
return "0.0.0.0"
def __getComputerID(self):
# Prints the name of the node that the script is run from. To do so it matches the mac addresses of
# all running interfaces against the mac addresses in the testbed's database. Prints None if no match is found
# First create a list containing the mac addresses of all the running interfaces
macAddresses = []
macAddressMatcher = re.compile('(?:[0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}')
lines = commands.getstatusoutput("ifconfig")[1].splitlines()
for line in lines:
matchObject = macAddressMatcher.search(line)
if (matchObject):
macAddresses.append(line[matchObject.start():matchObject.end()].upper())
# Now match the created list against all of the management mac addresses in the testbed's database
# for computer nodes
self.__henManager.initLogging()
nodes = self.__henManager.getNodes("computer","all")
nodeName = None
for node in nodes.values():
for interface in node.getInterfaces("management"):
for macAddress in macAddresses:
if (macAddress == interface.getMAC().upper()):
nodeName = node.getNodeID()
if nodeName == None:
nodes = self.__henManager.getNodes("virtualcomputer","all")
for node in nodes.values():
for interface in node.getInterfaces("management"):
for macAddress in macAddresses:
if (macAddress == interface.getMAC().upper()):
nodeName = node.getNodeID()
return nodeName
def __getIfaceMappings(self):
mappings = {}
# Supports only Linux for now
interfaces = self.__computerInfo.getInterfaces("experimental")
ifacesInfo = commands.getstatusoutput("ifconfig -a | grep HWaddr")[1].splitlines()
for interface in interfaces:
for infoLine in ifacesInfo:
if (infoLine.find(interface.getMAC()) != -1):
mappings[interface.getInterfaceID()] = infoLine[:infoLine.find(" ")]
return mappings
def __registerMethods(self):
self.registerMethodHandler("get_computer_id", self.getComputerID)
self.registerMethodHandler("autodetect", self.autodetect)
self.registerMethodHandler("execute_command", self.executeCommand)
self.registerMethodHandler("gcc_compile", self.gccCompile)
self.registerMethodHandler("cat", self.cat)
self.registerMethodHandler("make", self.make)
self.registerMethodHandler("mkdir", self.mkdir)
self.registerMethodHandler("untar", self.untar)
self.registerMethodHandler("add_route", self.addRoute)
self.registerMethodHandler("delete_route", self.delRoute)
self.registerMethodHandler("config_iface", self.configIface)
self.registerMethodHandler("click-align", self.clickAlign)
self.registerMethodHandler("click-install", self.clickInstall)
self.registerMethodHandler("click-uninstall", self.clickUninstall)
self.registerMethodHandler("load_module", self.loadModule)
self.registerMethodHandler("unload_module", self.unloadModule)
self.registerMethodHandler("linux_forwarding_on", self.linuxForwardingOn)
self.registerMethodHandler("linux_forwarding_off", self.linuxForwardingOff)
def __sendReply(self,prot,code,seq,payload):
if (code == 0):
code = 200
else:
code = 422 # returnCodes[422] = "error executing command"
prot.sendReply(code, seq, payload)
def autodetect(self,prot,seq,ln,payload):
pass
def getComputerID(self,prot,seq,ln,payload):
self.__sendReply(prot,"0",seq,self.__computerID)
def executeCommand(self,prot,seq,ln,payload):
(code, payload) = commands.getstatusoutput(payload)
self.__sendReply(prot,code,seq,payload)
def gccCompile(self,prot,seq,ln,payload):
(workDir, filename) = pickle.loads(payload)
name = filename[:filename.find(".")]
(code, payload) = commands.getstatusoutput("cd " + worDir + " ; g++ -o " + name + " " + filename)
self.__sendReply(prot,code,seq,payload)
def cat(self,prot,seq,ln,payload):
#print "got cat command"
payload = pickle.loads(payload)[0]
(code, payload) = commands.getstatusoutput("cat " + str(payload))
self.__sendReply(prot,code,seq,payload)
def make(self,prot,seq,ln,payload):
(workDir, makeTarget) = pickle.loads(payload)
(code, payload) = commands.getstatusoutput("cd " + workDir + " ; make -f " + makeTarget)
self.__sendReply(prot,code,seq,payload)
def mkdir(self,prot,seq,ln,payload):
code = os.mkdir(payload)
self.__sendReply(prot,code,seq,"")
def untar(self,prot,seq,ln,payload):
(tarPath, targetDir) = pickle.loads(payload)
(code, payload) = commands.getstatusoutput("tar -xf " + path + " -C " + targetDir)
self.__sendReply(prot,code,seq,payload)
def addRoute(self,prot,seq,ln,payload):
(network, netmask, gateway, interface) = pickle.loads(payload)
(code, payload) = commands.getstatusoutput("route add -net " + network + \
" netmask " + netmask + \
" gw " + gateway \
+ " dev " + interface)
self.__sendReply(prot,code,seq,payload)
def delRoute(self,prot,seq,ln,payload):
(network, netmask) = pickle.loads(payload)
(code, payload) = commands.getstatusoutput("route del -net " + network + " netmask " + netmask)
self.__sendReply(prot,code,seq,payload)
def configIface(self,prot,seq,ln,payload):
(interfaceID, address, mask, status) = pickle.loads(payload)
try:
cmd = "ifconfig " + self.__ifaceIDtoNameMappings[interfaceID] + " "
except KeyError:
log.error("Key error "+str( self.__ifaceIDtoNameMappings))
(code, payload) = (400, "Key error for interface")
self.__sendReply(prot,code,seq,payload)
return
if (status == "on"):
cmd += address + " netmask " + mask + " up"
else:
cmd += "down"
(code, payload) = commands.getstatusoutput(cmd)
self.__sendReply(prot,code,seq,payload)
def clickAlign(self,prot,seq,ln,payload):
(clickAlignPath, configFile) = pickle.loads(payload)
basePath = configFile[:configFile.rfind("/")]
filename = configFile[configFile.rfind("/") + 1: configFile.find(".")]
newPathToFile = basePath + "/" + filename + "-aligned.click'"
(code, payload) = commands.getstatusoutput(clickAlignPath + " " + configFile + " > " + newPathToFile)
self.__sendReply(prot,code,seq,payload)
def clickInstall(self,prot,seq,ln,payload):
(clickInstallPath, configFile, numberThreads) = pickle.loads(payload)
cmd = click-installPath + " "
if (int(numberThreads) != 0):
cmd += "--threads=" + numberThreads + " "
cmd += configFile
(code, payload) = commands.getstatusoutput(cmd)
self.__sendReply(prot,code,seq,payload)
def clickUninstall(self,prot,seq,ln,payload):
(code, payload) = commands.getstatusoutput(payload)
self.__sendReply(prot,code,seq,payload)
def loadModule(self,prot,seq,ln,payload):
(code, payload) = commands.getstatusoutput("insmod " + payload)
self.__sendReply(prot,code,seq,payload)
def unloadModule(self,prot,seq,ln,payload):
(code, payload) = commands.getstatusoutput("rmmod " + payload)
self.__sendReply(prot,code,seq,payload)
def linuxForwardingOn(self,prot,seq,ln,payload):
(code, payload) = commands.getstatusoutput("echo '1' \> /proc/sys/net/ipv4/ip_forward")
self.__sendReply(prot,code,seq,payload)
def linuxForwardingOff(self,prot,seq,ln,payload):
(code, payload) = commands.getstatusoutput("echo '0' \> /proc/sys/net/ipv4/ip_forward")
self.__sendReply(prot,code,seq,payload)
def stopDaemon(self,prot,seq,ln,payload):
"""\brief Stops the daemon and all threads
This method will first stop any more incoming queries, then wait for
any update tasks to complete, before stopping itself.
"""
log.info("stopDaemon called.")
prot.sendReply(200, seq, "Accepted stop request.")
log.debug("Sending stopDaemon() response")
self.acceptConnections(False)
log.info("Stopping ComputerDaemon (self)")
self.stop()
#!/usr/bin/env python
import os, sys, commands
from henmanager import HenManager
manager = HenManager()
nodes = manager.getNodes("computer")
user=""
usage = "usage: reservations.py [computerid] [computerid]\n"
usage += "usage: reservations.py all\n"
usage += "usage: reservations.py model [dell2950|dell1950|dell1850|sunx4100|sunv20z|delloptiplex]\n"
usage += "usage: reservations.py user [username]"
if (len(sys.argv) < 2):
print usage
os._exit(0)
if (sys.argv[1] == "model"):
if (len(sys.argv) != 3):
print usage
os._exit(0)
elif (sys.argv[2] == "dell2950"):
beginID="computer81"
endID="computer100"
elif (sys.argv[2] == "dell1950"):
beginID="computer56"
endID="computer80"
elif (sys.argv[2] == "dell1850"):
beginID="computer21"
endID="computer25"
