def stopAgent(self, msg): functionName = self.stopAgent.__name__ helpers.entrylog(log, functionName, level=logging.INFO) self.active = False if self.thread: self.thread.join() helpers.exitlog(log, functionName, level=logging.INFO)
def registerShard(dbHost, configHost, dbPort=DATABASE_SERVER_PORT, configPort=ROUTER_SERVER_PORT, block=True, timeout=TIMEOUT): """ Function to register a database server as a shard in the database cluster """ functionName = registerShard.__name__ helpers.entrylog(log, functionName, locals()) if not block: timeout = 0 elif timeout <= 0: timeout = sys.maxint start = time.time() stop = start + timeout log.info("Trying to register %s:%d as a shard on %s:%d" %(dbHost, dbPort, configHost, configPort)) connection = getConnection(host=configHost, port=configPort, timeout=timeout) #check if mongos is up and connect to it getConnection(host=dbHost, port=DATABASE_SERVER_PORT, timeout=timeout) #check if mongod is up while time.time() < stop: if call("""mongo --host %s --eval "sh.addShard('%s:%d')" """ %(configHost, dbHost, dbPort), shell=True): log.debug("Failed to add shard. Will retry.") time.sleep(1) continue if connection.config.shards.find({"host": "%s:%d" % (dbHost, dbPort)}).count() == 0: log.debug("Failed to add shard. Will retry.") time.sleep(1) continue log.info("Registered %s as a shard on %s" %(dbHost, configHost)) helpers.exitlog(log, functionName) return log.error("Cannot add the required shard") helpers.exitlog(log, functionName) raise pymongo.errors.PyMongoError("Cannot add the required shard")
def isShardRegistered(dbHost, configHost, dbPort=DATABASE_SERVER_PORT, configPort=ROUTER_SERVER_PORT, block=True): """ Check if given mongo db host is registered as a shard """ functionName = isShardRegistered.__name__ helpers.entrylog(log, functionName, locals()) connection = getConnection(host=configHost, port=configPort) log.info("Checking if database server is registered as a shard") while True: try: if connection.config.shards.find({ "host": "%s:%d" % (dbHost, dbPort) }).count() != 0: helpers.exitlog(log, functionName) return True except: pass if not block: helpers.exitlog(log, functionName) return False time.sleep(1)
def getCollection(agentName, hostName, connection=None, dbHost='localhost', dbPort=DATABASE_SERVER_PORT): """ Function to get a pointer to a given agent data collection """ functionName = getCollection.__name__ helpers.entrylog(log, functionName, locals()) global collectionCache if connection: if not isinstance(connection, Connection): raise TypeError("Invalid connection instance") dbHost = connection.host dbPort = connection.port if (agentName, dbHost, dbPort) not in collectionCache: collectionCache[(agentName, hostName, dbHost, dbPort)] = Collection(agentName=agentName, hostName=hostName, connection=connection, dbHost=dbHost, dbPort=dbPort) helpers.exitlog(log, functionName) return collectionCache[(agentName, hostName, dbHost, dbPort)]
def getStatus(self, msg, groupMembership=False, agentInfo=False): """ gives the group membership and agent information: pid, agentname, threadId """ functionName = self.getStatus.__name__ helpers.entrylog(log, functionName, locals()) result = dict() result['status'] = True if groupMembership: groupMembership = dict(self.messaging.groupMembership) result['groupMembership'] = groupMembership if agentInfo: agentInfo = [] processId = os.getpid() for tAgent in self.staticAgents + self.threadAgents: agentInfo.append({"name": tAgent.agentname, "processId": processId, "threadId": tAgent.tid}) for name in self.pAgentPids.keys(): agentInfo.append({"name": name, "processId": self.pAgentPids[name]}) result['agentInfo'] = agentInfo self.messaging.send(MAGIMessage(nodes=msg.src, docks=msg.srcdock, contenttype=MAGIMessage.YAML, data=yaml.safe_dump(result))) helpers.exitlog(log, functionName)
def computeMu(self, k): functionName = self.computeMu.__name__ helpers.entrylog(log, functionName) self.mu5[k+1] = max(0, self.mu5[k] + self.Kmu5*(-self.P_D[k] - self.K_E*self.E_D[k] + self.P_Dmin)) self.mu6[k+1] = max(0, self.mu6[k] + self.Kmu6*(self.P_D[k] + self.K_E*self.E_D[k] - self.P_Dmax)) log.info("Computed Mu. k=%d, mu5:%f, mu6:%f", k+1, self.mu5[k+1], self.mu6[k+1]) helpers.exitlog(log, functionName)
def reboot(self, msg, distributionDir=None, noUpdate=False, noInstall=False, expConf=None, nodeConf=None): """ reinvokes magi_bootstrap, the boostrap script invokes stop() and does a clean shutdown and then restarts """ functionName = self.reboot.__name__ helpers.entrylog(log, functionName, locals()) if not distributionDir: distributionDir = config.getDistDir() rebootCmd = "sudo %s/magi_bootstrap.py -p %s" %(distributionDir, distributionDir) if noUpdate: rebootCmd += ' --noupdate' if noInstall: rebootCmd += ' --noinstall' if not expConf and not nodeConf: nodeConf = config.getNodeConfFile() if expConf: rebootCmd += ' --expconf %s' %(expConf) if nodeConf: rebootCmd += ' --nodeconf %s' %(nodeConf) log.info("Rebooting: %s" %(rebootCmd)) self.messaging.send(MAGIMessage(nodes=msg.src, docks=msg.srcdock, contenttype=MAGIMessage.YAML, data=yaml.safe_dump({'status' : True}))) Popen(rebootCmd.split()) helpers.exitlog(log, functionName)
def initCommClient(self, address, replyHandler): functionName = self.initCommClient.__name__ helpers.entrylog(log, functionName, level=logging.INFO) self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.settimeout(TXTIMEOUT) retries = 0 while not self.connected: log.info("Trying to connect to server, attempt #%d..." % (retries + 1)) try: self.sock.connect((address, PORT)) self.connected = True log.info("Connected to server") except socket.error as e: retries += 1 log.info("Socket timed out, exception: %s" % repr(e)) time.sleep(0.1 + (random.random() * 0.3)) data = json.dumps({'src': self.clientId}) self.sock.send(data) self.active = True thread = Thread(name="ClientHandler for " + self.clientId, target=self.ClientHandler, args=(replyHandler, )) thread.start() helpers.exitlog(log, functionName, level=logging.INFO) return thread
def terminateserver(self): functionName = self.terminateserver.__name__ helpers.entrylog(log, functionName, level=logging.INFO) self.commServer.stop() helpers.exitlog(log, functionName, level=logging.INFO) return True
def initCommClient(self, address, port, replyHandler): functionName = self.initCommClient.__name__ helpers.entrylog(log, functionName, level=logging.INFO) self.sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.settimeout(TXTIMEOUT) retries = 0 while not self.connected: log.info("Trying to connect to server, attempt #%d..." % (retries+1)) try: log.info("Trying to connect to server %s..." % (address)) self.sock.connect((address, port)) self.connected = True log.info("Connected to server") except socket.error as e: retries += 1 log.info("Socket timed out, exception: %s" % repr(e)) time.sleep(0.1 + (random.random()*0.3)) if retries == 10: log.info("Failed to connect after ten retires... %s" % repr(e)) return # Now that a connection is established with the server start the # server management thread so that client and asynchronously send and recv self.active = True thread = Thread(name="ClientHandler for " + str(self.clientId), target=self.ClientHandler, args=(replyHandler,)) thread.start() helpers.exitlog(log, functionName, level=logging.INFO) return thread
def initCommClient(self, address, replyHandler): functionName = self.initCommClient.__name__ helpers.entrylog(log, functionName, level=logging.INFO) self.sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.settimeout(TXTIMEOUT) retries = 0 while not self.connected: log.info("Trying to connect to server, attempt #%d..." % (retries+1)) try: self.sock.connect((address, PORT)) self.connected = True log.info("Connected to server") except socket.error as e: retries += 1 log.info("Socket timed out, exception: %s" % repr(e)) time.sleep(0.1 + (random.random()*0.3)) data = json.dumps({'src': self.clientId}) self.sock.send(data) self.active = True thread = Thread(name="ClientHandler for " + self.clientId, target=self.ClientHandler, args=(replyHandler,)) thread.start() helpers.exitlog(log, functionName, level=logging.INFO) return thread
def getData(self, msg, agents=None, nodes=None, filters=dict(), timestampChunks=None, visited=set()): """ Request to fetch data """ functionName = self.getData.__name__ helpers.entrylog(log, functionName, locals()) agents_ = helpers.toSet(agents) nodes_ = helpers.toSet(nodes) if not nodes_: nodes_ = config.getTopoGraph().nodes() if not agents_: if nodes: agents_ = self.getSensorAgents(nodes[0]) else: raise AttributeError( "Cannot query for an empty set of collections.") if timestampChunks == None: timestampChunks = [(0, time.time())] data = dict() for agent in agents_: data[agent] = dict() for node in nodes_: filters_copy = filters.copy() filters_copy['host'] = node nodedata = [] for tsChunk in timestampChunks: nodedata = nodedata + database.getData( agent, filters_copy, tsChunk, database.configHost(), database.ROUTER_SERVER_PORT) data[agent][node] = nodedata args = { "agents": agents, "nodes": nodes, "filters": filters, "timestampChunks": timestampChunks, "visited": visited, "data": data } call = {'version': 1.0, 'method': 'putData', 'args': args} log.debug('Creating data message') msg = MAGIMessage(nodes=msg.src, docks='dataman', contenttype=MAGIMessage.PICKLE, data=pickle.dumps(call)) log.debug('Sending message') self.messenger.send(msg) helpers.exitlog(log, functionName)
def computeMu(self, k): functionName = self.computeMu.__name__ helpers.entrylog(log, functionName) self.mu3[k+1] = max(0, self.mu3[k] + self.Kmu3*(self.P_Gmin-self.P_G[k])) self.mu4[k+1] = max(0, self.mu4[k] + self.Kmu4*(self.P_G[k]-self.P_Gmax)) log.info("Computed Mu. k=%d, mu3:%f, mu4:%f", k+1, self.mu3[k+1], self.mu4[k+1]) helpers.exitlog(log, functionName)
def sendGradF(self, k): functionName = self.sendGradF.__name__ helpers.entrylog(log, functionName) pdr = self.P_D[k] grad_f = self.grad_f[k] log.info("Sending grad_f to ISO: %f, P_D: %f (k=%d)", grad_f, pdr, k) self.commClient.sendData({'k': k, 'pdr': pdr, 'grad_f': grad_f}) helpers.exitlog(log, functionName)
def requestPdr(self, k): functionName = self.requestPdr.__name__ helpers.entrylog(log, functionName) log.debug("Requesting Pdr, k:%d", k) kwargs = {'method' : 'sendPdr', 'args' : {'k' : k}, 'version' : 1.0} msg = MAGIMessage(groups="dr_group", docks="dmm_dock", data=yaml.dump(kwargs), contenttype=MAGIMessage.YAML) self.messenger.send(msg) helpers.exitlog(log, functionName)
def sendTheta(self, k): functionName = self.sendTheta.__name__ helpers.entrylog(log, functionName) theta = self.theta[:, k] kwargs = {'method' : 'receiveTheta', 'args' : {'k' : k, 'theta' : theta}, 'version' : 1.0} msg = MAGIMessage(nodes="grid", docks="dmm_dock", data=yaml.dump(kwargs), contenttype=MAGIMessage.YAML) self.messenger.send(msg) helpers.exitlog(log, functionName)
def sendRho(self, k): functionName = self.sendRho.__name__ helpers.entrylog(log, functionName, locals()) kwargs = {'method' : 'receiveRho', 'args' : {'k' : k, 'rho' : self.rho[k]}, 'version' : 1.0} log.debug("Sending rho: %s", kwargs['args']) msg = MAGIMessage(nodes="iso", docks="dmm_dock", data=yaml.dump(kwargs), contenttype=MAGIMessage.YAML) self.messenger.send(msg) helpers.exitlog(log, functionName)
def sendFreqErrorNotice(self, status): functionName = self.sendFreqErrorNotice.__name__ helpers.entrylog(log, functionName, locals()) kwargs = {'method' : 'receiveFreqErrorNotice', 'args' : {'status' : status}, 'version' : 1.0} log.info("Sending freqErrorNotice: %s", kwargs['args']) msg = MAGIMessage(nodes="iso", docks="dmm_dock", data=yaml.dump(kwargs), contenttype=MAGIMessage.YAML) self.messenger.send(msg) helpers.exitlog(log, functionName)
def sendGradF(self, k): functionName = self.sendGradF.__name__ helpers.entrylog(log, functionName) pdr = self.P_D[k] grad_f = self.grad_f[k] log.info("Sending grad_f to ISO: %f, P_D: %f (k=%d)", grad_f, pdr, k) self.commClient.sendData({'k' : k, 'pdr': pdr, 'grad_f' : grad_f}) helpers.exitlog(log, functionName)
def sendPdr(self, k): functionName = self.sendPdr.__name__ helpers.entrylog(log, functionName) for agentIndex in range(0, self.N_dem): node = "dr-"+str(agentIndex) pdr = self.P_D[agentIndex, k] log.debug("Sending P_D, dst: %s, k:%d, pdr:%f", node, k, pdr) self.commServer.sendData(node, {'k' : k, 'pdr' : pdr}) helpers.exitlog(log, functionName)
def testInt(self, msg, a, b): functionName = self.testInt.__name__ helpers.entrylog(log, functionName, locals(), logging.INFO) log.info("a: %d" %(a)) log.info("b: %d" %(b)) result = a + b log.info("result: %d" %(result)) helpers.exitlog(log, functionName, result, logging.INFO) return result
def sendPdr(self, k): functionName = self.sendPdr.__name__ helpers.entrylog(log, functionName) for agentIndex in range(0, self.N_dem): node = "dr-" + str(agentIndex) pdr = self.P_D[agentIndex, k] log.debug("Sending P_D, dst: %s, k:%d, pdr:%f", node, k, pdr) self.commServer.sendData(node, {'k': k, 'pdr': pdr}) helpers.exitlog(log, functionName)
def testInt(self, msg, a, b): functionName = self.testInt.__name__ helpers.entrylog(log, functionName, locals(), logging.INFO) log.info("a: %d" % (a)) log.info("b: %d" % (b)) result = a + b log.info("result: %d" % (result)) helpers.exitlog(log, functionName, result, logging.INFO) return result
def __init__(self, clientId): log.info("In ClientCommService Init") self.active = False self.clientId = clientId self.connected = False self.sock = None functionName = self.initCommClient.__name__ + str(self.clientId) helpers.exitlog(log, functionName, level=logging.INFO)
def computeMu(self, k): functionName = self.computeMu.__name__ helpers.entrylog(log, functionName) self.mu3[k + 1] = max( 0, self.mu3[k] + self.Kmu3 * (self.P_Gmin - self.P_G[k])) self.mu4[k + 1] = max( 0, self.mu4[k] + self.Kmu4 * (self.P_G[k] - self.P_Gmax)) log.info("Computed Mu. k=%d, mu3:%f, mu4:%f", k + 1, self.mu3[k + 1], self.mu4[k + 1]) helpers.exitlog(log, functionName)
def runserver(self): functionName = self.runserver.__name__ + "on port " + str(self.port) helpers.entrylog(log, functionName, level=logging.INFO) self.commServer = ServerCommService() self.commServer.initCommServer(self.port, self.responseHandler) helpers.exitlog(log, functionName, level=logging.INFO) return True
def setupDBLogHandler(self): functionName = self.setupDBLogHandler.__name__ helpers.entrylog(log, functionName, locals()) log.info("Setting up database log handler") from magi.util.databaseLogHandler import DatabaseHandler self.dbLogHandler = DatabaseHandler.to(level=logging.INFO) rootLogger = logging.getLogger() rootLogger.addHandler(self.dbLogHandler) helpers.exitlog(log, functionName)
def sendPg(self, k): functionName = self.sendPg.__name__ helpers.entrylog(log, functionName) for agentIndex in range(0, self.N_gen): if not self.statusGens[agentIndex]: continue # inactive generator node = "gen-" + str(agentIndex) pg = self.P_G[agentIndex, k] log.debug("Sending P_G, dst: %s, k:%d, pg:%f", node, k, pg) self.commServer.sendData(node, {'k': k, 'pg': pg}) helpers.exitlog(log, functionName)
def sendPg(self, k): functionName = self.sendPg.__name__ helpers.entrylog(log, functionName) for agentIndex in range(0, self.N_gen): if not self.statusGens[agentIndex]: continue # inactive generator node = "gen-"+str(agentIndex) pg = self.P_G[agentIndex, k] log.debug("Sending P_G, dst: %s, k:%d, pg:%f", node, k, pg) self.commServer.sendData(node, {'k' : k, 'pg' : pg}) helpers.exitlog(log, functionName)
def sendEdr(self, k): functionName = self.sendEdr.__name__ helpers.entrylog(log, functionName) for agentIndex in range(0, self.N_dem): node = "dr-"+str(agentIndex) edr = self.E_D[agentIndex, k] log.debug("Sending E_D, Node: %s, k:%d, E_D:%f", node, k, edr) kwargs = {'method' : 'receiveEdr', 'args' : {'k' : k, 'edr' : edr}, 'version' : 1.0} msg = MAGIMessage(nodes=node, docks="dmm_dock", data=yaml.dump(kwargs), contenttype=MAGIMessage.YAML) self.messenger.send(msg) helpers.exitlog(log, functionName)
def sendPdr(self, msg, k): functionName = self.sendPdr.__name__ helpers.entrylog(log, functionName) self.currentGridTs = k if k > self.lastPdrRcvdTs: self.P_D[k] = self.P_D[self.lastPdrRcvdTs] pdr = self.P_D[k] log.info("Sending P_D to grid agent: %f (k=%d)", pdr, k) kwargs = {'method' : 'receivePdr', 'args' : {'k' : k, 'pdr' : pdr}, 'version' : 1.0} msg = MAGIMessage(nodes="grid", docks="dmm_dock", data=yaml.dump(kwargs), contenttype=MAGIMessage.YAML) self.messenger.send(msg) helpers.exitlog(log, functionName)
def computeMu(self, k): functionName = self.computeMu.__name__ helpers.entrylog(log, functionName) self.mu5[k + 1] = max( 0, self.mu5[k] + self.Kmu5 * (-self.P_D[k] - self.K_E * self.E_D[k] + self.P_Dmin)) self.mu6[k + 1] = max( 0, self.mu6[k] + self.Kmu6 * (self.P_D[k] + self.K_E * self.E_D[k] - self.P_Dmax)) log.info("Computed Mu. k=%d, mu5:%f, mu6:%f", k + 1, self.mu5[k + 1], self.mu6[k + 1]) helpers.exitlog(log, functionName)
def getData(self, msg, agents=None, nodes=None, filters=dict(), timestampChunks=None, visited=set()): """ Request to fetch data """ functionName = self.getData.__name__ helpers.entrylog(log, functionName, locals()) agents_ = helpers.toSet(agents) nodes_ = helpers.toSet(nodes) if not nodes_: nodes_ = config.getTopoGraph().nodes() if not agents_: if nodes: agents_ = self.getSensorAgents(nodes[0]) else: raise AttributeError("Cannot query for an empty set of collections.") if timestampChunks == None: timestampChunks = [(0, time.time())] data = dict() for agent in agents_: data[agent] = dict() for node in nodes_: filters_copy = filters.copy() filters_copy['host'] = node nodedata = [] for tsChunk in timestampChunks: nodedata = nodedata + database.getData(agent, filters_copy, tsChunk, database.configHost(), database.ROUTER_SERVER_PORT) data[agent][node] = nodedata args = { "agents": agents, "nodes": nodes, "filters": filters, "timestampChunks": timestampChunks, "visited": visited, "data": data } call = {'version': 1.0, 'method': 'putData', 'args': args} log.debug('Creating data message') msg = MAGIMessage(nodes=msg.src, docks='dataman', contenttype=MAGIMessage.PICKLE, data=pickle.dumps(call)) log.debug('Sending message') self.messenger.send(msg) helpers.exitlog(log, functionName)
def digest(self, *args): functionName = self.digest.__name__ helpers.entrylog(log, functionName, locals()) m = hashlib.md5() for arg in args: if type(arg) is set: arg = list(arg) if type(arg) is list: arg.sort() m.update(str(arg)) result = m.hexdigest() helpers.exitlog(log, functionName, result) return result
def putCollectionMetadata(self, msg, collectionMetadata): """ Response for collector information request """ functionName = self.putCollectionMetadata.__name__ helpers.entrylog(log, functionName, locals()) self.collectionMetadata[msg.src] = CachedItem(msg.src, collectionMetadata) queryHash = self.digest("CollectionMetadata", msg.src) self.events[queryHash].set() self.events[queryHash].clear() helpers.exitlog(log, functionName)
def getCollector(self, node, agentName): """ Internal function to fetch the collector for a given node and agent """ functionName = self.getCollector.__name__ helpers.entrylog(log, functionName, locals()) node = node.split(".")[0] sensorToCollectorMap = database.getSensorToCollectorMap() result = sensorToCollectorMap.get(node, sensorToCollectorMap.get('__ALL__')) helpers.exitlog(log, functionName, result) return result
def sendGradF(self, k): functionName = self.sendGradF.__name__ helpers.entrylog(log, functionName, locals()) pg = self.P_G[k] grad_f = self.grad_f[k] self.collection.insert({'k': k, 'gradFDeception': self.gradFDeception}) if self.gradFDeceptionAttack: log.info("gradFDeception grad_f: %f, deception: %f (k=%d)", grad_f, self.gradFDeception, k) grad_f += self.gradFDeception self.gradFDeception += self.gradFDeceptionInc log.info("Sending grad_f to ISO: %f, P_G: %f (k=%d)", grad_f, pg, k) self.commClient.sendData({'k': k, 'pg': pg, 'grad_f': grad_f}) helpers.exitlog(log, functionName)
def sendGradF(self, k): functionName = self.sendGradF.__name__ helpers.entrylog(log, functionName, locals()) pg = self.P_G[k] grad_f = self.grad_f[k] self.collection.insert({'k' : k, 'gradFDeception' : self.gradFDeception}) if self.gradFDeceptionAttack: log.info("gradFDeception grad_f: %f, deception: %f (k=%d)", grad_f, self.gradFDeception, k) grad_f += self.gradFDeception self.gradFDeception += self.gradFDeceptionInc log.info("Sending grad_f to ISO: %f, P_G: %f (k=%d)", grad_f, pg, k) self.commClient.sendData({'k' : k, 'pg': pg, 'grad_f' : grad_f}) helpers.exitlog(log, functionName)
def archive(self, msg, destinationDir=config.getTempDir()): """ Tars the log directory" """ functionName = self.archive.__name__ helpers.entrylog(log, functionName, locals()) logDir = config.getLogDir() logTar = tarfile.open(name=os.path.join(destinationDir, "logs_%s.tar.gz"%(datetime.datetime.now() .strftime("%Y%m%d_%H%M%S"))), mode='w:gz') logTar.add(logDir, arcname=os.path.basename(logDir)) logTar.close() helpers.exitlog(log, functionName)
def isShardRegistered(dbHost=None, configHost=getConfigHost(), block=False): """ Check if given mongo db host is registered as a shard """ functionName = isShardRegistered.__name__ helpers.entrylog(log, functionName, locals()) if dbHost == None: dbHost = getCollector() helpers.exitlog(log, functionName) return Server.isShardRegistered( dbHost=helpers.toControlPlaneNodeName(dbHost), configHost=helpers.toControlPlaneNodeName(configHost), block=block)
def registerShard( mongod=config.getNodeName(), mongos=getConfigHost(), timeout=TIMEOUT): """ Function to register a database server as a shard in the database cluster """ functionName = registerShard.__name__ helpers.entrylog(log, functionName, locals()) mongod = helpers.toControlPlaneNodeName(mongod) mongos = helpers.toControlPlaneNodeName(mongos) Server.registerShard(dbHost=mongod, configHost=mongos, timeout=timeout) helpers.exitlog(log, functionName)
def getCollectionMetadata(self, msg): """ Request for collector information """ functionName = self.getCollectionMetadata.__name__ helpers.entrylog(log, functionName, locals()) args = { "collectionMetadata" : database.collectionHosts } call = {'version': 1.0, 'method': 'putCollectionMetadata', 'args': args} msg = MAGIMessage(nodes=msg.src, docks='dataman', contenttype=MAGIMessage.YAML, data=yaml.dump(call)) self.messenger.send(msg) helpers.exitlog(log, functionName)
def setupDatabase(self): functionName = self.setupDatabase.__name__ helpers.entrylog(log, functionName, locals()) log.info("Setting up database") if database.isDBSharded(): log.info("Setting up a distributed database") if database.isConfigHost(): log.info("Starting mongo config server") cp = database.startConfigServer() if cp: #if a database server was started with this call self.dbProcesses.add(cp) log.info("Starting mongo shard server") sp = database.startShardServer() if sp: #if a database server was started with this call self.dbProcesses.add(sp) log.info("Starting mongo database server") dp = database.startDBServer() if dp: #if a database server was started with this call self.dbProcesses.add(dp) log.info("Stopping balancer") database.setBalancerState(False) log.info("Configuring database cluster") self.configureDBCluster() elif database.isCollector(): log.info("Starting mongo database server") dp = database.startDBServer() if dp: #if a database server was started with this call self.dbProcesses.add(dp) log.info("Waiting for collector database to be added as a shard") database.isShardRegistered(dbHost=database.getCollector(), block=True) log.info("Collector database has been added as a shard") else: log.info("Setting up a non-distributed database") if database.isCollector(): log.info("Starting mongo database server") dp = database.startDBServer() if dp: #if a database server was started with this call self.dbProcesses.add(dp) log.info("Waiting for collector database to be up and running") database.getConnection() log.info("Collector database up") helpers.exitlog(log, functionName)
def getLogsArchive(self, msg): """ Tars the log directory and sends it to the requester as a message" """ functionName = self.archive.__name__ helpers.entrylog(log, functionName, locals()) logDir = config.getLogDir() store = cStringIO.StringIO() logTar = tarfile.open(fileobj=store, mode='w:gz') logTar.add(logDir, arcname=os.path.basename(logDir)) logTar.close() result = base64.encodestring(store.getvalue()) self.messaging.send(MAGIMessage(nodes=msg.src, docks=msg.srcdock, contenttype=MAGIMessage.YAML, data=yaml.safe_dump(result))) helpers.exitlog(log, functionName)