def testRescheduleUpgradeToLowerVersionThanPreviouslyScheduled(
        looper, tconf, nodeSet, validUpgrade, trustee, trusteeWallet):
    """
    A node starts at version 1.2 running has scheduled upgrade for version 1.5
    but get a txn for upgrade 1.4, it will schedule it and cancel upgrade to 1.5.
    """
    upgr1 = deepcopy(validUpgrade)

    upgr2 = deepcopy(upgr1)
    upgr2[VERSION] = bumpVersion(upgr1[VERSION])
    upgr2[NAME] += randomString(3)
    # upgr2[SHA256] = get_valid_code_hash()
    upgr2[SHA256] = 'ef9c3984e7a31994d4f692139116120bd0dd1ff7e270b6a2d773f8f2f9214d4c'

    # An upgrade for higher version scheduled, it should pass
    ensureUpgradeSent(looper, trustee, trusteeWallet, upgr2)
    looper.run(
        eventually(
            checkUpgradeScheduled,
            nodeSet,
            upgr2[VERSION],
            retryWait=1,
            timeout=waits.expectedUpgradeScheduled()))

    # An upgrade for lower version scheduled, the transaction should pass and
    # the upgrade should be scheduled
    ensureUpgradeSent(looper, trustee, trusteeWallet, upgr1)
    looper.run(
        eventually(
            checkUpgradeScheduled,
            nodeSet,
            upgr1[VERSION],
            retryWait=1,
            timeout=waits.expectedUpgradeScheduled()))
Beispiel #2
0
def testRescheduleUpgradeToLowerVersionThanPreviouslyScheduled(
        looper, tconf, nodeSet, validUpgrade, sdk_pool_handle,
        sdk_wallet_trustee):
    """
    A node starts at version 1.2 running has scheduled upgrade for version 1.5
    but get a txn for upgrade 1.4, it will schedule it and cancel upgrade to 1.5.
    """
    upgr1 = deepcopy(validUpgrade)

    upgr2 = deepcopy(upgr1)
    upgr2[VERSION] = bumpVersion(upgr1[VERSION])
    upgr2[NAME] += randomString(3)
    # upgr2[SHA256] = get_valid_code_hash()
    upgr2[
        SHA256] = 'ef9c3984e7a31994d4f692139116120bd0dd1ff7e270b6a2d773f8f2f9214d4c'

    # An upgrade for higher version scheduled, it should pass
    sdk_ensure_upgrade_sent(looper, sdk_pool_handle, sdk_wallet_trustee, upgr2)
    looper.run(
        eventually(checkUpgradeScheduled,
                   nodeSet,
                   upgr2[VERSION],
                   retryWait=1,
                   timeout=waits.expectedUpgradeScheduled()))

    # An upgrade for lower version scheduled, the transaction should pass and
    # the upgrade should be scheduled
    sdk_ensure_upgrade_sent(looper, sdk_pool_handle, sdk_wallet_trustee, upgr1)
    looper.run(
        eventually(checkUpgradeScheduled,
                   nodeSet,
                   upgr1[VERSION],
                   retryWait=1,
                   timeout=waits.expectedUpgradeScheduled()))
Beispiel #3
0
def test_forced_upgrade_no_consensus_on_single_node(validUpgradeExpForceTrue,
                                                    looper, nodeSet,
                                                    sdk_pool_handle,
                                                    sdk_wallet_trustee):
    nup = validUpgradeExpForceTrue.copy()
    nup.update({VERSION: bumpVersion(validUpgradeExpForceTrue[VERSION])})
    for node in nodeSet:
        if node.name != "Alpha" and node in looper.prodables:
            node.cleanupOnStopping = False
            looper.removeProdable(node)
            node.stop()
        else:
            node.upgrader.scheduledUpgrade = None
    _, did = sdk_wallet_trustee
    req = get_req_from_update(looper, did, nup)
    sdk_sign_and_send_prepared_request(looper, sdk_wallet_trustee,
                                       sdk_pool_handle, req)

    def testsched():
        for node in nodeSet:
            if node.name == "Alpha":
                assert node.upgrader.scheduledAction
                assert node.upgrader.scheduledAction[0] == nup[VERSION]

    looper.run(
        eventually(testsched,
                   retryWait=1,
                   timeout=waits.expectedUpgradeScheduled()))
def test_node_reschedules_upgrade_for_proper_datetime(
        looper, tconf, nodeSet, validUpgrade,
        sdk_pool_handle, sdk_wallet_trustee):
    upgr1 = deepcopy(validUpgrade)
    # Upgrade 1 of each node will be scheduled for tomorrow
    for nodeId in upgr1[SCHEDULE]:
        nodeUpgradeDateTime = dateutil.parser.parse(upgr1[SCHEDULE][nodeId])
        nodeUpgradeDateTime += timedelta(days=1)
        upgr1[SCHEDULE][nodeId] = nodeUpgradeDateTime.isoformat()

    upgr2 = deepcopy(upgr1)
    upgr2[VERSION] = bumpVersion(upgr1[VERSION])
    upgr2[NAME] += randomString(32)
    upgr2[SHA256] = 'ef9c3984e7a31994d4f692139116120bd0dd1ff7e270b6a2d773f8f2f9214d4c'
    # Upgrade 2 of each node will be scheduled for its own day
    # (since today with one day step)
    deltaDays = -1
    for nodeId in upgr2[SCHEDULE]:
        nodeUpgradeDateTime = dateutil.parser.parse(upgr2[SCHEDULE][nodeId])
        nodeUpgradeDateTime += timedelta(days=deltaDays)
        upgr2[SCHEDULE][nodeId] = nodeUpgradeDateTime.isoformat()
        deltaDays += 1

    # Upgrade 1 is scheduled
    sdk_ensure_upgrade_sent(looper, sdk_pool_handle,
                            sdk_wallet_trustee, upgr1)
    looper.run(
        eventually(
            checkUpgradeScheduled,
            nodeSet,
            upgr1[VERSION],
            retryWait=1,
            timeout=waits.expectedUpgradeScheduled()))

    # Upgrade 2 cancels Upgrade 1 and is scheduled itself
    # according its own schedule
    sdk_ensure_upgrade_sent(looper, sdk_pool_handle,
                            sdk_wallet_trustee, upgr2)
    looper.run(
        eventually(
            checkUpgradeScheduled,
            nodeSet,
            upgr2[VERSION],
            upgr2[SCHEDULE],
            retryWait=1,
            timeout=waits.expectedUpgradeScheduled()))
def test_node_reschedules_upgrade_for_proper_datetime(looper, tconf, nodeSet,
                                                      validUpgrade,
                                                      sdk_pool_handle,
                                                      sdk_wallet_trustee):
    upgr1 = deepcopy(validUpgrade)
    # Upgrade 1 of each node will be scheduled for tomorrow
    for nodeId in upgr1[SCHEDULE]:
        nodeUpgradeDateTime = dateutil.parser.parse(upgr1[SCHEDULE][nodeId])
        nodeUpgradeDateTime += timedelta(days=1)
        upgr1[SCHEDULE][nodeId] = nodeUpgradeDateTime.isoformat()

    upgr2 = deepcopy(upgr1)
    upgr2[VERSION] = bumpVersion(upgr1[VERSION])
    upgr2[NAME] += randomString(32)
    upgr2[
        SHA256] = 'ef9c3984e7a31994d4f692139116120bd0dd1ff7e270b6a2d773f8f2f9214d4c'
    # Upgrade 2 of each node will be scheduled for its own day
    # (since today with one day step)
    deltaDays = -1
    for nodeId in upgr2[SCHEDULE]:
        nodeUpgradeDateTime = dateutil.parser.parse(upgr2[SCHEDULE][nodeId])
        nodeUpgradeDateTime += timedelta(days=deltaDays)
        upgr2[SCHEDULE][nodeId] = nodeUpgradeDateTime.isoformat()
        deltaDays += 1

    # Upgrade 1 is scheduled
    sdk_ensure_upgrade_sent(looper, sdk_pool_handle, sdk_wallet_trustee, upgr1)
    looper.run(
        eventually(checkUpgradeScheduled,
                   nodeSet,
                   upgr1[VERSION],
                   retryWait=1,
                   timeout=waits.expectedUpgradeScheduled()))

    # Upgrade 2 cancels Upgrade 1 and is scheduled itself
    # according its own schedule
    sdk_ensure_upgrade_sent(looper, sdk_pool_handle, sdk_wallet_trustee, upgr2)
    looper.run(
        eventually(checkUpgradeScheduled,
                   nodeSet,
                   upgr2[VERSION],
                   upgr2[SCHEDULE],
                   retryWait=1,
                   timeout=waits.expectedUpgradeScheduled()))
def test_forced_upgrade_no_consensus_on_single_node(
        validUpgradeExpForceTrue, looper, nodeSet, trustee, trusteeWallet):
    nup = validUpgradeExpForceTrue.copy()
    nup.update({VERSION: bumpVersion(validUpgradeExpForceTrue[VERSION])})
    for node in nodeSet:
        if node.name != "Alpha":
            node.cleanupOnStopping = False
            looper.removeProdable(node)
            node.stop()
        else:
            node.upgrader.scheduledUpgrade = None
    sendUpgrade(trustee, trusteeWallet, nup)

    def testsched():
        for node in nodeSet:
            if node.name == "Alpha":
                assert node.upgrader.scheduledUpgrade
                assert node.upgrader.scheduledUpgrade[0] == nup[VERSION]

    looper.run(eventually(testsched, retryWait=1,
                          timeout=waits.expectedUpgradeScheduled()))
Beispiel #7
0
def testForcedUpgradeNoConsensusOnSingleNode(validUpgradeExpForceTrue, looper,
                                             nodeSet, trustee, trusteeWallet):
    nup = validUpgradeExpForceTrue.copy()
    nup.update({VERSION: bumpVersion(validUpgradeExpForceTrue[VERSION])})
    for node in nodeSet:
        if node.name != "Alpha":
            node.cleanupOnStopping = False
            looper.removeProdable(node)
            node.stop()
        else:
            node.upgrader.scheduledUpgrade = None
    sendUpgrade(trustee, trusteeWallet, nup)

    def testsched():
        for node in nodeSet:
            if node.name == "Alpha":
                assert node.upgrader.scheduledUpgrade
                assert node.upgrader.scheduledUpgrade[0] == nup[VERSION]

    looper.run(
        eventually(testsched,
                   retryWait=1,
                   timeout=waits.expectedUpgradeScheduled()))
def test_forced_upgrade_no_consensus_on_single_node(
        validUpgradeExpForceTrue, looper, nodeSet, sdk_pool_handle, sdk_wallet_trustee):
    nup = validUpgradeExpForceTrue.copy()
    nup.update({VERSION: bumpVersion(validUpgradeExpForceTrue[VERSION])})
    for node in nodeSet:
        if node.name != "Alpha":
            node.cleanupOnStopping = False
            looper.removeProdable(node)
            node.stop()
        else:
            node.upgrader.scheduledUpgrade = None
    _, did = sdk_wallet_trustee
    req = get_req_from_update(looper, did, nup)
    sdk_sign_and_send_prepared_request(looper, sdk_wallet_trustee, sdk_pool_handle, req)

    def testsched():
        for node in nodeSet:
            if node.name == "Alpha":
                assert node.upgrader.scheduledAction
                assert node.upgrader.scheduledAction[0] == nup[VERSION]

    looper.run(eventually(testsched, retryWait=1,
                          timeout=waits.expectedUpgradeScheduled()))
Beispiel #9
0
def validUpgradeExpForceTrue(validUpgradeExpForceFalse):
    nup = validUpgradeExpForceFalse.copy()
    nup.update({FORCE: True})
    nup.update({VERSION: bumpVersion(validUpgradeExpForceFalse[VERSION])})
    return nup
def testUpgradeLatestUncancelledVersion(looper, txnPoolNodeSet, tconf,
                                        nodeThetaAdded, validUpgrade, trustee,
                                        trusteeWallet, tdirWithPoolTxns,
                                        allPluginsPath):
    """
    A node starts and finds several upgrades but selects the latest one which
    is not cancelled, eg node is on version 1.2 but finds 1.3, 1.4 and 1.5 but
    since 1.5 is cancelled, it selects 1.4
    """
    nodeSet = txnPoolNodeSet
    newSteward, newStewardWallet, newNode = nodeThetaAdded
    for node in nodeSet[:-1]:
        node.nodestack.removeRemoteByName(newNode.nodestack.name)
        newNode.nodestack.removeRemoteByName(node.nodestack.name)
    newNode.stop()
    nodeSet = nodeSet[:-1]
    looper.removeProdable(newNode)

    upgr1 = deepcopy(validUpgrade)

    upgr2 = deepcopy(upgr1)
    upgr2[VERSION] = bumpVersion(upgr1[VERSION])
    upgr2[NAME] += randomString(3)
    # upgr2[SHA256] = get_valid_code_hash()
    upgr2[
        SHA256] = 'db34a72a90d026dae49c3b3f0436c8d3963476c77468ad955845a1ccf7b03f55'

    upgr3 = deepcopy(upgr2)
    upgr3[VERSION] = bumpVersion(upgr2[VERSION])
    upgr3[NAME] += randomString(3)
    # upgr3[SHA256] = get_valid_code_hash()
    upgr3[
        SHA256] = '112c060527e8cecfafe64dcb5bdabc4010cc7b64e0bf9bc2a43d23c37d927128'

    upgr4 = deepcopy(upgr3)
    upgr4[ACTION] = CANCEL

    ensureUpgradeSent(looper, trustee, trusteeWallet, upgr1)
    looper.run(
        eventually(checkUpgradeScheduled,
                   nodeSet[:-1],
                   upgr1[VERSION],
                   retryWait=1,
                   timeout=waits.expectedUpgradeScheduled()))

    ensureUpgradeSent(looper, trustee, trusteeWallet, upgr2)
    looper.run(
        eventually(checkUpgradeScheduled,
                   nodeSet[:-1],
                   upgr2[VERSION],
                   retryWait=1,
                   timeout=waits.expectedUpgradeScheduled()))

    ensureUpgradeSent(looper, trustee, trusteeWallet, upgr3)
    looper.run(
        eventually(checkUpgradeScheduled,
                   nodeSet[:-1],
                   upgr3[VERSION],
                   retryWait=1,
                   timeout=waits.expectedUpgradeScheduled()))

    ensureUpgradeSent(looper, trustee, trusteeWallet, upgr4)
    looper.run(
        eventually(checkUpgradeScheduled,
                   nodeSet[:-1],
                   upgr2[VERSION],
                   retryWait=1,
                   timeout=waits.expectedUpgradeScheduled()))

    trustee.stopRetrying()

    newNode = TestNode(newNode.name,
                       basedirpath=tdirWithPoolTxns,
                       base_data_dir=tdirWithPoolTxns,
                       config=tconf,
                       pluginPaths=allPluginsPath,
                       ha=newNode.nodestack.ha,
                       cliha=newNode.clientstack.ha)
    looper.add(newNode)
    nodeSet.append(newNode)
    looper.run(checkNodesConnected(nodeSet))

    looper.run(
        eventually(checkUpgradeScheduled, [
            newNode,
        ],
                   upgr2[VERSION],
                   retryWait=1,
                   timeout=waits.expectedUpgradeScheduled()))
Beispiel #11
0
def validUpgradeExpForceTrue(validUpgradeExpForceFalse):
    nup = validUpgradeExpForceFalse.copy()
    nup.update({FORCE: True})
    nup.update({VERSION: bumpVersion(validUpgradeExpForceFalse[VERSION])})
    return nup
def testUpgradeLatestUncancelledVersion(looper,
                                        txnPoolNodeSet, tconf, sdk_node_theta_added,
                                        validUpgrade, sdk_pool_handle, sdk_wallet_trustee,
                                        tdirWithPoolTxns, allPluginsPath):
    """
    A node starts and finds several upgrades but selects the latest one which
    is not cancelled, eg node is on version 1.2 but finds 1.3, 1.4 and 1.5 but
    since 1.5 is cancelled, it selects 1.4
    """
    nodeSet = txnPoolNodeSet
    _, newNode = sdk_node_theta_added
    for node in nodeSet[:-1]:
        node.nodestack.removeRemoteByName(newNode.nodestack.name)
        newNode.nodestack.removeRemoteByName(node.nodestack.name)
    newNode.stop()
    nodeSet = nodeSet[:-1]
    looper.removeProdable(newNode)

    upgr1 = deepcopy(validUpgrade)

    upgr2 = deepcopy(upgr1)
    upgr2[VERSION] = bumpVersion(upgr1[VERSION])
    upgr2[NAME] += randomString(3)
    # upgr2[SHA256] = get_valid_code_hash()
    upgr2[SHA256] = 'db34a72a90d026dae49c3b3f0436c8d3963476c77468ad955845a1ccf7b03f55'

    upgr3 = deepcopy(upgr2)
    upgr3[VERSION] = bumpVersion(upgr2[VERSION])
    upgr3[NAME] += randomString(3)
    # upgr3[SHA256] = get_valid_code_hash()
    upgr3[SHA256] = '112c060527e8cecfafe64dcb5bdabc4010cc7b64e0bf9bc2a43d23c37d927128'

    upgr4 = deepcopy(upgr3)
    upgr4[ACTION] = CANCEL

    sdk_ensure_upgrade_sent(looper, sdk_pool_handle, sdk_wallet_trustee, upgr1)
    looper.run(eventually(checkUpgradeScheduled,
                          nodeSet[:-1],
                          upgr1[VERSION],
                          retryWait=1,
                          timeout=waits.expectedUpgradeScheduled()))

    sdk_ensure_upgrade_sent(looper, sdk_pool_handle, sdk_wallet_trustee, upgr2)
    looper.run(eventually(checkUpgradeScheduled,
                          nodeSet[:-1],
                          upgr2[VERSION],
                          retryWait=1,
                          timeout=waits.expectedUpgradeScheduled()))

    sdk_ensure_upgrade_sent(looper, sdk_pool_handle, sdk_wallet_trustee, upgr3)
    looper.run(eventually(checkUpgradeScheduled,
                          nodeSet[:-1],
                          upgr3[VERSION],
                          retryWait=1,
                          timeout=waits.expectedUpgradeScheduled()))

    sdk_ensure_upgrade_sent(looper, sdk_pool_handle, sdk_wallet_trustee, upgr4)
    looper.run(eventually(checkUpgradeScheduled,
                          nodeSet[:-1],
                          upgr2[VERSION],
                          retryWait=1,
                          timeout=waits.expectedUpgradeScheduled()))

    newNode = TestNode(newNode.name, basedirpath=tdirWithPoolTxns, base_data_dir=tdirWithPoolTxns,
                       config=tconf, pluginPaths=allPluginsPath,
                       ha=newNode.nodestack.ha, cliha=newNode.clientstack.ha)
    looper.add(newNode)
    nodeSet.append(newNode)
    looper.run(checkNodesConnected(nodeSet))

    looper.run(eventually(checkUpgradeScheduled, [newNode, ], upgr2[VERSION],
                          retryWait=1, timeout=waits.expectedUpgradeScheduled()))