예제 #1
0
 def send_taa(self):
     sdk_send_txn_author_agreement(self.looper,
                                   self.sdk_pool_handle,
                                   self.trustee_wallet,
                                   randomString(10),
                                   randomString(5),
                                   ratified=get_utc_epoch())
def nodeSetWithTaaAlwaysResponding(txnPoolNodeSet,
                                   set_txn_author_agreement_aml, looper,
                                   sdk_pool_handle, sdk_wallet_trustee):
    global RATIFIED_V1, RATIFIED_V2
    global TIMESTAMP_V1, TIMESTAMP_V2

    looper.runFor(3)  # Make sure we have long enough gap between updates
    RATIFIED_V1 = get_utc_epoch() - 30
    reply = sdk_send_txn_author_agreement(looper, sdk_pool_handle,
                                          sdk_wallet_trustee, V1, TEXT_V1,
                                          RATIFIED_V1)
    TIMESTAMP_V1 = reply[1]['result'][TXN_METADATA][TXN_METADATA_TIME]

    looper.runFor(3)  # Make sure we have long enough gap between updates
    RATIFIED_V2 = get_utc_epoch() - 30
    reply = sdk_send_txn_author_agreement(looper, sdk_pool_handle,
                                          sdk_wallet_trustee, V2, TEXT_V2,
                                          RATIFIED_V2)
    TIMESTAMP_V2 = reply[1]['result'][TXN_METADATA][TXN_METADATA_TIME]

    sdk_send_txn_author_agreement(looper,
                                  sdk_pool_handle,
                                  sdk_wallet_trustee,
                                  V1,
                                  retired=TIMESTAMP_V1)
    return txnPoolNodeSet
예제 #3
0
def test_send_valid_txn_author_agreement_without_enough_privileges_fails(
        looper, setup_aml, txnPoolNodeSet, sdk_pool_handle,
        sdk_wallet_steward):
    with pytest.raises(RequestRejectedException):
        sdk_send_txn_author_agreement(looper, sdk_pool_handle,
                                      sdk_wallet_steward, randomString(1024),
                                      randomString(16))
예제 #4
0
def test_txn_author_agreement_respects_current_auth_rules(looper, setup_aml, txnPoolNodeSet, sdk_pool_handle,
                                                          sdk_wallet_trustee, sdk_wallet_steward):
    sdk_send_and_check_auth_rule_request(looper, sdk_pool_handle, sdk_wallet_trustee,
                                         auth_action=ADD_PREFIX, auth_type=TXN_AUTHOR_AGREEMENT,
                                         field='*', new_value='*',
                                         constraint=steward_or_trustee_constraint.as_dict)

    sdk_send_txn_author_agreement(looper, sdk_pool_handle, sdk_wallet_steward,
                                  randomString(16), randomString(1024), ratified=get_utc_epoch() - 300)
예제 #5
0
def test_send_valid_txn_author_agreement_succeeds(looper, setup_aml, txnPoolNodeSet, sdk_pool_handle,
                                                  sdk_wallet_trustee, sdk_wallet_client):
    text = randomString(1024)
    version = randomString(16)
    sdk_send_txn_author_agreement(looper, sdk_pool_handle, sdk_wallet_trustee, text, version)

    reply = sdk_get_txn_author_agreement(looper, sdk_pool_handle, sdk_wallet_client)[1]
    assert reply['op'] == REPLY

    result = reply['result']['data']
    assert result[TXN_AUTHOR_AGREEMENT_TEXT] == text
    assert result[TXN_AUTHOR_AGREEMENT_VERSION] == version
예제 #6
0
def nodeSetWithTaaAlwaysResponding(txnPoolNodeSet,
                                   set_txn_author_agreement_aml, looper,
                                   sdk_pool_handle, sdk_wallet_trustee):
    global TIMESTAMP_V1, TIMESTAMP_V2

    # Force signing empty config state
    txnPoolNodeSet[0].master_replica._do_send_3pc_batch(
        ledger_id=CONFIG_LEDGER_ID)

    looper.runFor(3)  # Make sure we have long enough gap between updates
    reply = sdk_send_txn_author_agreement(looper, sdk_pool_handle,
                                          sdk_wallet_trustee, TEXT_V1, V1)
    TIMESTAMP_V1 = reply[1]['result'][TXN_METADATA][TXN_METADATA_TIME]

    looper.runFor(3)  # Make sure we have long enough gap between updates
    reply = sdk_send_txn_author_agreement(looper, sdk_pool_handle,
                                          sdk_wallet_trustee, TEXT_V2, V2)
    TIMESTAMP_V2 = reply[1]['result'][TXN_METADATA][TXN_METADATA_TIME]

    return txnPoolNodeSet
def test_fill_ts_store_for_config_after_catchup(txnPoolNodeSet, looper,
                                                sdk_pool_handle,
                                                sdk_wallet_trustee, tconf,
                                                tdir, allPluginsPath,
                                                set_txn_author_agreement_aml):
    sdk_send_txn_author_agreement(looper,
                                  sdk_pool_handle,
                                  sdk_wallet_trustee,
                                  *create_random_taa(),
                                  ratified=get_utc_epoch() - 600)
    node_to_disconnect = txnPoolNodeSet[-1]

    disconnect_node_and_ensure_disconnected(looper, txnPoolNodeSet,
                                            node_to_disconnect)
    looper.removeProdable(name=node_to_disconnect.name)
    sdk_reply = sdk_send_txn_author_agreement(looper,
                                              sdk_pool_handle,
                                              sdk_wallet_trustee,
                                              *create_random_taa(),
                                              ratified=get_utc_epoch() - 600)

    node_to_disconnect = start_stopped_node(node_to_disconnect, looper, tconf,
                                            tdir, allPluginsPath)
    txnPoolNodeSet[-1] = node_to_disconnect
    looper.run(checkNodesConnected(txnPoolNodeSet))

    waitNodeDataEquality(looper,
                         node_to_disconnect,
                         *txnPoolNodeSet,
                         exclude_from_check=['check_last_ordered_3pc_backup'])
    req_handler = node_to_disconnect.read_manager.request_handlers[
        GET_TXN_AUTHOR_AGREEMENT]
    last_digest = StaticTAAHelper.get_taa_digest(req_handler.state)
    key = StaticTAAHelper.state_path_taa_digest(last_digest)
    root_hash = req_handler.database_manager.ts_store.get_equal_or_prev(
        get_txn_time(sdk_reply[1]['result']))
    assert root_hash
    from_state = req_handler.state.get_for_root_hash(root_hash=root_hash,
                                                     key=key)
    assert config_state_serializer.deserialize(from_state)['val']['text'] == \
           get_payload_data(sdk_reply[1]['result'])['text']
예제 #8
0
    def run(self):
        # Step 1. Change auth rule
        self.send_and_check(self.changed_auth_rule, wallet=self.trustee_wallet)

        # Step 2. Check, that we cannot do txn the old way
        with pytest.raises(RequestRejectedException):
            sdk_send_txn_author_agreement(self.looper,
                                          self.sdk_pool_handle,
                                          self.trustee_wallet,
                                          'v1',
                                          'some_text',
                                          ratified=get_utc_epoch() - 300)

        # Step 3. Check, that new auth rule is used
        sdk_send_txn_author_agreement(self.looper,
                                      self.sdk_pool_handle,
                                      self.new_default_wallet,
                                      'v2',
                                      'other_text',
                                      ratified=get_utc_epoch() - 300)

        # Step 4. Return default auth rule
        self.send_and_check(self.default_auth_rule, wallet=self.trustee_wallet)

        # Step 5. Check, that default auth rule works
        sdk_send_txn_author_agreement(self.looper,
                                      self.sdk_pool_handle,
                                      self.trustee_wallet,
                                      'v3',
                                      'another_text',
                                      ratified=get_utc_epoch() - 300)
def test_recover_taa_from_ledger(txnPoolNodeSet, sdk_pool_handle,
                                 sdk_wallet_trustee, looper, monkeypatch,
                                 setup_aml, tconf, tdir, allPluginsPath):
    orig_handlers = {}
    # Step 1. Stop one node
    node_to_stop = txnPoolNodeSet[-1]
    rest_pool = txnPoolNodeSet[:-1]
    disconnect_node_and_ensure_disconnected(looper,
                                            txnPoolNodeSet,
                                            node_to_stop.name,
                                            stopNode=True)
    looper.removeProdable(name=node_to_stop.name)

    # Step 2. Patch all the rest nodes for using old version TAA handler

    # it's ugly but it works
    globals()['CURRENT_TXN_PAYLOAD_VERSIONS'][TXN_AUTHOR_AGREEMENT] = '1'
    for node in rest_pool:
        handler = node.write_manager.request_handlers.get(
            TXN_AUTHOR_AGREEMENT)[0]
        orig_handlers[node.name] = handler
        handler_for_v_1 = node.write_manager._request_handlers_with_version.get(
            (TXN_AUTHOR_AGREEMENT, "1"))[0]
        node.write_manager.request_handlers[TXN_AUTHOR_AGREEMENT] = [
            handler_for_v_1
        ]

    # Step 3. Send TAA txn in old way
    text = randomString(1024)
    version_0 = randomString(16)
    res = sdk_send_txn_author_agreement(looper, sdk_pool_handle,
                                        sdk_wallet_trustee, version_0, text)[1]
    taa_0_ratification_ts = get_txn_time(res['result'])

    version_1 = randomString(16)
    res = sdk_send_txn_author_agreement(looper, sdk_pool_handle,
                                        sdk_wallet_trustee, version_1, text)[1]
    taa_1_ratification_ts = get_txn_time(res['result'])

    # Step 4. return original TAA handlers back

    # it's ugly but it works
    globals()['CURRENT_TXN_PAYLOAD_VERSIONS'][TXN_AUTHOR_AGREEMENT] = '2'
    for node in rest_pool:
        node.write_manager.request_handlers[TXN_AUTHOR_AGREEMENT] = [
            orig_handlers[node.name]
        ]

    # Step 5. Send another TAA txn in new way without optional parameters
    text_2 = randomString(1024)
    version_2 = randomString(16)
    ratified_2 = get_utc_epoch() - 300
    res_0 = sdk_send_txn_author_agreement(looper,
                                          sdk_pool_handle,
                                          sdk_wallet_trustee,
                                          version_2,
                                          text_2,
                                          ratified=ratified_2)[1]

    # Step 6. Send another TAA txn in new way without optional parameter
    text = randomString(1024)
    version_3 = randomString(16)
    ratified_3 = get_utc_epoch() - 300
    sdk_send_txn_author_agreement(looper,
                                  sdk_pool_handle,
                                  sdk_wallet_trustee,
                                  version_3,
                                  text,
                                  ratified=ratified_3)

    # Step 7. Send taa updating for the second taa transaction (for checking txn with optional parameter)
    retired_time = int(time.time()) + 20
    retired_time_in_past = int(time.time()) - 20
    sdk_send_txn_author_agreement(looper,
                                  sdk_pool_handle,
                                  sdk_wallet_trustee,
                                  version_2,
                                  retired=retired_time)

    # Step 8. Ensure, that all TAAs was written
    res_1 = sdk_get_txn_author_agreement(looper,
                                         sdk_pool_handle,
                                         sdk_wallet_trustee,
                                         version=version_1)[1]
    assert TXN_AUTHOR_AGREEMENT_DIGEST not in res_1['result']['data']
    assert TXN_AUTHOR_AGREEMENT_RATIFICATION_TS not in res_1['result']['data']
    assert res_1['result']['data'][TXN_AUTHOR_AGREEMENT_VERSION] == version_1

    res_2 = sdk_get_txn_author_agreement(looper,
                                         sdk_pool_handle,
                                         sdk_wallet_trustee,
                                         version=version_2)[1]
    check_result_contains_expected_taa_data(res_2, version_2, ratified_2,
                                            retired_time)

    res_3 = sdk_get_txn_author_agreement(looper,
                                         sdk_pool_handle,
                                         sdk_wallet_trustee,
                                         version=version_3)[1]
    check_result_contains_expected_taa_data(res_3, version_3, ratified_3)

    # Step 9. Return previous disconnected node back
    node_to_stop = start_stopped_node(node_to_stop, looper, tconf, tdir,
                                      allPluginsPath)
    txnPoolNodeSet = rest_pool + [node_to_stop]

    # Step 10. Ensure that all nodes have the same data
    ensure_all_nodes_have_same_data(looper, txnPoolNodeSet)

    # Step 11. Send another taa txns for checking pool writability
    text = randomString(1024)
    version_4 = randomString(16)
    ratified_4 = get_utc_epoch() - 300
    sdk_send_txn_author_agreement(looper,
                                  sdk_pool_handle,
                                  sdk_wallet_trustee,
                                  version_4,
                                  text,
                                  ratified=ratified_4)

    # Step 12. Ensure that all nodes have the same data
    ensure_all_nodes_have_same_data(looper, txnPoolNodeSet)

    # Step 13. Retire TAA written using old handler, make sure ratification date is not spoiled
    sdk_send_txn_author_agreement(looper,
                                  sdk_pool_handle,
                                  sdk_wallet_trustee,
                                  version_1,
                                  retired=retired_time_in_past)
    res_1 = sdk_get_txn_author_agreement(looper,
                                         sdk_pool_handle,
                                         sdk_wallet_trustee,
                                         version=version_1)[1]
    check_result_contains_expected_taa_data(res_1, version_1,
                                            taa_1_ratification_ts,
                                            retired_time_in_past)

    # Step 14. Disable TAAs written using old handler, make sure ratification date is not spoiled
    disable_res = sdk_send_txn_author_agreement_disable(
        looper, sdk_pool_handle, sdk_wallet_trustee)[1]

    res_0 = sdk_get_txn_author_agreement(looper,
                                         sdk_pool_handle,
                                         sdk_wallet_trustee,
                                         version=version_0)[1]
    check_result_contains_expected_taa_data(
        res_0, version_0, taa_0_ratification_ts,
        get_txn_time(disable_res['result']))

    res_1 = sdk_get_txn_author_agreement(looper,
                                         sdk_pool_handle,
                                         sdk_wallet_trustee,
                                         version=version_1)[1]
    check_result_contains_expected_taa_data(res_1, version_1,
                                            taa_1_ratification_ts,
                                            retired_time_in_past)