mirror of
https://github.com/XRPLF/rippled.git
synced 2026-04-29 15:37:57 +00:00
3cbdf818a7
- Added a new Invariant: `ValidPseudoAccounts` which checks that all pseudo-accounts behave consistently through creation and updates, and that no "real" accounts look like pseudo-accounts (which means they don't have a 0 sequence).
- `to_short_string(base_uint)`. Like `to_string`, but only returns the first 8 characters. (Similar to how a git commit ID can be abbreviated.) Used as a wrapped sink to prefix most transaction-related messages. More can be added later.
- `XRPL_ASSERT_PARTS`. Convenience wrapper for `XRPL_ASSERT`, which takes the `function` and `description` as separate parameters.
- `SField::sMD_PseudoAccount`. Metadata option for `SField` definitions to indicate that the field, if set in an `AccountRoot` indicates that account is a pseudo-account. Removes the need for hard-coded field lists all over the place. Added the flag to `AMMID` and `VaultID`.
- Added functionality to `SField` ctor to detect both code and name collisions using asserts. And require all SFields to have a name
- Convenience type aliases `STLedgerEntry::const_pointer` and `STLedgerEntry::const_ref`. (`SLE` is an alias to `STLedgerEntry`.)
- Generalized `feeunit.h` (`TaggedFee`) into `unit.h` (`ValueUnit`) and added new "BIPS"-related tags for future use. Also refactored the type restrictions to use Concepts.
- Restructured `transactions.macro` to do two big things
1. Include the `#include` directives for transactor header files directly in the macro file. Removes the need to update `applySteps.cpp` and the resulting conflicts.
2. Added a `privileges` parameter to the `TRANSACTION` macro, which specifies some of the operations a transaction is allowed to do. These `privileges` are enforced by invariant checks. Again, removed the need to update scattered lists of transaction types in various checks.
- Unit tests:
1. Moved more helper functions into `TestHelpers.h` and `.cpp`.
2. Cleaned up the namespaces to prevent / mitigate random collisions and ambiguous symbols, particularly in unity builds.
3. Generalized `Env::balance` to add support for `MPTIssue` and `Asset`.
4. Added a set of helper classes to simplify `Env` transaction parameter classes: `JTxField`, `JTxFieldWrapper`, and a bunch of classes derived or aliased from it. For an example of how awesome it is, check the changes `src/test/jtx/escrow.h` for how much simpler the definitions are for `finish_time`, `cancel_time`, `condition`, and `fulfillment`.
5. Generalized several of the amount-related helper classes to understand `Asset`s.
6. `env.balance` for an MPT issuer will return a negative number (or 0) for consistency with IOUs.
714 lines
36 KiB
C++
714 lines
36 KiB
C++
//------------------------------------------------------------------------------
|
|
/*
|
|
This file is part of rippled: https://github.com/ripple/rippled
|
|
Copyright 2016 Ripple Labs Inc.
|
|
|
|
Permission to use, copy, modify, and/or distribute this software for any
|
|
purpose with or without fee is hereby granted, provided that the above
|
|
copyright notice and this permission notice appear in all copies.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
//==============================================================================
|
|
|
|
#include <test/jtx.h>
|
|
#include <test/jtx/TrustedPublisherServer.h>
|
|
#include <test/unit_test/FileDirGuard.h>
|
|
|
|
#include <xrpld/app/misc/ValidatorSite.h>
|
|
|
|
#include <xrpl/basics/strHex.h>
|
|
#include <xrpl/protocol/PublicKey.h>
|
|
#include <xrpl/protocol/jss.h>
|
|
|
|
#include <boost/algorithm/string/join.hpp>
|
|
#include <boost/algorithm/string/predicate.hpp>
|
|
#include <boost/asio.hpp>
|
|
#include <boost/range/adaptor/transformed.hpp>
|
|
|
|
#include <date/date.h>
|
|
|
|
#include <chrono>
|
|
|
|
namespace ripple {
|
|
namespace detail {
|
|
constexpr char const*
|
|
realValidatorContents()
|
|
{
|
|
return R"vl({
|
|
"public_key": "ED2677ABFFD1B33AC6FBC3062B71F1E8397C1505E1C42C64D11AD1B28FF73F4734",
|
|
"manifest": "JAAAAAFxIe0md6v/0bM6xvvDBitx8eg5fBUF4cQsZNEa0bKP9z9HNHMh7V0AnEi5D4odY9X2sx+cY8B3OHNjJvMhARRPtTHmWnAhdkDFcg53dAQS1WDMQDLIs2wwwHpScrUnjp1iZwwTXVXXsaRxLztycioto3JgImGdukXubbrjeqCNU02f7Y/+6w0BcBJA3M0EOU+39hmB8vwfgernXZIDQ1+o0dnuXjX73oDLgsacwXzLBVOdBpSAsJwYD+nW8YaSacOHEsWaPlof05EsAg==",
|
|
"blob" : "{"sequence":37,"expiration":594172800,"validators":[{"validation_public_key":"ED49F8EB8071E26D4E067238D62D67CA6EBFB298B4A72DCFAD536A7EC8925C519B","manifest":"JAAAAAFxIe1J+OuAceJtTgZyONYtZ8puv7KYtKctz61Tan7IklxRm3MhAogMmQTRAFK/+m/XWQfJvXTeMcaiyF6gkhgAssdLOciIdkYwRAIgNxYavJPyHANuxogQY7RNBP9tZogZJxF1wZqzm4a37GgCIBOvbeQ8+P46CCIcy4ZCZA5rZZ+93H0aKJZQ3+IA0OOucBJAASTpQKtEJkeqwHz+jKWNvWl0sHRQZSSJuYiMyyUa7ytpsev6NGoFn1bNpYTgvsaPxoz7vHskDh2Z6gebSDCRCA=="},{"validation_public_key":"ED8108F7D9EE779DC1075EC3CF8EB9004DDF84CD0A0FF5775C9E375CCACDAA3022","manifest":"JAAAAAFxIe2BCPfZ7nedwQdew8+OuQBN34TNCg/1d1yeN1zKzaowInMhAlvPJANQcRUSNUR+NlZuo4kGpYF8l9pHPP1ZROOUcNYRdkYwRAIgRWZZuJLAf3SNMGoFygUlu+eAD51ZoHFMcyoicn0WKucCIGw4n9cVDPOBGC8wlJDy9282x9RdOwo1co2g+NZlc/DNcBJAKJhK/am6L7KE450NVzhpVVoL8OFMo0mFxk8BDG6QO2cSNMN3Oywf40D+Iles9LXxxvvPB6gWSmPlwF7dNR9GAQ=="},{"validation_public_key":"ED7E3BAFF901DE525B00B2C1FE19AF449A080B5F3100C6EC182C867AF61F710FFD","manifest":"JAAAAAFxIe1+O6/5Ad5SWwCywf4Zr0SaCAtfMQDG7Bgshnr2H3EP/XMhA5+GDJh2ApWKCh2N5omx4FAOFEqXMjqy1HJ5E7WA3FrOdkcwRQIhAMRezwjTAL35jpjj15jqoHUvRm7+7iHpU47aKE6HEChZAiBSMIZaMWv6qNJHniYpsYHx4OPPpBoCMMdMVAGfFi9fK3ASQE0TYiIsGv0/ylpqGEBiLkk2XjrA8++Akzpr9vcTtrkHiDDo0cHKO9mRULAXesRrOyFb5QcO0l0VswevD5jlswk="},{"validation_public_key":"ED45E80A04D79CB9DF00AEBD86DCDC1686D6419EA9E5E0E71F1A817E08B5076A55","manifest":"JAAAAAFxIe1F6AoE15y53wCuvYbc3BaG1kGeqeXg5x8agX4ItQdqVXMhAxZo157pcB9de6Smk7hoK3wNCAr4aFZtfAPi7CE4mNJldkcwRQIhALlVjXCfiy/mtXBWsNt77t4jKcNEBpRV8zv+SpU5lCh0AiBa8vo8xxpviYlf4zdG+nQhB2OgfkQZZPMHOt7CaXzXgXASQL8O5p083mg4KKL8uZfMaUqdgzuJ0Gta1lyUWPctTPCxY135XwK+nJAdFsIUFNJ9MPjnpCmSjYVzVa6M5/nAcAI="},{"validation_public_key":"EDD8C88642795CE69C5B780E01702C370F9507D0B64433F17EFE70F2637A40ADB7","manifest":"JAAAAAFxIe3YyIZCeVzmnFt4DgFwLDcPlQfQtkQz8X7+cPJjekCtt3MhAnFfr+r9BXdsXE/cBlJMyd/XsO1A5XEYCctrsvLEX+DmdkcwRQIhANRcRMg9SAXoaOvHDZ2av9RzEaZaVENfQiVgsi+Ox3F0AiB2snSIOm6c4/inbtU0UmWLQTzuwkOdUFPIB8Ax8dmGuHASQMUIfXMj96kcFTSJnMFC/mW/AQ8bKXkFrrk0CUTFFKweEjTq+STrFi6qLL2MT7nveGxsXBCgztjc0qGas9KFWgM="},{"validation_public_key":"EDBDEB901F7C75D0E20C6C42AF03BE0DA40377AF1939A18B3CB3679661DD5F9F74","manifest":"JAAAAAFxIe2965AffHXQ4gxsQq8Dvg2kA3evGTmhizyzZ5Zh3V+fdHMhAg3cyKNPMPqKgR7kIi7c/8GL/YgdBtg4mSAWvwmaevVGdkYwRAIgWzG8GqYg3YpwDs8xXa9XqLHss76KT2uAHRhUXFVUqCQCIG2EvbFKnxezRd9cpPHSt32HXK+P4+aL3p2+vqlCxRR9cBJAboXTmYTayocA3zf9dWEXtyaeOGC1k5WdYURzPleevvalR4xVoXzs38iGPxFr/pA9nL+M4duu0GKCHlVir+fBAg=="},{"validation_public_key":"EDA17871E72B0C570AC4345C60CF02AFBBB740A631B7AD0E1E573216574D9AEA02","manifest":"JAAAAAFxIe2heHHnKwxXCsQ0XGDPAq+7t0CmMbetDh5XMhZXTZrqAnMhAojyuzgtreQkxQj8prHxOsbDcF5fu4XXb0KxEL/Pq5HhdkcwRQIhANfPDLZP47aCWwt5kBnp75BuuCgp9c4BfJPd66SFCw61AiAJvegBvvPIrec+XOSzKRfi5uuXWxtl9Eyr2aPBYXvbRHASQMULYEo7beRfoUCnjk1sTYyY91tLIGLgnnaWXhUm80+zs5IGegk8qijKAtBOMuBC71lAB4KhJc+dB2rpMOFc5gw="},{"validation_public_key":"EDF46EE27AD0E1A714AFECDA816EAB7114614FCB92D0CB4D97B6A88ED43434AFC9","manifest":"JAAAAAFxIe30buJ60OGnFK/s2oFuq3EUYU/LktDLTZe2qI7UNDSvyXMhAw0ATWjVTt4FfeKO7kv6fFgd/go2+d5BSyUcURmRWnTtdkcwRQIhAMwOgDec7QYYNngspg90wEvVbsoh2ux14RPTw+GHaXNlAiALgfEsz+AF4eyX/Y5i44VrFjFFIMWUfOZaQJtsxteM1XASQLOaF0t2ZpqVKd8JESQVY+zU567iAAG2amTPZx95875S9A6Pl+kH5TGHMAeWjgWSqfh3m2HBJX7NIcXb98vy9AA="},{"validation_public_key":"ED6E4C41E59FFBEB51726E54468502FE6437238FA78EA51634E7BF0D09171AEE8F","manifest":"JAAAAAFxIe1uTEHln/vrUXJuVEaFAv5kNyOPp46lFjTnvw0JFxruj3MhAuztGWb/Oi1/V5m5dujWr9HmbKRyK4XYk+kmuFPSgAFrdkYwRAIgfQ+BgXX6QblZy4H05o7GPSIwqS7QQRUW7dqF54IAiiMCIH4XfLw956iEaoxZOk7Kctin2X9hMfaLN7wys9yAUFoZcBJAueEi84XR3Ll1GLJWanW1g1MdUj/0PAxJbw6EEQRuG3zdnuRHNXld6UZAbIkVcP0ztfqulBzjbcsLDOKFEicSBg=="},{"validation_public_key":"EDB6FC8E803EE8EDC2793F1EC917B2EE41D35255618DEB91D3F9B1FC89B75D4539","manifest":"JAAAAAFxIe22/I6APujtwnk/HskXsu5B01JVYY3rkdP5sfyJt11FOXMhA8VdvHFyScByQGTYNGeOvB0+67gWaqefcfvRk5+KwgV1dkYwRAIgZFulO/AiMoczng6i/4BkfzT7j9lxF4PP1ufgrOQaJ8sCIBX/E8Zbpn7tWqgAyNyWpVPkhFmaUMqEry8WoUT1fdGQcBJAv51RqJxgg/VrnrZwiLK2Dc0CKbiLPO5HJ4ZMsjdPT2gRc97rWkAXuV2L6PNFO59xyuoaZmSMlZYvqSGPpfF7Bw=="},{"validation_public_key":"ED691303992FEC64E6BC4BACD36AE6E5AEDC23F2861B6D8EFB9FD77EE3EADE3435","manifest":"JAAAAAFxIe1pEwOZL+xk5rxLrNNq5uWu3CPyhhttjvuf137j6t40NXMhAi2AXJQgo/JuW3r7f/6CcVsGN1YmIj11GiIESHBnQSk8dkcwRQIhANCDEQymrd6veT3ouacF6fhBr5wLw3GmXg1rMCLVvBzZAiA8uWQ+tqd46WmfBexjSBQ2Jd6UAGdrHvjcCQ2ZgSooCnASQFkHl+D7/U3WByYP384+pcFDf2Gi4WIRHVTo58cqdk5CDiwc1T0rDoLhmo41a3f+dsftfwR4aMmwFcPXLnrjrAI="},{"validation_public_key":"EDAD16667F0185DDBB7FA65B22F4B7D310BF5C3E2D9B823FB06A3A41AF8AC83BC1","manifest":"JAAAAAFxIe2tFmZ/AYXdu3+mWyL0t9MQv1w+LZuCP7BqOkGvisg7wXMhAqweE3PIS3E44KhMqKjKtbkBe8H8GbiuoAXAYDRoVRHodkYwRAIgagGkXtowUybdltKojv0lvvflrlQ9IRnPOjekF60iHzgCICg6ZocIMzkUuvO91BEormIWmX4G/MGT2zro6I/PvB8XcBJAcJLXkt/w/kcwEvNiZmi2i2nMn1wiP3LS9NJjBPju8KFLAMg0O9ydQT67U/ALYOeTPTO2/i2Yw9OSlibtqhgzDA=="},{"validation_public_key":"EDC245027A52EE5318095598EC3AB65FF4A3B9F9428E10B2F3C6F39DE15A15C90A","manifest":"JAAAAAFxIe3CRQJ6Uu5TGAlVmOw6tl/0o7n5Qo4QsvPG853hWhXJCnMhA/8/9rKUdA61j/fIEP/cqLpxBlmIhP2rg1d7NaEPyKV+dkcwRQIhAIxE0M/FJ50vfZW6fPpy4yCZumY9n0obrOojUkjm55a0AiBj56O0MpopGoY9HxC/+4wNO36Ho7E9CQeHsnKreDdsAXASQIYUd81jbiVUlET4dGoG2p+cf+2GqEXX5fJMSSyX/qe0XfR4cO+4qlgmjMQdCRDBWABHVvdN/yZyi/rL2c+WrQc="},{"validation_public_key":"ED4246AA3AE9D29863944800CCA91829E4447498A20CD9C3973A6B59346C75AB95","manifest":"JAAAAAFxIe1CRqo66dKYY5RIAMypGCnkRHSYogzZw5c6a1k0bHWrlXMhAkm1lz0c8QXWfJ9b1vB72dLabw8wYId8MtnpsHHBEC8pdkYwRAIgQlb6HJ53hsTAfVid+AOdBVvMF7rahIKNLBHUgn52zBECIGLUqFu8a1AAHRJcVonKYEnmhJwbCXLn+je7na1WD1/ocBJAE4vfvrGSmZC2uAUGmM5dIBtoSgEUey+2VleDYEsce94txYcjR8Z7QLNaliD8w/bD5/hvYQ8meV1Wg1jJFNe0CA=="},{"validation_public_key":"ED2C1468B4A11D281F93EF337C95E4A08DF0000FDEFB6D0EA9BC05FBD5D61A1F5A","manifest":"JAAAAAFxIe0sFGi0oR0oH5PvM3yV5KCN8AAP3vttDqm8BfvV1hofWnMhAkMUmCD2aPmgFDDRmimvSicSIScw6YNr42Dw4RAdwrOAdkcwRQIhAJFOHMg6qTG8v60dhrenYYk6cwOaRXq0RNmLjyyCiz5lAiAdU0YkDUJQhnN8Ry8s+6zTJLiNLbtM8oO/cLnurVpRM3ASQGALarHAsJkSZQtGdM2AaR/joFK/jhDU57+l+RSYjri/ydE20DaKanwkMEoVlBTg7lX4hYjEnmkqo73wIthLOAQ="},{"validation_public_key":"EDA54C85F91219FD259134B6B126AD64AE7204B81DD4052510657E1A5697246AD2","manifest":"JAAAAAJxIe2lTIX5Ehn9JZE0trEmrWSucgS4HdQFJRBlfhpWlyRq0nMhAl8cJerPv+vo1BK611xVTpGxjjr/CuxPTgU8URM4eTZ5dkYwRAIgdK3cQV2Y/viZne/PboKSKewngTuIN2M6c8azwqc20uUCIAc6GoNT+P2YBy49gdau4P7ySwWoQX5nf9dQxiQav5wIcBJAqiCK0d6QRZSpiVHp8O9nlKXCSEhsiSNcWcEFm/fGhJAnAN0Ov9HINId1pxrBn2dKRegLTvYG3Bpbz//HLgEdDA=="},{"validation_public_key":"ED9AE4F5887BA029EB7C0884486D23CF281975F773F44BD213054219882C411CC7","manifest":"JAAAAAFxIe2a5PWIe6Ap63wIhEhtI88oGXX3c/RL0hMFQhmILEEcx3MhAmG2zgv8FBZsZJU8aPapwo9cIqQv4/MSS1oVA5eVMiwLdkYwRAIgF+LOe4eY0gp9ttqh2gnv+z75OqLyOQMpGPALgm+NtOsCICDXBZVPtprmBDkBJkPFSnE55D9eKYRH8z/iY1EtpNplcBJAADEWGVT80Owhd1lh2JsU/oZlmeNF5WN7YvlB8llExaRKEVC+GW9Wg+iNIQ3rmV7P8aNaVuaabG00fOgkgzNhDw=="},{"validation_public_key":"EDA8D29F40CEB28995617641A3BC42692E1DE883214F612FBB62087A148E5F6F9A","manifest":"JAAAAAFxIe2o0p9AzrKJlWF2QaO8QmkuHeiDIU9hL7tiCHoUjl9vmnMhAnYnP7Eg6VgNnEUTRE29d64jQT/iBcWTQtNrUzyD6MJ+dkcwRQIhAOEsV5anTkloSmTZRbimMyBKqHoJYXcBBe8lLiPYC7mUAiAz2aNOpfQ/1LycWloIMvdhxzinq5X7Uas/uOSb9wh8d3ASQLVkfpW/GO6wdT6AuuSJ56TtM343pDNH+iSzxltIfdrPiUxT5rf4k21lQQuPClXm9+SfKrCiUXZK7dj0/GWTYQg="},{"validation_public_key":"ED38B0288EA240B4CDEC18A1A6289EB49007E4EBC0DE944803EB7EF141C5664073","manifest":"JAAAAAFxIe04sCiOokC0zewYoaYonrSQB+TrwN6USAPrfvFBxWZAc3MhAgOKcvIuchalrZw/glTuOxV3IOCcporxMB7JqAVupk1edkcwRQIhAOvRzpe+IYZK1MyInIQZ87JvP2J8SIXCXZMPBCdITBamAiASavJXi9pws8rDDJSxhGMlmE7zI5bSA8ivtRC9Lgq+UXASQDl3eoqLID+ETJNM+zbMuvwvcHEIxeBZkZ9fp5jJv6OCTPwlj4TJSuy1avEWqUYS2riv5Dvl2haFUoCHf4yawAA="},{"validation_public_key":"EDEE10DC36ACD995C8E0E86E3CD2FBF8301A4AC2B8847B61A1935DE4973B407C0E","manifest":"JAAAAAFxIe3uENw2rNmVyODobjzS+/gwGkrCuIR7YaGTXeSXO0B8DnMhAmX0vb7j+lgBjFjbN9RlA86J7AO2Vn6HLquO3aisK4mwdkYwRAIgfxBLn7i4jg/di0U25q6kIbVfTzqbA0SCpQ0I57TOFkcCIFMtJQpENjB2K2EmvBHPvNcwuSPc3vsEeqE2rNJ/cT5DcBJAf68XPFu5RjCeLgpFJM7PKFLgoV8e1nxO5ewjq9Q+TAEGnFyS0IOwf6pOOtIVMdVeXu1v6p4fhXQkdihHt1x6Ag=="},{"validation_public_key":"ED583ECD06C3B7369980E65C78C440A529300F557ED81256283F7DD5AA3513A334","manifest":"JAAAAAFxIe1YPs0Gw7c2mYDmXHjEQKUpMA9VftgSVig/fdWqNROjNHMhAyuUnzZZ1n2/GaTmE1m7H/v9YlZyDEwHY3gSHUA3ICL9dkYwRAIgHx2PHvidoN+5yG9WeAS2k7nwIM8ajxQW6wjvt8kBenACIDNxQPQkDyDJH9seS5C62mAarQmgiN89YS3jhNtnvEIqcBJAj7Jh0Kac+aJdpoepu/+eJKnnFQ7YByZB8eMZ+SS1zLhE+lip/49qqVNcpAxEqfaGtxJzoDDD1/QbuU7NOSPkCg=="},{"validation_public_key":"ED95C5172B2AD7D39434EEBC436B65B3BB7E58D5C1CEFC820B6972ACAD776E286A","manifest":"JAAAAAFxIe2VxRcrKtfTlDTuvENrZbO7fljVwc78ggtpcqytd24oanMhAiqcRde3MQZ075fa4ZNNyRaYJGMdBNkBnn3bQrKseBDQdkYwRAIgU+LfcE71DPVrO+KtUBjQ9D2u0k/Pr7lukO1nPRj6hSACIDNLYC/JFgobCsIa0BGw+6bUnOw9meU3FdXgR7Q7SoqJcBJAXQakOoQnPp3pcLL7zdKCPUX4b+/FC9Unhqp+O9xQFnRaCWVGmk5MJOIMs4WOQdpM1j3OgSsABmRuCXYvwo/nDw=="},{"validation_public_key":"ED90163D2BF0B7788904C4A4118D7D968920E847D88B79178390837DE3CA261562","manifest":"JAAAAAFxIe2QFj0r8Ld4iQTEpBGNfZaJIOhH2It5F4OQg33jyiYVYnMhA72VTRiGhkJBtqgGHDzHj7YbC6+NsEKrFHNuE/LO3Tn5dkYwRAIgf8s+fYt0llrKQ2qiWPnGmb6qJPoe8OnCM3VS29XKbYYCIHGnlJ4OTs2dXugO6Bto63NpDvvqJ+WIwdYKqZ6BiBfzcBJAGvNtkog4pfE5dZRwmic87ZBeeunOh4YpL0SERdxWj43Cs9815zFJuZysSaUX2R/vdE2VKqvSgqqtDEnrMo2oAw=="}]}",
|
|
"signature" : "9FF30EDC4DED7ABCD0D36389B7C716EED4B5E4F043902853534EBAC7BE966BB3813D5CF25E4DADA5E657CCF019FFD11847FD3CC44B5559A6FCEEE4C3DCFF8D0E",
|
|
"version": 1
|
|
}
|
|
)vl";
|
|
}
|
|
|
|
auto constexpr default_expires = std::chrono::seconds{3600};
|
|
auto constexpr default_effective_overlap = std::chrono::seconds{30};
|
|
} // namespace detail
|
|
|
|
namespace test {
|
|
class ValidatorSite_test : public beast::unit_test::suite
|
|
{
|
|
private:
|
|
using Validator = TrustedPublisherServer::Validator;
|
|
|
|
void
|
|
testConfigLoad()
|
|
{
|
|
testcase("Config Load");
|
|
|
|
using namespace jtx;
|
|
|
|
Env env(*this, envconfig(), nullptr, beast::severities::kDisabled);
|
|
auto trustedSites =
|
|
std::make_unique<ValidatorSite>(env.app(), env.journal);
|
|
|
|
// load should accept empty sites list
|
|
std::vector<std::string> emptyCfgSites;
|
|
BEAST_EXPECT(trustedSites->load(emptyCfgSites));
|
|
|
|
// load should accept valid validator site uris
|
|
std::vector<std::string> cfgSites(
|
|
{"http://ripple.com/",
|
|
"http://ripple.com/validators",
|
|
"http://ripple.com:8080/validators",
|
|
"http://207.261.33.37/validators",
|
|
"http://207.261.33.37:8080/validators",
|
|
"https://ripple.com/validators",
|
|
"https://ripple.com:443/validators",
|
|
"file:///etc/opt/ripple/validators.txt",
|
|
"file:///C:/Lib/validators.txt"
|
|
#if !_MSC_VER
|
|
,
|
|
"file:///"
|
|
#endif
|
|
});
|
|
BEAST_EXPECT(trustedSites->load(cfgSites));
|
|
|
|
// load should reject validator site uris with invalid schemes
|
|
std::vector<std::string> badSites({"ftp://ripple.com/validators"});
|
|
BEAST_EXPECT(!trustedSites->load(badSites));
|
|
|
|
badSites[0] = "wss://ripple.com/validators";
|
|
BEAST_EXPECT(!trustedSites->load(badSites));
|
|
|
|
badSites[0] = "ripple.com/validators";
|
|
BEAST_EXPECT(!trustedSites->load(badSites));
|
|
|
|
// Host names are not supported for file URLs
|
|
badSites[0] = "file://ripple.com/vl.txt";
|
|
BEAST_EXPECT(!trustedSites->load(badSites));
|
|
|
|
// Even local host names are not supported for file URLs
|
|
badSites[0] = "file://localhost/home/user/vl.txt";
|
|
BEAST_EXPECT(!trustedSites->load(badSites));
|
|
|
|
// Nor IP addresses
|
|
badSites[0] = "file://127.0.0.1/home/user/vl.txt";
|
|
BEAST_EXPECT(!trustedSites->load(badSites));
|
|
|
|
// File URL path can not be empty
|
|
badSites[0] = "file://";
|
|
BEAST_EXPECT(!trustedSites->load(badSites));
|
|
|
|
#if _MSC_VER // Windows paths strip off the leading /, leaving the path empty
|
|
// File URL path can not be a directory
|
|
// (/ is the only path we can reasonably assume is a directory)
|
|
badSites[0] = "file:///";
|
|
BEAST_EXPECT(!trustedSites->load(badSites));
|
|
#endif
|
|
}
|
|
|
|
struct FetchListConfig
|
|
{
|
|
std::string path;
|
|
std::string msg;
|
|
bool ssl;
|
|
bool failFetch = false;
|
|
bool failApply = false;
|
|
int serverVersion = 1;
|
|
std::chrono::seconds expiresFromNow = detail::default_expires;
|
|
std::chrono::seconds effectiveOverlap =
|
|
detail::default_effective_overlap;
|
|
int expectedRefreshMin = 0;
|
|
};
|
|
void
|
|
testFetchList(
|
|
detail::DirGuard const& good,
|
|
std::vector<FetchListConfig> const& paths)
|
|
{
|
|
testcase << "Fetch list - "
|
|
<< boost::algorithm::join(
|
|
paths |
|
|
boost::adaptors::transformed(
|
|
[](FetchListConfig const& cfg) {
|
|
return cfg.path +
|
|
(cfg.ssl ? " [https] v" : " [http] v") +
|
|
std::to_string(cfg.serverVersion) +
|
|
" " + cfg.msg;
|
|
}),
|
|
", ");
|
|
|
|
using namespace jtx;
|
|
using namespace std::chrono_literals;
|
|
|
|
Env env(*this, [&]() {
|
|
auto p = test::jtx::envconfig();
|
|
p->legacy("database_path", good.subdir().string());
|
|
return p;
|
|
}());
|
|
auto& trustedKeys = env.app().validators();
|
|
env.timeKeeper().set(env.timeKeeper().now() + 30s);
|
|
|
|
test::StreamSink sink;
|
|
beast::Journal journal{sink};
|
|
|
|
std::vector<std::string> emptyCfgKeys;
|
|
struct publisher
|
|
{
|
|
publisher(FetchListConfig const& c) : cfg{c}
|
|
{
|
|
}
|
|
std::shared_ptr<TrustedPublisherServer> server;
|
|
std::vector<Validator> list;
|
|
std::string uri;
|
|
FetchListConfig const& cfg;
|
|
bool isRetry;
|
|
};
|
|
std::vector<publisher> servers;
|
|
|
|
auto constexpr listSize = 20;
|
|
std::vector<std::string> cfgPublishers;
|
|
|
|
for (auto const& cfg : paths)
|
|
{
|
|
servers.push_back(cfg);
|
|
auto& item = servers.back();
|
|
item.isRetry = cfg.path == "/bad-resource";
|
|
item.list.reserve(listSize);
|
|
while (item.list.size() < listSize)
|
|
item.list.push_back(TrustedPublisherServer::randomValidator());
|
|
|
|
NetClock::time_point const expires =
|
|
env.timeKeeper().now() + cfg.expiresFromNow;
|
|
NetClock::time_point const effective2 =
|
|
expires - cfg.effectiveOverlap;
|
|
NetClock::time_point const expires2 =
|
|
effective2 + cfg.expiresFromNow;
|
|
item.server = make_TrustedPublisherServer(
|
|
env.app().getIOContext(),
|
|
item.list,
|
|
expires,
|
|
{{effective2, expires2}},
|
|
cfg.ssl,
|
|
cfg.serverVersion);
|
|
std::string pubHex = strHex(item.server->publisherPublic());
|
|
cfgPublishers.push_back(pubHex);
|
|
|
|
if (item.cfg.failFetch)
|
|
{
|
|
// Create a cache file
|
|
auto const name = good.subdir() / ("cache." + pubHex);
|
|
std::ofstream o(name.string());
|
|
o << "{}";
|
|
}
|
|
|
|
std::stringstream uri;
|
|
uri << (cfg.ssl ? "https://" : "http://")
|
|
<< item.server->local_endpoint() << cfg.path;
|
|
item.uri = uri.str();
|
|
}
|
|
|
|
BEAST_EXPECT(trustedKeys.load({}, emptyCfgKeys, cfgPublishers));
|
|
|
|
// Normally, tests will only need a fraction of this time,
|
|
// but sometimes DNS resolution takes an inordinate amount
|
|
// of time, so the test will just wait.
|
|
auto sites = std::make_unique<ValidatorSite>(env.app(), journal, 12s);
|
|
|
|
std::vector<std::string> uris;
|
|
for (auto const& u : servers)
|
|
{
|
|
log << "Testing " << u.uri << std::endl;
|
|
uris.push_back(u.uri);
|
|
}
|
|
sites->load(uris);
|
|
sites->start();
|
|
sites->join();
|
|
|
|
auto const jv = sites->getJson();
|
|
for (auto const& u : servers)
|
|
{
|
|
for (auto const& val : u.list)
|
|
{
|
|
BEAST_EXPECT(
|
|
trustedKeys.listed(val.masterPublic) != u.cfg.failApply);
|
|
BEAST_EXPECT(
|
|
trustedKeys.listed(val.signingPublic) != u.cfg.failApply);
|
|
}
|
|
|
|
Json::Value myStatus;
|
|
for (auto const& vs : jv[jss::validator_sites])
|
|
if (vs[jss::uri].asString().find(u.uri) != std::string::npos)
|
|
myStatus = vs;
|
|
BEAST_EXPECTS(
|
|
myStatus[jss::last_refresh_message].asString().empty() !=
|
|
u.cfg.failFetch,
|
|
to_string(myStatus) + "\n" + sink.messages().str());
|
|
|
|
if (!u.cfg.msg.empty())
|
|
{
|
|
BEAST_EXPECTS(
|
|
sink.messages().str().find(u.cfg.msg) != std::string::npos,
|
|
sink.messages().str());
|
|
}
|
|
|
|
if (u.cfg.expectedRefreshMin)
|
|
{
|
|
BEAST_EXPECTS(
|
|
myStatus[jss::refresh_interval_min].asInt() ==
|
|
u.cfg.expectedRefreshMin,
|
|
to_string(myStatus));
|
|
}
|
|
|
|
if (u.cfg.failFetch)
|
|
{
|
|
using namespace std::chrono;
|
|
std::stringstream nextRefreshStr{
|
|
myStatus[jss::next_refresh_time].asString()};
|
|
system_clock::time_point nextRefresh;
|
|
date::from_stream(nextRefreshStr, "%Y-%b-%d %T", nextRefresh);
|
|
BEAST_EXPECT(!nextRefreshStr.fail());
|
|
auto now = system_clock::now();
|
|
BEAST_EXPECTS(
|
|
nextRefresh <= now + (u.isRetry ? seconds{30} : minutes{5}),
|
|
"Now: " + to_string(now) + ", NR: " + nextRefreshStr.str());
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
testFileList(std::vector<std::pair<std::string, std::string>> const& paths)
|
|
{
|
|
testcase << "File list - " << paths[0].first
|
|
<< (paths.size() > 1 ? ", " + paths[1].first : "");
|
|
|
|
using namespace jtx;
|
|
|
|
Env env(*this);
|
|
|
|
test::StreamSink sink;
|
|
beast::Journal journal{sink};
|
|
|
|
struct publisher
|
|
{
|
|
std::string uri;
|
|
std::string expectMsg;
|
|
bool shouldFail;
|
|
};
|
|
std::vector<publisher> servers;
|
|
|
|
for (auto const& cfg : paths)
|
|
{
|
|
servers.push_back({});
|
|
auto& item = servers.back();
|
|
item.shouldFail = !cfg.second.empty();
|
|
item.expectMsg = cfg.second;
|
|
|
|
std::stringstream uri;
|
|
uri << "file://" << cfg.first;
|
|
item.uri = uri.str();
|
|
}
|
|
|
|
auto sites = std::make_unique<ValidatorSite>(env.app(), journal);
|
|
|
|
std::vector<std::string> uris;
|
|
for (auto const& u : servers)
|
|
uris.push_back(u.uri);
|
|
sites->load(uris);
|
|
sites->start();
|
|
sites->join();
|
|
|
|
for (auto const& u : servers)
|
|
{
|
|
auto const jv = sites->getJson();
|
|
Json::Value myStatus;
|
|
for (auto const& vs : jv[jss::validator_sites])
|
|
if (vs[jss::uri].asString().find(u.uri) != std::string::npos)
|
|
myStatus = vs;
|
|
BEAST_EXPECTS(
|
|
myStatus[jss::last_refresh_message].asString().empty() !=
|
|
u.shouldFail,
|
|
to_string(myStatus));
|
|
if (u.shouldFail)
|
|
{
|
|
BEAST_EXPECTS(
|
|
sink.messages().str().find(u.expectMsg) !=
|
|
std::string::npos,
|
|
sink.messages().str());
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
testFileURLs()
|
|
{
|
|
auto fullPath = [](detail::FileDirGuard const& guard) {
|
|
auto absPath = absolute(guard.file()).string();
|
|
if (absPath.front() != '/')
|
|
absPath.insert(absPath.begin(), '/');
|
|
return absPath;
|
|
};
|
|
{
|
|
// Create a file with a real validator list
|
|
detail::FileDirGuard good(
|
|
*this, "test_val", "vl.txt", detail::realValidatorContents());
|
|
// Create a file with arbitrary content
|
|
detail::FileDirGuard hello(
|
|
*this, "test_val", "helloworld.txt", "Hello, world!");
|
|
// Create a file with malformed Json
|
|
detail::FileDirGuard json(
|
|
*this,
|
|
"test_val",
|
|
"json.txt",
|
|
R"json({ "version": 2, "extra" : "value" })json");
|
|
auto const goodPath = fullPath(good);
|
|
auto const helloPath = fullPath(hello);
|
|
auto const jsonPath = fullPath(json);
|
|
auto const missingPath = jsonPath + ".bad";
|
|
testFileList({
|
|
{goodPath, ""},
|
|
{helloPath,
|
|
"Unable to parse JSON response from file://" + helloPath},
|
|
{jsonPath,
|
|
"Missing fields in JSON response from file://" + jsonPath},
|
|
{missingPath, "Problem retrieving from file://" + missingPath},
|
|
});
|
|
}
|
|
}
|
|
|
|
public:
|
|
void
|
|
run() override
|
|
{
|
|
testConfigLoad();
|
|
|
|
detail::DirGuard good(*this, "test_fetch");
|
|
for (auto ssl : {true, false})
|
|
{
|
|
// fetch single site
|
|
testFetchList(good, {{"/validators", "", ssl}});
|
|
testFetchList(good, {{"/validators2", "", ssl}});
|
|
// fetch multiple sites
|
|
testFetchList(
|
|
good, {{"/validators", "", ssl}, {"/validators", "", ssl}});
|
|
testFetchList(
|
|
good, {{"/validators", "", ssl}, {"/validators2", "", ssl}});
|
|
testFetchList(
|
|
good, {{"/validators2", "", ssl}, {"/validators", "", ssl}});
|
|
testFetchList(
|
|
good, {{"/validators2", "", ssl}, {"/validators2", "", ssl}});
|
|
// fetch single site with single redirects
|
|
testFetchList(good, {{"/redirect_once/301", "", ssl}});
|
|
testFetchList(good, {{"/redirect_once/302", "", ssl}});
|
|
testFetchList(good, {{"/redirect_once/307", "", ssl}});
|
|
testFetchList(good, {{"/redirect_once/308", "", ssl}});
|
|
// one redirect, one not
|
|
testFetchList(
|
|
good,
|
|
{{"/validators", "", ssl}, {"/redirect_once/302", "", ssl}});
|
|
testFetchList(
|
|
good,
|
|
{{"/validators2", "", ssl}, {"/redirect_once/302", "", ssl}});
|
|
// UNLs with a "gap" between validUntil of one and validFrom of the
|
|
// next
|
|
testFetchList(
|
|
good,
|
|
{{"/validators2",
|
|
"",
|
|
ssl,
|
|
false,
|
|
false,
|
|
1,
|
|
detail::default_expires,
|
|
std::chrono::seconds{-90}}});
|
|
// fetch single site with undending redirect (fails to load)
|
|
testFetchList(
|
|
good,
|
|
{{"/redirect_forever/301",
|
|
"Exceeded max redirects",
|
|
ssl,
|
|
true,
|
|
true}});
|
|
// two that redirect forever
|
|
testFetchList(
|
|
good,
|
|
{{"/redirect_forever/307",
|
|
"Exceeded max redirects",
|
|
ssl,
|
|
true,
|
|
true},
|
|
{"/redirect_forever/308",
|
|
"Exceeded max redirects",
|
|
ssl,
|
|
true,
|
|
true}});
|
|
// one undending redirect, one not
|
|
testFetchList(
|
|
good,
|
|
{{"/validators", "", ssl},
|
|
{"/redirect_forever/302",
|
|
"Exceeded max redirects",
|
|
ssl,
|
|
true,
|
|
true}});
|
|
// one undending redirect, one not
|
|
testFetchList(
|
|
good,
|
|
{{"/validators2", "", ssl},
|
|
{"/redirect_forever/302",
|
|
"Exceeded max redirects",
|
|
ssl,
|
|
true,
|
|
true}});
|
|
// invalid redir Location
|
|
testFetchList(
|
|
good,
|
|
{{"/redirect_to/ftp://invalid-url/302",
|
|
"Invalid redirect location",
|
|
ssl,
|
|
true,
|
|
true}});
|
|
testFetchList(
|
|
good,
|
|
{{"/redirect_to/file://invalid-url/302",
|
|
"Invalid redirect location",
|
|
ssl,
|
|
true,
|
|
true}});
|
|
// invalid json
|
|
testFetchList(
|
|
good,
|
|
{{"/validators/bad",
|
|
"Unable to parse JSON response",
|
|
ssl,
|
|
true,
|
|
true}});
|
|
testFetchList(
|
|
good,
|
|
{{"/validators2/bad",
|
|
"Unable to parse JSON response",
|
|
ssl,
|
|
true,
|
|
true}});
|
|
// error status returned
|
|
testFetchList(
|
|
good,
|
|
{{"/bad-resource", "returned bad status", ssl, true, true}});
|
|
// location field missing
|
|
testFetchList(
|
|
good,
|
|
{{"/redirect_nolo/308",
|
|
"returned a redirect with no Location",
|
|
ssl,
|
|
true,
|
|
true}});
|
|
// json fields missing
|
|
testFetchList(
|
|
good,
|
|
{{"/validators/missing",
|
|
"Missing fields in JSON response",
|
|
ssl,
|
|
true,
|
|
true}});
|
|
testFetchList(
|
|
good,
|
|
{{"/validators2/missing",
|
|
"Missing fields in JSON response",
|
|
ssl,
|
|
true,
|
|
true}});
|
|
// timeout
|
|
testFetchList(
|
|
good, {{"/sleep/13", "took too long", ssl, true, true}});
|
|
// bad manifest format using known versions
|
|
// * Retrieves a v1 formatted list claiming version 2
|
|
testFetchList(
|
|
good, {{"/validators", "Missing fields", ssl, true, true, 2}});
|
|
// * Retrieves a v2 formatted list claiming version 1
|
|
testFetchList(
|
|
good, {{"/validators2", "Missing fields", ssl, true, true, 0}});
|
|
// bad manifest version
|
|
// Because versions other than 1 are treated as v2, the v1
|
|
// list won't have the blobs_v2 fields, and thus will claim to have
|
|
// missing fields
|
|
testFetchList(
|
|
good, {{"/validators", "Missing fields", ssl, true, true, 4}});
|
|
testFetchList(
|
|
good,
|
|
{{"/validators2",
|
|
"1 unsupported version",
|
|
ssl,
|
|
false,
|
|
true,
|
|
4}});
|
|
using namespace std::chrono_literals;
|
|
// get expired validator list
|
|
testFetchList(
|
|
good,
|
|
{{"/validators",
|
|
"Applied 1 expired validator list(s)",
|
|
ssl,
|
|
false,
|
|
false,
|
|
1,
|
|
0s}});
|
|
testFetchList(
|
|
good,
|
|
{{"/validators2",
|
|
"Applied 1 expired validator list(s)",
|
|
ssl,
|
|
false,
|
|
false,
|
|
1,
|
|
0s,
|
|
-1s}});
|
|
// force an out-of-range validUntil value
|
|
testFetchList(
|
|
good,
|
|
{{"/validators",
|
|
"1 invalid validator list(s)",
|
|
ssl,
|
|
false,
|
|
true,
|
|
1,
|
|
std::chrono::seconds{Json::Value::maxInt + 1}}});
|
|
// force an out-of-range validUntil value on the future list
|
|
// The first list is accepted. The second fails. The parser
|
|
// returns the "best" result, so this looks like a success.
|
|
testFetchList(
|
|
good,
|
|
{{"/validators2",
|
|
"",
|
|
ssl,
|
|
false,
|
|
false,
|
|
1,
|
|
std::chrono::seconds{Json::Value::maxInt - 300},
|
|
299s}});
|
|
// force an out-of-range validFrom value
|
|
// The first list is accepted. The second fails. The parser
|
|
// returns the "best" result, so this looks like a success.
|
|
testFetchList(
|
|
good,
|
|
{{"/validators2",
|
|
"",
|
|
ssl,
|
|
false,
|
|
false,
|
|
1,
|
|
std::chrono::seconds{Json::Value::maxInt - 300},
|
|
301s}});
|
|
// force an out-of-range validUntil value on _both_ lists
|
|
testFetchList(
|
|
good,
|
|
{{"/validators2",
|
|
"2 invalid validator list(s)",
|
|
ssl,
|
|
false,
|
|
true,
|
|
1,
|
|
std::chrono::seconds{Json::Value::maxInt + 1},
|
|
std::chrono::seconds{Json::Value::maxInt - 6000}}});
|
|
// verify refresh intervals are properly clamped
|
|
testFetchList(
|
|
good,
|
|
{{"/validators/refresh/0",
|
|
"",
|
|
ssl,
|
|
false,
|
|
false,
|
|
1,
|
|
detail::default_expires,
|
|
detail::default_effective_overlap,
|
|
1}}); // minimum of 1 minute
|
|
testFetchList(
|
|
good,
|
|
{{"/validators2/refresh/0",
|
|
"",
|
|
ssl,
|
|
false,
|
|
false,
|
|
1,
|
|
detail::default_expires,
|
|
detail::default_effective_overlap,
|
|
1}}); // minimum of 1 minute
|
|
testFetchList(
|
|
good,
|
|
{{"/validators/refresh/10",
|
|
"",
|
|
ssl,
|
|
false,
|
|
false,
|
|
1,
|
|
detail::default_expires,
|
|
detail::default_effective_overlap,
|
|
10}}); // 10 minutes is fine
|
|
testFetchList(
|
|
good,
|
|
{{"/validators2/refresh/10",
|
|
"",
|
|
ssl,
|
|
false,
|
|
false,
|
|
1,
|
|
detail::default_expires,
|
|
detail::default_effective_overlap,
|
|
10}}); // 10 minutes is fine
|
|
testFetchList(
|
|
good,
|
|
{{"/validators/refresh/2000",
|
|
"",
|
|
ssl,
|
|
false,
|
|
false,
|
|
1,
|
|
detail::default_expires,
|
|
detail::default_effective_overlap,
|
|
60 * 24}}); // max of 24 hours
|
|
testFetchList(
|
|
good,
|
|
{{"/validators2/refresh/2000",
|
|
"",
|
|
ssl,
|
|
false,
|
|
false,
|
|
1,
|
|
detail::default_expires,
|
|
detail::default_effective_overlap,
|
|
60 * 24}}); // max of 24 hours
|
|
}
|
|
using namespace boost::filesystem;
|
|
for (auto const& file : directory_iterator(good.subdir()))
|
|
{
|
|
remove_all(file);
|
|
}
|
|
|
|
testFileURLs();
|
|
}
|
|
};
|
|
|
|
BEAST_DEFINE_TESTSUITE_PRIO(ValidatorSite, app, ripple, 2);
|
|
|
|
} // namespace test
|
|
} // namespace ripple
|