Python Session.authorize方法代码示例

# 需要导入模块: from session import Session [as 别名]
# 或者: from session.Session import authorize [as 别名]
def killProcess(agent, user, password, pid):
    s = Session(agent, service="ProcessStop")
    s.authorize(user, password)

    response = s.doRequest(attributes={"PID" : str(pid)})

    return int(ElementTree.fromstring(response).get("ExitCode"))

# 需要导入模块: from session import Session [as 别名]
# 或者: from session.Session import authorize [as 别名]
def stopProcess(address, port, dbPassword):
    s = Session(address, port=port, service="Monitor")
    s.authorize("Cloud", dbPassword)
    s.doConnect()

    s.send("<Request Action=\"shutdown\"/>")

    s.close()

# 需要导入模块: from session import Session [as 别名]
# 或者: from session.Session import authorize [as 别名]
    def query(self, type, msgBody=None):
        s = Session(self.getPeer().getConnectStr(), service="Manager")
        s.authorize(self.getPeer().getDomain().getUser(), self.getPeer().getDomain().getPassword())
        pwdResponse = s.doRequest(attributes={"Type": "GetDatabaseCredentials", "Database": self.getDbName()})

        pwdXml = ElementTree.fromstring(pwdResponse)
        pwd = pwdXml.find("Password").text.strip()

        return queryEngine(self.getAddress(), self.getPort(), type, pwd, msgBody)

# 需要导入模块: from session import Session [as 别名]
# 或者: from session.Session import authorize [as 别名]
    def query(self, query_type, msg_body=None):
        session = Session(self.peer.connect_str, service="Manager")
        session.authorize(self.peer.domain.user, self.peer.domain.password)
        pwd_response = session.doRequest(attributes={"Type": "GetDatabaseCredentials", "Database": self.database.name})

        pwd_xml = ElementTree.fromstring(pwd_response)
        pwd = pwd_xml.find("Password").text.strip()

        return queryEngine(self.address, self.port, query_type, pwd, msg_body)

# 需要导入模块: from session import Session [as 别名]
# 或者: from session.Session import authorize [as 别名]
def doDatabaseAction(broker, user, password, db_name, action, child=None):
    s = Session(broker, service="ChorusManagement")
    s.authorize(user, password)

    if child is not None:
        child = [ child ]
    s.doConnect(attributes={"Database" : db_name, "Action" : action}, children=child)
    response = s.recv()
    checkForError(response)

    s.close()

    return response

# 需要导入模块: from session import Session [as 别名]
# 或者: from session.Session import authorize [as 别名]
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)

# 需要导入模块: from session import Session [as 别名]
# 或者: from session.Session import authorize [as 别名]
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

# 需要导入模块: from session import Session [as 别名]
# 或者: from session.Session import authorize [as 别名]
def getArchiveHistory(agent, user, password, archive, options=None):
    s = Session(agent, service="ProcessStart")
    s.authorize(user, password)

    option = _OPTION_VALUE_STR % ("--archive", archive)
    opts = [ ElementTree.fromstring(option) ]

    if options:
        for (k,v) in options:
            if v:
                option = _OPTION_VALUE_STR % (k, v)
            else:
                option = _OPTION_FLAG_STR % k
            opts.append(ElementTree.fromstring(option))

    return s.doRequest(attributes={"Process" : "archiveHistory"}, children=opts)

# 需要导入模块: from session import Session [as 别名]
# 或者: from session.Session import authorize [as 别名]
def startProcess(agent, user, password, db_name, options=None):
    s = Session(agent, service="ProcessStart")
    s.authorize(user, password)

    if not options:
        options = []

    options.append(("--database", db_name))

    opts = []
    for (k,v) in options:
        if v:
            optStr = _OPTION_VALUE_STR % (k, v)
        else:
            optStr = _OPTION_FLAG_STR % k
        opts.append(ElementTree.fromstring(optStr))

    return s.doRequest(attributes={"Process" : "server"}, children=opts)

# 需要导入模块: from session import Session [as 别名]
# 或者: from session.Session import authorize [as 别名]
def queryEngine(address, port, target, dbPassword, msgBody=None):
    s = Session(address, port=port, service="Query")
    s.authorize("Cloud", dbPassword)
    s.doConnect()

    msg = "<Query Target=\"%s\"/>" % target
    if msgBody is not None:
        xml = ElementTree.fromstring(msg)
        xml.append(msgBody)
        msg = ElementTree.tostring(xml)

    s.send(msg)
    response = s.recv()

    checkForError(response)

    s.close()

    return response

# 需要导入模块: from session import Session [as 别名]
# 或者: from session.Session import authorize [as 别名]
    def find_peer(self, address, port=None):
        """
        Find a peer by address
        @type: address str
        @type: port int or str
        @rtype: Peer
        """
        if port is None:
            if ":" in address:
                address, port = address.split(":", 2)
            else:
                port = self.__entry_peer.port
        else:
            if ":" in address:
                address, _ = address.split(":", 2)

        ip = socket.gethostbyname(address)
        inet_sock_addr = ":".join([ip, str(port)])
        try:
            return self.__peers_by_addr[inet_sock_addr]
        except:
            pass

        session = Session(address, port=port, service="Identity")
        session.authorize(self.__user, self.__password)
        response = session.doRequest()
        try:
            root = ElementTree.fromstring(response)
            if self.__domain_name != root.get("Domain"):
                return None
            peer = self.get_peer(root.get("AgentId"))
            if peer:
                self.__peers_by_addr[peer._get_normalized_addr()] = peer
            return peer
        except:
            return None

# 需要导入模块: from session import Session [as 别名]
# 或者: from session.Session import authorize [as 别名]
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)
#.........这里部分代码省略.........

# 需要导入模块: from session import Session [as 别名]
# 或者: from session.Session import authorize [as 别名]
def getState(broker, user, password):
    s = Session(broker, service="State")
    s.authorize(user, password)
    
    return s.doRequest()

# 需要导入模块: from session import Session [as 别名]
# 或者: from session.Session import authorize [as 别名]
def setLicense(broker, user, password, licenseText):
    s = Session(broker, service="License")
    s.authorize(user, password)

    s.doRequest(attributes={ "Action" : "ApplyLicense" }, text=licenseText)

# 需要导入模块: from session import Session [as 别名]
# 或者: from session.Session import authorize [as 别名]
def getLicense(broker, user, password):
    s = Session(broker, service="License")
    s.authorize(user, password)

    return s.doRequest(attributes={ "Action" : "GetCurrentLicense" })