コード例 #1
0
ファイル: pool_manager.py プロジェクト: mhdhaque/indy-plenum
    def __init__(self, node, ha=None, cliname=None, cliha=None):
        self.node = node
        self.name = node.name
        self.config = node.config
        self.genesis_dir = node.genesis_dir
        self.keys_dir = node.keys_dir
        self._ledger = None
        self._id = None

        TxnStackManager.__init__(self,
                                 self.name,
                                 node.genesis_dir,
                                 node.keys_dir,
                                 isNode=True)
        self.state = self.loadState()
        self.reqHandler = self.getPoolReqHandler()
        self.initPoolState()
        self._load_nodes_order_from_ledger()
        self.nstack, self.cstack, self.nodeReg, self.cliNodeReg = \
            self.getStackParamsAndNodeReg(self.name, self.keys_dir, ha=ha,
                                          cliname=cliname, cliha=cliha)

        self._dataFieldsValidators = (
            (NODE_IP, self._isIpAddressValid),
            (CLIENT_IP, self._isIpAddressValid),
            (NODE_PORT, self._isPortValid),
            (CLIENT_PORT, self._isPortValid),
        )
コード例 #2
0
 def __init__(self, node, ha=None, cliname=None, cliha=None):
     self.node = node
     self.name = node.name
     self.config = node.config
     self.basedirpath = node.basedirpath
     self._ledger = None
     TxnStackManager.__init__(self, self.name, self.basedirpath, isNode=True)
     self.nstack, self.cstack, self.nodeReg, self.cliNodeReg = \
         self.getStackParamsAndNodeReg(self.name, self.basedirpath, ha=ha,
                                       cliname=cliname, cliha=cliha)
コード例 #3
0
ファイル: pool_manager.py プロジェクト: zmh0531/indy-plenum
 def __init__(self):
     self._ledgerFile = None
     TxnStackManager.__init__(self, self.name, self.genesis_dir, self.keys_dir,
                              isNode=False)
     _, cliNodeReg, nodeKeys = self.parseLedgerForHaAndKeys(self.ledger)
     self.nodeReg = cliNodeReg
     self.addRemoteKeysFromLedger(nodeKeys)
     # Temporary place for keeping node transactions while this client is
     # discovering. Key is sequence number and value is dictionary where key
     # is the name of the node and value is the transaction. Transaction
     # should be applied in increasing order of sequence numbers.
     self.tempNodeTxns = {}  # type: Dict[int, Dict[str, Dict]]
コード例 #4
0
ファイル: pool_manager.py プロジェクト: evernym/plenum
 def __init__(self):
     self._ledgerFile = None
     self._ledgerLocation = None
     TxnStackManager.__init__(self, self.name, self.basedirpath,
                              isNode=False)
     _, cliNodeReg, nodeKeys = self.parseLedgerForHaAndKeys(self.ledger)
     self.nodeReg = cliNodeReg
     self.addRemoteKeysFromLedger(nodeKeys)
     # Temporary place for keeping node transactions while this client is
     # discovering. Key is sequence number and value is dictionary where key
     # is the name of the node and value is the transaction. Transaction
     # should be applied in increasing order of sequence numbers.
     self.tempNodeTxns = {}  # type: Dict[int, Dict[str, Dict]]
コード例 #5
0
def migrate_all():
    node_name = get_node_name()
    if node_name is None:
        logger.error("Could not get node name")
        return False

    ledger = get_pool_ledger(node_name)
    nodeReg, _, _ = TxnStackManager.parseLedgerForHaAndKeys(ledger)

    if nodeReg is None:
        logger.error("Empty node registry returned by stack manager")
        return False

    if node_name not in nodeReg:
        logger.error("Node registry does not contain node {}".format(node_name))
        return False

    ha = nodeReg[node_name]
    if ha is None:
        logger.error("Empty HA for node {}".format(node_name))
        return False

    logger.info("HA for {}: {}".format(node_name, ha))

    try:
        append_ips_to_env(ha.host)
    except Exception:
        logger.error(traceback.print_exc())
        logger.error("Could not append node and client IPs to indy env file")
        return False

    return True
コード例 #6
0
ファイル: pool_manager.py プロジェクト: mhdhaque/indy-plenum
    def nodeServicesChanged(self, txn):
        nodeNym = txn[TARGET_NYM]
        _, nodeInfo = self.getNodeInfoFromLedger(nodeNym)
        nodeName = nodeInfo[DATA][ALIAS]
        oldServices = set(nodeInfo[DATA].get(SERVICES, []))
        newServices = set(txn[DATA].get(SERVICES, []))
        if oldServices == newServices:
            logger.debug(
                "Node {} not changing {} since it is same as existing".format(
                    nodeNym, SERVICES))
            return
        else:
            if self.name != nodeName:
                if VALIDATOR in newServices.difference(oldServices):
                    # If validator service is enabled
                    self.updateNodeTxns(nodeInfo, txn)
                    self.connectNewRemote(nodeInfo, nodeName, self.node)
                    self.node.nodeJoined(txn)

                if VALIDATOR in oldServices.difference(newServices):
                    # If validator service is disabled
                    del self.node.nodeReg[nodeName]
                    del self.node.cliNodeReg[nodeName + CLIENT_STACK_SUFFIX]
                    try:
                        rid = TxnStackManager.removeRemote(
                            self.node.nodestack, nodeName)
                        if rid:
                            self.node.nodestack.outBoxes.pop(rid, None)
                    except RemoteNotFound:
                        logger.debug(
                            '{} did not find remote {} to remove'.format(
                                self, nodeName))

                    self.node.nodeLeft(txn)
                    self.node_about_to_be_disconnected(nodeName)
コード例 #7
0
ファイル: pool_manager.py プロジェクト: zmh0531/indy-plenum
    def nodeServicesChanged(self, txn_data):
        nodeNym = txn_data[TARGET_NYM]
        _, nodeInfo = self.getNodeInfoFromLedger(nodeNym)
        remoteName = nodeInfo[DATA][ALIAS] + CLIENT_STACK_SUFFIX
        oldServices = set(nodeInfo[DATA].get(SERVICES, []))
        newServices = set(txn_data[DATA].get(SERVICES, []))
        if oldServices == newServices:
            logger.debug(
                "Client {} not changing {} since it is same as existing"
                .format(nodeNym, SERVICES))
            return
        else:
            if VALIDATOR in newServices.difference(oldServices):
                # If validator service is enabled
                self.updateNodeTxns(nodeInfo, txn_data)
                self.connectNewRemote(nodeInfo, remoteName, self)

            if VALIDATOR in oldServices.difference(newServices):
                # If validator service is disabled
                del self.nodeReg[remoteName]
                try:
                    rid = TxnStackManager.removeRemote(
                        self.nodestack, remoteName)
                    if rid:
                        self.nodestack.outBoxes.pop(rid, None)
                except RemoteNotFound:
                    logger.info('{} did not find remote {} to remove'.format(self, remoteName))
コード例 #8
0
def test_parse_non_base58_txn_type_field_raises_descriptive_error(
        tdirWithLedger, tdir):
    with pytest.raises(ValueError) as excinfo:
        ledger = Ledger(CompactMerkleTree(), dataDir=tdir)
        _, _, nodeKeys = TxnStackManager.parseLedgerForHaAndKeys(ledger)
    assert ("verkey" in str(excinfo.value))
    ledger.stop()
コード例 #9
0
def test_pool_file_is_invalid_raises_SystemExit_has_descriptive_error(
        tdir_for_func):
    """
    Test that that invalid pool_transaction file raises the proper exception (INDY-150)
    """
    ledger = DummyLedger(CompactMerkleTree(), dataDir=tdir_for_func)
    with pytest.raises(SystemExit) as excinfo:
        _, _, nodeKeys = TxnStackManager.parseLedgerForHaAndKeys(ledger)
    assert excinfo.value.code == errMsg
    ledger.stop()
コード例 #10
0
def test_parse_identifier_non_base58_txn_type_field_raises_SystemExit_has_descriptive_error(
        invalid_identifier_tdir, tdir_for_func):
    """
    Test that invalid base58 IDENTIFIER in pool_transaction raises the proper exception (INDY-150)
    """
    with pytest.raises(SystemExit) as excinfo:
        ledger = Ledger(CompactMerkleTree(), dataDir=tdir_for_func)
        _, _, nodeKeys = TxnStackManager.parseLedgerForHaAndKeys(ledger)
    assert excinfo.value.code == errMsg2
    ledger.stop()
コード例 #11
0
def test_parse_verkey_non_base58_txn_type_field_raises_SystemExit_has_descriptive_error(
        invalid_verkey_tdir, tdir_for_func):
    """
    Test that invalid base58 TARGET_NYM in pool_transaction raises the proper exception (INDY-150)
    """
    with pytest.raises(SystemExit) as excinfo:
        ledger = Ledger(CompactMerkleTree(), dataDir=tdir_for_func)
        _, _, nodeKeys = TxnStackManager.parseLedgerForHaAndKeys(ledger)
    assert excinfo.value.code == 'Invalid verkey. Rebuild pool transactions.'
    ledger.stop()
コード例 #12
0
    def nodeServicesChanged(self, txn_data) -> bool:
        nodeNym = txn_data[TARGET_NYM]
        nodeName = self.getNodeName(nodeNym)
        oldServices = set(self._ordered_node_services.get(nodeNym, []))
        newServices = set(txn_data[DATA].get(SERVICES, []))
        if oldServices == newServices:
            logger.info(
                "Node {} not changing {} since it is same as existing".format(
                    nodeNym, SERVICES))
            return False

        node_count_changed = False
        if VALIDATOR in newServices.difference(oldServices):
            node_count_changed = True
            # If validator service is enabled
            node_info = self.write_manager.get_node_data(nodeNym)
            self.node.nodeReg[nodeName] = HA(node_info[NODE_IP],
                                             node_info[NODE_PORT])
            self.node.cliNodeReg[nodeName + CLIENT_STACK_SUFFIX] = HA(
                node_info[CLIENT_IP], node_info[CLIENT_PORT])

            self.updateNodeTxns({
                DATA: node_info,
            }, txn_data)

            if self.name != nodeName:
                self.connectNewRemote({
                    DATA: node_info,
                    TARGET_NYM: nodeNym
                }, nodeName, self.node)
            else:
                logger.debug("{} adding itself to node registry".format(
                    self.name))

        if VALIDATOR in oldServices.difference(newServices):
            node_count_changed = True
            # If validator service is disabled
            del self.node.nodeReg[nodeName]
            del self.node.cliNodeReg[nodeName + CLIENT_STACK_SUFFIX]

            if self.name != nodeName:
                try:
                    rid = TxnStackManager.removeRemote(self.node.nodestack,
                                                       nodeName)
                    if rid:
                        self.node.nodestack.outBoxes.pop(rid, None)
                except RemoteNotFound:
                    logger.info('{} did not find remote {} to remove'.format(
                        self, nodeName))
                self.node_about_to_be_disconnected(nodeName)

        return node_count_changed
コード例 #13
0
    def __init__(self, node, ledger, state, reqHandler, ha=None, cliname=None, cliha=None):
        self.node = node
        self.name = node.name
        self.config = node.config
        self.genesis_dir = node.genesis_dir
        self.keys_dir = node.keys_dir
        self.ledger = ledger
        self._id = None

        TxnStackManager.__init__(
            self, self.name, node.keys_dir, isNode=True)
        self.state = state
        self.reqHandler = reqHandler
        self._load_nodes_order_from_ledger()
        self.nstack, self.cstack, self.nodeReg, self.cliNodeReg = \
            self.getStackParamsAndNodeReg(self.name, self.keys_dir, ha=ha,
                                          cliname=cliname, cliha=cliha)

        self._dataFieldsValidators = (
            (NODE_IP, self._isIpAddressValid),
            (CLIENT_IP, self._isIpAddressValid),
            (NODE_PORT, self._isPortValid),
            (CLIENT_PORT, self._isPortValid),
        )
コード例 #14
0
    def nodeServicesChanged(self, txn_data):
        nodeNym = txn_data[TARGET_NYM]
        nodeName = self.getNodeName(nodeNym)
        oldServices = set(self._ordered_node_services.get(nodeNym, []))
        newServices = set(txn_data[DATA].get(SERVICES, []))
        if oldServices == newServices:
            logger.info("Node {} not changing {} since it is same as existing".format(nodeNym, SERVICES))
            return
        else:
            if VALIDATOR in newServices.difference(oldServices):
                # If validator service is enabled
                node_info = self.reqHandler.getNodeData(nodeNym)
                self.node.nodeReg[nodeName] = HA(node_info[NODE_IP],
                                                 node_info[NODE_PORT])
                self.node.cliNodeReg[nodeName + CLIENT_STACK_SUFFIX] = HA(node_info[CLIENT_IP],
                                                                          node_info[CLIENT_PORT])

                self.updateNodeTxns({DATA: node_info, }, txn_data)
                self.node.nodeJoined(txn_data)

                if self.name != nodeName:
                    self.connectNewRemote({DATA: node_info,
                                           TARGET_NYM: nodeNym}, nodeName, self.node)

            if VALIDATOR in oldServices.difference(newServices):
                # If validator service is disabled
                del self.node.nodeReg[nodeName]
                del self.node.cliNodeReg[nodeName + CLIENT_STACK_SUFFIX]
                self.node.nodeLeft(txn_data)

                if self.name != nodeName:
                    try:
                        rid = TxnStackManager.removeRemote(
                            self.node.nodestack, nodeName)
                        if rid:
                            self.node.nodestack.outBoxes.pop(rid, None)
                    except RemoteNotFound:
                        logger.info('{} did not find remote {} to remove'.format(self, nodeName))
                    self.node_about_to_be_disconnected(nodeName)