def nodeIsOn(self, node):
"""\brief Checks if given node is on.
\param nodeInstance - Instance of node to check
\return result - 0 = off, 1 = on, -1 = unknown/unsupported
XXX TODO: Use powerd for query, removing dependance on having a ref to
henmanager
XXX Small leaking here, as powerSilent creates node instances...
"""
self.__powerStatusCallbackEvent.clear()
p = Protocol(None)
if DaemonStatus().powerDaemonIsOnline(5):
p.open(DaemonLocations.monitorDaemon[0], \
DaemonLocations.monitorDaemon[1])
p.sendRequest("get_power_status", node.getNodeID(), \
self.powerStatusHandler)
p.readAndProcess()
self.__powerStatusCallbackEvent.wait(POWER_STATUS_TIMEOUT)
p.close()
try:
pnodeid = node.getPowerNodeID()
if (pnodeid == "None" or pnodeid == "none"):
return -1
if self.__powerResults:
(st, msg) = (0, self.__powerResults)
else:
(st,msg) = self.__hen_manager.powerSilent(node.getNodeID(), \
"status", pnodeid)
if (st == 0 and msg == "on"):
return 1
if (st == 0 and msg == "off"):
return 0
except Exception, e:
log.debug("nodeIsOn Exception: %s" % str(e))
def __init__(self, useSSL=True):
Daemon.__init__(self, useSSL)
self.__MIN_ID = 100000
self.__MAX_ID = 100000000
self.__SESSION_TIMEOUT_HOURS = 48
self.__loggedInUsers = {}
self.__reverseLoggedInUsers = {}
self.__userProtocols = {}
self.__systemProtocol = Protocol(None)
self.__controlProtocol = Protocol(None)
try:
self.__systemProtocol.open(DaemonLocations.systemDaemon[0], DaemonLocations.systemDaemon[1])
except:
print "warning, could not connect to system daemon"
try:
self.__controlProtocol.open(DaemonLocations.controlDaemon[0], DaemonLocations.controlDaemon[1])
except:
print "warning, could not connect to control daemon"
self.registerMethodHandler("login", self.login)
self.registerMethodHandler("logout", self.logout)
self.registerMethodHandler("system", self.systemOperation)
self.registerMethodHandler("control", self.controlOperation)
self.__consoleOperationReply = None
self.__controlOperationReply = None
self.__systemOperationReply = None
self.__ldapClient = LDAPClient("ldap://henldap:389")
def nodeIsOn(self, node):
"""\brief Checks if given node is on.
\param nodeInstance - Instance of node to check
\return result - 0 = off, 1 = on, -1 = unknown/unsupported
XXX TODO: Use powerd for query, removing dependance on having a ref to
henmanager
XXX Small leaking here, as powerSilent creates node instances...
"""
self.__powerStatusCallbackEvent.clear()
p = Protocol(None)
if DaemonStatus().powerDaemonIsOnline(5):
p.open(DaemonLocations.monitorDaemon[0], \
DaemonLocations.monitorDaemon[1])
p.sendRequest("get_power_status", node.getNodeID(), \
self.powerStatusHandler)
p.readAndProcess()
self.__powerStatusCallbackEvent.wait(POWER_STATUS_TIMEOUT)
p.close()
try:
pnodeid = node.getPowerNodeID()
if (pnodeid == "None" or pnodeid == "none"):
return -1
if self.__powerResults:
(st,msg) = (0, self.__powerResults)
else:
(st,msg) = self.__hen_manager.powerSilent(node.getNodeID(), \
"status", pnodeid)
if (st == 0 and msg == "on"):
return 1
if (st == 0 and msg == "off"):
return 0
except Exception, e:
log.debug("nodeIsOn Exception: %s" % str(e))
def addSocket(self,sock):
"""\brief Accepts a new customer
\param socket (\c socket) The opened socket
"""
self.sock_list.append(sock)
prot = Protocol(sock, self.__useSSL)
for i in self.__handlers:
prot.registerMethodHandler(i,self.__handlers[i])
self.protocol_list.append(prot)
def console(self,prot,seq,ln,payload):
print "in console"
if (self.__controlProtocol == None):
self.__controlProtocol = Protocol(None)
self.__controlProtocol.open(DaemonLocations.controlDaemon[0], DaemonLocations.controlDaemon[1])
(action, username, nodeID, consoleInput) = pickle.loads(payload)
print action, username, nodeID, consoleInput
(serialID, serialPort) = self.__getPort(nodeID)
# Replies are needed by doSynchronous call in control daemon
if (action == "open"):
terminalServerConnection = TerminalServerConnection(username, serialPort, self.__terminalServerNodes[serialID])
self.__terminalServerConnections[terminalServerConnection.getSocket()] = terminalServerConnection
self.__terminalServerSockets.append(terminalServerConnection.getSocket())
self.sock_list.append(terminalServerConnection.getSocket())
prot.sendReply(200, seq, "")
return
elif (action == "close"):
for connection in self.__terminalServerConnections.values():
if (connection.getUserID() == username):
connection.close()
self.sock_list.remove(connection.getSocket())
self.__terminalServerSockets.remove(connection.getSocket())
del self.__terminalServerConnections[connection.getSocket()]
break
prot.sendReply(200, seq, "")
return
elif (action == "forward"):
for connection in self.__terminalServerConnections.values():
if (connection.getUserID() == username):
connection.send(consoleInput)
else:
print "unrecognized action:", action
def runChecker(self):
log.debug("runChecker() called.")
log.debug("Acquiring checker lock.")
self.__checker_lock.acquire()
p = Protocol(None)
if DaemonStatus().monitorDaemonIsOnline(5):
p.open(MONITORD_HOST, MONITORD_PORT)
p.sendRequest("get_currentsensorreadings", "",
self.nodeStatusHandler)
p.readAndProcess()
else:
log.info("Monitor Daemon is not online!") # TODO: Email
self.__checker_lock.release()
log.debug("Released checker lock.")
def runChecker(self):
log.debug("runChecker() called.")
log.debug("Acquiring checker lock.")
self.__checker_lock.acquire()
p = Protocol(None)
if DaemonStatus().monitorDaemonIsOnline(5):
p.open(MONITORD_HOST, MONITORD_PORT)
p.sendRequest("get_currentsensorreadings","",self.nodeStatusHandler)
p.readAndProcess()
else:
log.info("Monitor Daemon is not online!") # TODO: Email
self.__checker_lock.release()
log.debug("Released checker lock.")
def __init__(self, useSSL=True):
Daemon.__init__(self, useSSL)
self.__MIN_ID = 100000
self.__MAX_ID = 100000000
self.__SESSION_TIMEOUT_HOURS = 48
self.__loggedInUsers = {}
self.__reverseLoggedInUsers = {}
self.__userProtocols = {}
self.__systemProtocol = Protocol(None)
self.__controlProtocol = Protocol(None)
try:
self.__systemProtocol.open(DaemonLocations.systemDaemon[0],
DaemonLocations.systemDaemon[1])
except:
print "warning, could not connect to system daemon"
try:
self.__controlProtocol.open(DaemonLocations.controlDaemon[0],
DaemonLocations.controlDaemon[1])
except:
print "warning, could not connect to control daemon"
self.registerMethodHandler("login", self.login)
self.registerMethodHandler("logout", self.logout)
self.registerMethodHandler("system", self.systemOperation)
self.registerMethodHandler("control", self.controlOperation)
self.__consoleOperationReply = None
self.__controlOperationReply = None
self.__systemOperationReply = None
self.__ldapClient = LDAPClient("ldap://henldap:389")
class AuthenticationHandler(Daemon):
def __init__(self, useSSL=True):
Daemon.__init__(self, useSSL)
self.__MIN_ID = 100000
self.__MAX_ID = 100000000
self.__SESSION_TIMEOUT_HOURS = 48
self.__loggedInUsers = {}
self.__reverseLoggedInUsers = {}
self.__userProtocols = {}
self.__systemProtocol = Protocol(None)
self.__controlProtocol = Protocol(None)
try:
self.__systemProtocol.open(DaemonLocations.systemDaemon[0],
DaemonLocations.systemDaemon[1])
except:
print "warning, could not connect to system daemon"
try:
self.__controlProtocol.open(DaemonLocations.controlDaemon[0],
DaemonLocations.controlDaemon[1])
except:
print "warning, could not connect to control daemon"
self.registerMethodHandler("login", self.login)
self.registerMethodHandler("logout", self.logout)
self.registerMethodHandler("system", self.systemOperation)
self.registerMethodHandler("control", self.controlOperation)
self.__consoleOperationReply = None
self.__controlOperationReply = None
self.__systemOperationReply = None
self.__ldapClient = LDAPClient("ldap://henldap:389")
def login(self, prot, seq, ln, payload):
(username, password) = pickle.loads(payload)
validLogin = self.__ldapClient.authenticate(username, password)
groups = None
if (validLogin):
ldapInfo = self.__ldapClient.getUserInfoByLogin(username)
groups = ldapInfo.getGroups()
email = ldapInfo.getEmail()
loggedInID = random.randint(self.__MIN_ID, self.__MAX_ID)
loginDate = datetime.datetime.now()
loggedInUser = LoggedInUser(username, loggedInID, email, \
loginDate, groups)
self.__loggedInUsers[loggedInID] = loggedInUser
self.__reverseLoggedInUsers[username] = loggedInID
prot.sendReply(200, seq, str(loggedInID))
else:
prot.sendReply(421, seq, "")
def logout(self, prot, seq, ln, payload):
loggedInID = int(pickle.loads(payload))
if (self.__loggedInUsers.has_key(loggedInID)):
del self.__loggedInUsers[loggedInID]
if (self.__reverseLoggedInUsers.has_key(loggedInID)):
del self.__reverseLoggedInUsers[loggedInID]
if (self.__userProtocols.has_key(loggedInID)):
del self.__userProtocols[loggedInID]
prot.sendReply(200, seq, "")
def systemOperation(self, prot, seq, ln, payload):
(loggedInID, operation, parameters) = pickle.loads(payload)
if (not self.__isLoggedIn(loggedInID, prot, seq)):
return
username = self.__loggedInUsers[loggedInID].getUsername()
groups = self.__loggedInUsers[loggedInID].getGroups()
result = self.__systemProtocol.doSynchronousCall(operation, \
pickle.dumps((username, groups, parameters)))
resID = len(result) - 1
if resID < 0:
prot.sendReply(500, seq, "Got 0 result from systemdaemon!")
return
else:
prot.sendReply(result[resID][0], seq, result[resID][2])
def controlOperation(self, prot, seq, ln, payload):
(loggedInID, operation, parameters) = pickle.loads(payload)
print loggedInID, operation, parameters
# Special console case
if ((operation == "console") or (operation == "console_output")):
self.__console(prot, seq, ln, payload)
return
if (not self.__isLoggedIn(loggedInID, prot, seq)):
return
username = self.__loggedInUsers[loggedInID].getUsername()
groups = self.__loggedInUsers[loggedInID].getGroups()
result = self.__controlProtocol.doSynchronousCall(operation, \
pickle.dumps((username, groups, parameters)))
resID = len(result) - 1
#print "got result",result
if resID < 0:
prot.sendReply(500, seq, "Got 0 result from controldaemon!")
return
else:
prot.sendReply(result[resID][0], seq, result[resID][2])
def __console(self, prot, seq, ln, payload):
(loggedInID, operation, parameters) = pickle.loads(payload)
# Request from hm client
if (operation == "console"):
if (not self.__isLoggedIn(loggedInID, prot, seq)):
return
username = self.__loggedInUsers[loggedInID].getUsername()
groups = self.__loggedInUsers[loggedInID].getGroups()
action = parameters[0]
# Record client protocol so we can later reply to it
if (not self.__userProtocols.has_key(loggedInID)):
self.__userProtocols[loggedInID] = prot
self.__controlProtocol.sendRequest("console", \
pickle.dumps((username, groups, parameters)), \
self.__consoleOperationReplyHandler)
if (action == "open" or action == "close"):
self.__controlProtocol.readAndProcess()
prot.sendReply(self.__consoleOperationReply[0], seq,
self.__consoleOperationReply[3])
# Request from control daemon, forward to console client
elif (operation == "console_output"):
(username, operation, parameters) = pickle.loads(payload)
consoleOutput = parameters[0]
loggedInID = self.__reverseLoggedInUsers[username]
payload = pickle.dumps((200, consoleOutput))
self.__userProtocols[loggedInID].sendRequest(
"console", payload, self.__consoleOperationReplyHandler)
else:
print "unknown console operation received"
return
prot.sendRequest("console", self.__consoleOperationReply[3],
self.__consoleOperationReplyHandler)
def __consoleOperationReplyHandler(self, code, seq, sz, payload):
self.__consoleOperationReply = (code, seq, sz, payload)
def __isLoggedIn(self, loggedInID, prot, seq):
if ((not self.__loggedInUsers.has_key(loggedInID)) or \
self.__hasSessionExpired(loggedInID)):
print "not logged in"
prot.sendReply(400, seq, "")
return False
return True
def __hasSessionExpired(self, loggedInID):
loginDate = self.__loggedInUsers[loggedInID].getLoginDate()
now = datetime.datetime.now()
difference = now - loginDate
minutes, seconds = divmod(difference.seconds, 60)
hours, minutes = divmod(minutes, 60)
sessionTime = hours + (24 * difference.days)
if (sessionTime > self.__SESSION_TIMEOUT_HOURS):
return True
return False
import logging
import os.path
import pickle
from stat import *
from auxiliary.daemonlocations import DaemonLocations
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):
import logging
import os.path
import pickle
from stat import *
from auxiliary.daemonlocations import DaemonLocations
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):
class AuthenticationHandler(Daemon):
def __init__(self, useSSL=True):
Daemon.__init__(self, useSSL)
self.__MIN_ID = 100000
self.__MAX_ID = 100000000
self.__SESSION_TIMEOUT_HOURS = 48
self.__loggedInUsers = {}
self.__reverseLoggedInUsers = {}
self.__userProtocols = {}
self.__systemProtocol = Protocol(None)
self.__controlProtocol = Protocol(None)
try:
self.__systemProtocol.open(DaemonLocations.systemDaemon[0], DaemonLocations.systemDaemon[1])
except:
print "warning, could not connect to system daemon"
try:
self.__controlProtocol.open(DaemonLocations.controlDaemon[0], DaemonLocations.controlDaemon[1])
except:
print "warning, could not connect to control daemon"
self.registerMethodHandler("login", self.login)
self.registerMethodHandler("logout", self.logout)
self.registerMethodHandler("system", self.systemOperation)
self.registerMethodHandler("control", self.controlOperation)
self.__consoleOperationReply = None
self.__controlOperationReply = None
self.__systemOperationReply = None
self.__ldapClient = LDAPClient("ldap://henldap:389")
def login(self,prot,seq,ln,payload):
(username, password) = pickle.loads(payload)
validLogin = self.__ldapClient.authenticate(username, password)
groups = None
if (validLogin):
ldapInfo = self.__ldapClient.getUserInfoByLogin(username)
groups = ldapInfo.getGroups()
email = ldapInfo.getEmail()
loggedInID = random.randint(self.__MIN_ID, self.__MAX_ID)
loginDate = datetime.datetime.now()
loggedInUser = LoggedInUser(username, loggedInID, email, \
loginDate, groups)
self.__loggedInUsers[loggedInID] = loggedInUser
self.__reverseLoggedInUsers[username] = loggedInID
prot.sendReply(200, seq, str(loggedInID))
else:
prot.sendReply(421, seq, "")
def logout(self,prot,seq,ln,payload):
loggedInID = int(pickle.loads(payload))
if (self.__loggedInUsers.has_key(loggedInID)):
del self.__loggedInUsers[loggedInID]
if (self.__reverseLoggedInUsers.has_key(loggedInID)):
del self.__reverseLoggedInUsers[loggedInID]
if (self.__userProtocols.has_key(loggedInID)):
del self.__userProtocols[loggedInID]
prot.sendReply(200,seq,"")
def systemOperation(self,prot,seq,ln,payload):
(loggedInID, operation, parameters) = pickle.loads(payload)
if (not self.__isLoggedIn(loggedInID, prot, seq)):
return
username = self.__loggedInUsers[loggedInID].getUsername()
groups = self.__loggedInUsers[loggedInID].getGroups()
result = self.__systemProtocol.doSynchronousCall(operation, \
pickle.dumps((username, groups, parameters)))
resID = len(result)-1
if resID<0:
prot.sendReply(500,seq,"Got 0 result from systemdaemon!")
return
else:
prot.sendReply(result[resID][0],seq,result[resID][2])
def controlOperation(self,prot,seq,ln,payload):
(loggedInID, operation, parameters) = pickle.loads(payload)
print loggedInID, operation, parameters
# Special console case
if ((operation == "console") or (operation == "console_output")):
self.__console(prot,seq,ln,payload)
return
if (not self.__isLoggedIn(loggedInID, prot, seq)):
return
username = self.__loggedInUsers[loggedInID].getUsername()
groups = self.__loggedInUsers[loggedInID].getGroups()
result = self.__controlProtocol.doSynchronousCall(operation, \
pickle.dumps((username, groups, parameters)))
resID = len(result)-1
#print "got result",result
if resID<0:
prot.sendReply(500,seq,"Got 0 result from controldaemon!")
return
else:
prot.sendReply(result[resID][0],seq,result[resID][2])
def __console(self,prot,seq,ln,payload):
(loggedInID, operation, parameters) = pickle.loads(payload)
# Request from hm client
if (operation == "console"):
if (not self.__isLoggedIn(loggedInID, prot, seq)):
return
username = self.__loggedInUsers[loggedInID].getUsername()
groups = self.__loggedInUsers[loggedInID].getGroups()
action = parameters[0]
# Record client protocol so we can later reply to it
if (not self.__userProtocols.has_key(loggedInID)):
self.__userProtocols[loggedInID] = prot
self.__controlProtocol.sendRequest("console", \
pickle.dumps((username, groups, parameters)), \
self.__consoleOperationReplyHandler)
if (action == "open" or action == "close"):
self.__controlProtocol.readAndProcess()
prot.sendReply(self.__consoleOperationReply[0], seq, self.__consoleOperationReply[3])
# Request from control daemon, forward to console client
elif (operation == "console_output"):
(username, operation, parameters) = pickle.loads(payload)
consoleOutput = parameters[0]
loggedInID = self.__reverseLoggedInUsers[username]
payload = pickle.dumps((200, consoleOutput))
self.__userProtocols[loggedInID].sendRequest("console", payload, self.__consoleOperationReplyHandler)
else:
print "unknown console operation received"
return
prot.sendRequest("console", self.__consoleOperationReply[3], self.__consoleOperationReplyHandler)
def __consoleOperationReplyHandler(self, code, seq, sz, payload):
self.__consoleOperationReply = (code, seq, sz, payload)
def __isLoggedIn(self, loggedInID, prot, seq):
if ((not self.__loggedInUsers.has_key(loggedInID)) or \
self.__hasSessionExpired(loggedInID)):
print "not logged in"
prot.sendReply(400,seq,"")
return False
return True
def __hasSessionExpired(self, loggedInID):
loginDate = self.__loggedInUsers[loggedInID].getLoginDate()
now = datetime.datetime.now()
difference = now - loginDate
minutes, seconds = divmod(difference.seconds, 60)
hours, minutes = divmod(minutes, 60)
sessionTime = hours + (24 * difference.days)
if (sessionTime > self.__SESSION_TIMEOUT_HOURS):
return True
return False
class ConsoleControl(Daemon):
"""\brief Implements basic console daemon functionality.
"""
def __init__(self, configFilePath='/usr/local/hen/etc/configs/config'):
Daemon.__init__(self)
self.__version = "Console Daemon v0.2 (dumb)"
self.__terminalServerConnections = {}
self.__terminalServerSockets = []
self.__configFilePath = configFilePath
self.__configFile = ConfigParser.ConfigParser()
self.__configFile.read(configFilePath)
self.__henPhysicalTopology = self.__configFile.get('MAIN','PHYSICAL_TOPOLOGY')
self.__henLogPath = self.__configFile.get('MAIN', 'LOG_PATH')
self.__parser = HenParser(self.__henPhysicalTopology, \
None, \
None, \
self.__henLogPath, \
None,
None,
None, \
None)
self.__controlProtocol = None
# Create instances for all terminal servers in the testbed
self.__terminalServerNodes = {}
for terminalServerNode in self.__parser.getNodes("serial", "all").values():
self.__terminalServerNodes[terminalServerNode.getNodeID()] = terminalServerNode.getInstance()
self.__computerNodes = self.__parser.getNodes("computer", "all")
self.__registerMethods()
def __registerMethods(self):
self.registerMethodHandler("console", self.console)
def __getPort(self, nodeID):
return (self.__computerNodes[nodeID].getSerialNodeID(), self.__computerNodes[nodeID].getSerialNodePort())
def console(self,prot,seq,ln,payload):
print "in console"
if (self.__controlProtocol == None):
self.__controlProtocol = Protocol(None)
self.__controlProtocol.open(DaemonLocations.controlDaemon[0], DaemonLocations.controlDaemon[1])
(action, username, nodeID, consoleInput) = pickle.loads(payload)
print action, username, nodeID, consoleInput
(serialID, serialPort) = self.__getPort(nodeID)
# Replies are needed by doSynchronous call in control daemon
if (action == "open"):
terminalServerConnection = TerminalServerConnection(username, serialPort, self.__terminalServerNodes[serialID])
self.__terminalServerConnections[terminalServerConnection.getSocket()] = terminalServerConnection
self.__terminalServerSockets.append(terminalServerConnection.getSocket())
self.sock_list.append(terminalServerConnection.getSocket())
prot.sendReply(200, seq, "")
return
elif (action == "close"):
for connection in self.__terminalServerConnections.values():
if (connection.getUserID() == username):
connection.close()
self.sock_list.remove(connection.getSocket())
self.__terminalServerSockets.remove(connection.getSocket())
del self.__terminalServerConnections[connection.getSocket()]
break
prot.sendReply(200, seq, "")
return
elif (action == "forward"):
for connection in self.__terminalServerConnections.values():
if (connection.getUserID() == username):
connection.send(consoleInput)
else:
print "unrecognized action:", action
def processTerminalServerData(self, sock):
connection = self.__terminalServerConnections[sock]
if (connection.recv()):
self.__controlProtocol.sendRequest("console", \
pickle.dumps((connection.getUserID(), \
connection.getAndDeleteBuffer(), \
["console_output"])), \
self.terminalServerDataReplyHandler)
def terminalServerDataReplyHandler(self, code, seq, sz, payload):
pass
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 ConsoleDaemon (self)")
self.stop()
def run(self):
"""\brief Main daemon loop
Waits for messages from clients and processes them. Only sleeps for two
seconds, to accept new clients also.
"""
while not self.isStopped:
#select sockets
(read,write,exc) = select.select(self.sock_list,[],self.sock_list,2)
for i in read:
s = None
if (i in self.__terminalServerSockets):
self.processTerminalServerData(i)
continue
# Process regular socket
try:
s = i.recv(1000000,0)
# Process SSL socket
except:
try:
s = i.read(1000000)
except:
s = []
try:
#log.debug("Read from socket:"+s.replace("\r","\\r"))
if (len(s)==0):
#log.debug("removing")
idx = self.sock_list.index(i)
del self.sock_list[idx]
del self.protocol_list[idx]
else:
self.protocol_list[self.sock_list.index(i)].processPacket(s)
except Exception,e:
idx = self.sock_list.index(i)
del self.sock_list[idx]
del self.protocol_list[idx]
traceback.print_exc()
for i in exc:
log.debug ("exc",i)
