def monitorEngine(address, port, dbPassword, listener=None): if not listener: listener = _StandardOutListener() s = Session(address, port=port, service="Monitor") s.authorize("Cloud", dbPassword) monitor = SessionMonitor(s, listener=listener) monitor.start() s.doConnect() return EngineMonitor(monitor, s)
def monitorDomainStats(broker, user, password, listener=None): if not listener: listener = _StandardOutListener() s = Session(broker, service="HostStats") s.authorize(user, password) s.doConnect() checkForError(s.recv()) monitor = SessionMonitor(s, listener=listener) monitor.start() return monitor
def __init__(self, broker_addr, domain_user, domain_pwd, listener=None): """ @type broker_addr str @type domain_user str @type domain_pwd str @type listener """ if not domain_pwd: raise Exception("A password is required to join a domain") self.__session = Session(broker_addr, service="Monitor") self.__session.authorize(domain_user, domain_pwd) self.__user = domain_user self.__password = domain_pwd self.__listener = listener self.__peers = dict() """ @type : dict[str, Peer] """ self.__databases = dict() """ @type : dict[str, Database] """ self.__monitor = SessionMonitor(self.__session, self) # These will be set in handle status after joining the domain self.__domain_name = None """ @type : str """ self.__entry_peer = None """ @type : Peer """ try: self.__session.doConnect() self.__handle_status(self.__session.recv()) except Exception: self.__monitor.close() raise self.__monitor.start()
def __init__(self, broker_addr, domain_user, domain_pwd, listener=None): """ @type broker_addr str @type domain_user str @type domain_pwd str @type listener """ if not domain_pwd: raise Exception("A password is required to join a domain") self.__session = Session(broker_addr, service="Monitor") self.__session.authorize(domain_user, domain_pwd) self.__user = domain_user self.__password = domain_pwd self.__listener = listener self.__peers = dict() """ @type : dict[str, Peer] """ self.__peers_by_addr = dict() """ @type : dict[str, Peer] """ self.__databases = dict() """ @type : dict[str, Database] """ self.__monitor = SessionMonitor(self.__session, self) # These will be set in handle status after joining the domain self.__domain_name = None """ @type : str """ self.__entry_peer = None """ @type : Peer """ try: self.__session.doConnect() self.__handle_status(self.__session.recv()) except Exception: self.__monitor.close() raise self.__monitor.start()
def __init__(self, brokerAddr, domainUser, domainPwd, listener=None): if not domainPwd: raise Exception("A password is required to join a domain") self.__session = Session(brokerAddr, service="Monitor") self.__session.authorize(domainUser, domainPwd) self.__user = domainUser self.__password = domainPwd self.__listener = listener self.__peers = dict() self.__databases = dict() self.__monitor = SessionMonitor(self.__session, self) try: self.__session.doConnect() self.__handleStatus(self.__session.recv()) except Exception: self.__monitor.close() raise self.__monitor.start()
class Domain(BaseListener): """Represents the NuoDB domain. The domain is the top level NuoDB management object. The domain object provides access to the peers and databases that are contained within. """ def __init__(self, broker_addr, domain_user, domain_pwd, listener=None): """ @type broker_addr str @type domain_user str @type domain_pwd str @type listener """ if not domain_pwd: raise Exception("A password is required to join a domain") self.__session = Session(broker_addr, service="Monitor") self.__session.authorize(domain_user, domain_pwd) self.__user = domain_user self.__password = domain_pwd self.__listener = listener self.__peers = dict() """ @type : dict[str, Peer] """ self.__databases = dict() """ @type : dict[str, Database] """ self.__monitor = SessionMonitor(self.__session, self) # These will be set in handle status after joining the domain self.__domain_name = None """ @type : str """ self.__entry_peer = None """ @type : Peer """ try: self.__session.doConnect() self.__handle_status(self.__session.recv()) except Exception: self.__monitor.close() raise self.__monitor.start() def __str__(self): return self.domain_name + " [Entered through: " + self.entry_peer.connect_str + "]" def disconnect(self): """Disconnect from the domain.""" self.__monitor.close() def _send_domain_message(self, service, attributes=None, text=None, children=None): session = Session(self.__entry_peer.address, port=self.__entry_peer.port, service=service) session.authorize(self.__user, self.__password) return session.doRequest(attributes, text, children) @property def user(self): """Return the domain user.""" return self.__user @property def password(self): """Return the domain password.""" return self.__password @property def domain_name(self): """Return the domain name.""" return self.__domain_name def find_peer(self, address): """ Find a peer by address @type: address str @rtype: Peer """ def get_peer(self, agent_id): """ Return a peer for a given agent_id. @type agent_id str @rtype: Peer """ return self.__peers.get(agent_id) @property def peers(self): """ Return a list of all peers in the domain. @rtype: list[Peer] """ return self.__peers.values() @property def entry_peer(self): """ Return the peer that was used to enter the domain. @rtype: Peer """ return self.__entry_peer def get_database(self, name): """ Return a database by name @type name str @rtype: Database """ return self.__databases.get(name) @property def databases(self): """ Return a list of databases in the domain @rtype: list[Database] """ return self.__databases.values() def create_template(self, template_name, summary, requirements): """Create template by name""" response = self._send_domain_message(**Template.build_create_request(template_name, summary, requirements)) return ElementTree.fromstring(response).tag == Template.success_message def update_template(self, template_name, summary, requirements): """Update template by name""" response = self._send_domain_message(**Template.build_update_request(template_name, summary, requirements)) return ElementTree.fromstring(response).tag == Template.success_message def delete_template(self, template_name): """Delete template by name""" response = self._send_domain_message(**Template.build_delete_request(template_name)) return ElementTree.fromstring(response).tag == Template.success_message def get_template(self, template_name): """Return a template by name""" response = self._send_domain_message(**Template.build_get_request(template_name)) return Template.from_message(response) @property def templates(self): """Return a list of templates in the domain""" response = self._send_domain_message(**Template.build_list_request()) return Template.from_list_message(response) def create_description(self, name, template_name, variables, dba_user, dba_password): response = self._send_domain_message(**Description.build_create_request(name, template_name, variables, dba_user, dba_password)) return ElementTree.fromstring(response).tag == Description.success_message def update_description(self, name, template_name, variables): response = self._send_domain_message(**Description.build_update_request(name, template_name, variables)) return ElementTree.fromstring(response).tag == Description.success_message def delete_description(self, name): response = self._send_domain_message(**Description.build_delete_request(name)) return ElementTree.fromstring(response).tag == Description.success_message def get_description(self, name): response = self._send_domain_message(**Description.build_get_request(name)) return Description.from_message(response) def start_description(self, name): response = self._send_domain_message(**Description.build_start_request(name)) return ElementTree.fromstring(response).tag == Description.success_message def stop_description(self, name): response = self._send_domain_message(**Description.build_stop_request(name)) return ElementTree.fromstring(response).tag == Description.success_message @property def descriptions(self): response = self._send_domain_message(**Description.build_list_request()) return Description.from_list_message(response) def shutdown(self, graceful=True): """Shutdown all databases in the domain. graceful -- (default True) means that the database will first be quiesced and then shutdown. """ for database in self.__databases.itervalues(): database.shutdown(graceful) def message_received(self, root): """Process a management message from the broker. Override from session.BaseListener. """ if root.tag == "Event": event_type = root.get("Type") if event_type == "NewBroker": self.__peer_joined(Peer.from_message(self, root.find("Broker"))) elif event_type == "BrokerExit": self.__peer_left(Peer.from_message(self, root.find("Broker"))) elif event_type == "StatusChanged": status = root.get("Status") process_element = root.find("Process") db = self.__databases[process_element.get("Database")] process = Process.from_message(db, process_element) self.__process_status_changed(process, status) elif event_type == "ProcessFailed": peer = Peer.from_message(self, root.find("Broker")) peer = self.get_peer(peer.id) reason = root.get("Reason") start_id = root.get("StartId") self.__process_failed(peer, start_id, reason) elif event_type == "NewProcess" or event_type == "ProcessExit": process_element = root.find("Process") db_name = process_element.get("Database") if db_name not in self.__databases: self.__databases[db_name] = Database(self, db_name) if self.__listener: try: self.__listener.database_joined(self.__databases[db_name]) except AttributeError: pass if event_type == "NewProcess": start_id = process_element.get("StartId") self.__process_joined(Process.from_message(self.__databases[db_name], process_element), start_id) else: self.__process_left(Process.from_message(self.__databases[db_name], process_element)) def closed(self): """Called when the session is closed. Override from session.BaseListener. """ if self.__listener: try: self.__listener.closed() except AttributeError: pass def __handle_status(self, message): """Handle initial domain status on domain connection. Note that this is ONLY for processing the initial status message. All further update messages are processed by message_received().""" root = ElementTree.fromstring(message) if root.tag != "Status": raise Exception("Expected status message; got " + root.tag) self.__domain_name = root.get("Domain") self.__entry_peer = Peer(self, self.__session.address, root.get("AgentId"), (root.get("Role") == "Broker"), self.__session.port, root.get("Hostname"), root.get("Version")) self.__peer_joined(self.__entry_peer) for child in list(root): if child.tag == "Broker": self.__peer_joined(Peer.from_message(self, child)) for child in list(root): if child.tag == "Database": name = child.get("Name") if self.__listener: try: self.__listener.database_joined(self.__databases[name]) except AttributeError: pass for process_element in list(child): if process_element.tag == "Process": if name not in self.__databases: self.__databases[name] = Database(self, name) self.__process_joined(Process.from_message(self.__databases[name], process_element), None) def __peer_joined(self, peer): """Called when a peer joins the domain.""" self.__peers[peer.id] = peer if self.__listener: try: self.__listener.peer_joined(peer) except AttributeError: pass def __peer_left(self, peer): """Called when a peer leaves the domain.""" del self.__peers[peer.id] if self.__listener: try: self.__listener.peer_left(peer) except AttributeError: pass def __process_joined(self, process, start_id): """Called when a process joins the domain.""" process.database._add_process(process) process.peer._notify_start_id(start_id, process) if self.__listener: try: self.__listener.process_joined(process) except AttributeError: pass def __process_left(self, process): """Called when a process leaves the domain.""" database = process.database database._remove_process(process) process.peer._remove_process(process) if self.__listener: try: self.__listener.process_left(process) except AttributeError: pass if len(database.processes) == 0: del self.__databases[database.name] if self.__listener: try: self.__listener.database_left(database) except AttributeError: pass def __process_failed(self, peer, start_id, reason): """Called when a process in the domain fails.""" peer._notify_start_id(start_id, reason) if self.__listener: try: self.__listener.process_failed(peer, reason) except AttributeError: pass def __process_status_changed(self, process, status): """Called when a process in the domain changes status.""" process._set_status(status) if self.__listener: try: self.__listener.process_status_changed(process, status) except AttributeError: pass def _send_management_message(self, message, peer, process): """Send a management message. Note that this is an initial verison only to support the shutdown routine that doesn't need to watch for return messages ... right now this module is only supporting the tests, which don't need the other management routines at this point, so we'll flesh this out (as in the Java implementation) in the second round when other utilites get updated as well """ root = ElementTree.fromstring("<ManagementRequest AgentId=\"%s\" ProcessId=\"%i\"/>" % (peer.id, process.pid)) root.append(message) self.__session.send(ElementTree.tostring(root))
class Domain(BaseListener): def __init__(self, brokerAddr, domainUser, domainPwd, listener=None): if not domainPwd: raise Exception("A password is required to join a domain") self.__session = Session(brokerAddr, service="Monitor") self.__session.authorize(domainUser, domainPwd) self.__user = domainUser self.__password = domainPwd self.__listener = listener self.__peers = dict() self.__databases = dict() self.__monitor = SessionMonitor(self.__session, self) try: self.__session.doConnect() self.__handleStatus(self.__session.recv()) except Exception: self.__monitor.close() raise self.__monitor.start() def __str__(self): return self.getDomainName() + " [Entered through: " + self.getEntryPeer().getConnectStr() + "]" def disconnect(self): self.__monitor.close() def getUser(self): return self.__user def getPassword(self): return self.__password def getDomainName(self): return self.__domainName def getPeer(self, agentId): return self.__peers.get(agentId) def getPeers(self): return self.__peers.itervalues() def getEntryPeer(self): return self.__entryPeer def getDatabase(self, name): return self.__databases.get(name) def getDatabases(self): return self.__databases.itervalues() def getDatabaseCount(self): return len(self.__databases) def shutdown(self, graceful=True): for (dbName, db) in self.__databases.items(): db.shutdown(graceful) def messageReceived(self, root): if root.tag == "Event": eventType = root.get("Type") if eventType == "NewBroker": self.__peerJoined(Peer.fromMessage(self, root.find("Broker"))) elif eventType == "BrokerExit": self.__peerLeft(Peer.fromMessage(self, root.find("Broker"))) elif eventType == "StatusChanged": status = root.get("Status") processElement = root.find("Process") db = self.__databases[processElement.get("Database")] process = Process.fromMessage(db, processElement) self.__processStatusChanged(process, status) elif eventType == "ProcessFailed": peer = Peer.fromMessage(self, root.find("Broker")) peer = self.getPeer(peer.getId()) reason = root.get("Reason") startId = root.get("StartId") self.__processFailed(peer, startId, reason) elif eventType == "NewProcess" or eventType == "ProcessExit": processElement = root.find("Process") dbName = processElement.get("Database") if dbName not in self.__databases: self.__databases[dbName] = Database(self, dbName) if self.__listener: try: self.__listener.databaseJoined(self.__databases[dbName]) except: pass if eventType == "NewProcess": startId = processElement.get("StartId") self.__processJoined(Process.fromMessage(self.__databases[dbName], processElement), startId) else: self.__processLeft(Process.fromMessage(self.__databases[dbName], processElement)) def closed(self): if self.__listener: try: self.__listener.closed() except: pass # NOTE: this is the status provided on initial broker-connection, and not # per-process status updates def __handleStatus(self, message): root = ElementTree.fromstring(message) if root.tag != "Status": raise Exception("Expected status message; got " + root.tag) self.__domainName = root.get("Domain") self.__entryPeer = Peer( self, self.__session.getAddress(), root.get("AgentId"), (root.get("Role") == "Broker"), self.__session.getPort(), root.get("Hostname"), root.get("Version"), ) self.__peerJoined(self.__entryPeer) for child in list(root): if child.tag == "Broker": self.__peerJoined(Peer.fromMessage(self, child)) for child in list(root): if child.tag == "Database": name = child.get("Name") if self.__listener: try: self.__listener.databaseJoined(self.__databases[name]) except: pass for processElement in list(child): if processElement.tag == "Process": if name not in self.__databases: self.__databases[name] = Database(self, name) self.__processJoined(Process.fromMessage(self.__databases[name], processElement), None) def __peerJoined(self, peer): self.__peers[peer.getId()] = peer if self.__listener: try: self.__listener.peerJoined(peer) except: pass def __peerLeft(self, peer): del self.__peers[peer.getId()] if self.__listener: try: self.__listener.peerLeft(peer) except: pass def __processJoined(self, process, startId): process.getDatabase()._addProcess(process) process.getPeer()._notifyStartId(startId, process) if self.__listener: try: self.__listener.processJoined(process) except: pass def __processLeft(self, process): database = process.getDatabase() database._removeProcess(process) process.getPeer()._removeProcess(process) if self.__listener: try: self.__listener.processLeft(process) except: pass if database.getProcessCount() == 0: del self.__databases[database.getName()] if self.__listener: try: self.__listener.databaseLeft(database) except: pass def __processFailed(self, peer, startId, reason): peer._notifyStartId(startId, reason) if self.__listener: try: self.__listener.processFailed(peer, reason) except: pass def __processStatusChanged(self, process, status): process._setStatus(status) if self.__listener: try: self.__listener.processStatusChanged(process, status) except: pass # an initial verison only to support the shutdown routine that doesn't # need to watch for return messages ... right now this module is only # supporting the tests, which don't need the other management routines # at this point, so we'll flesh this out (as in the Java implementation) # in the second round when other utilites get updated as well def _sendManagementMessage(self, message, peer, process): root = ElementTree.fromstring( '<ManagementRequest AgentId="%s" ProcessId="%i"/>' % (peer.getId(), process.getPid()) ) root.append(message) self.__session.send(ElementTree.tostring(root))