rippled
ReportingETL_test.cpp
1 
2 //------------------------------------------------------------------------------
3 /*
4  This file is part of rippled: https://github.com/ripple/rippled
5  Copyright (c) 2020 Ripple Labs Inc.
6 
7  Permission to use, copy, modify, and/or distribute this software for any
8  purpose with or without fee is hereby granted, provided that the above
9  copyright notice and this permission notice appear in all copies.
10 
11  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14  ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 */
19 //==============================================================================
20 
21 #include <ripple/app/ledger/LedgerMaster.h>
22 #include <ripple/app/reporting/P2pProxy.h>
23 #include <ripple/beast/unit_test.h>
24 #include <ripple/rpc/impl/Tuning.h>
25 
26 #include <test/jtx.h>
27 #include <test/jtx/Env.h>
28 #include <test/jtx/envconfig.h>
29 #include <test/rpc/GRPCTestClientBase.h>
30 
31 namespace ripple {
32 namespace test {
33 
34 class ReportingETL_test : public beast::unit_test::suite
35 {
36  // gRPC stuff
37  class GrpcLedgerClient : public GRPCTestClientBase
38  {
39  public:
40  org::xrpl::rpc::v1::GetLedgerRequest request;
41  org::xrpl::rpc::v1::GetLedgerResponse reply;
42 
43  explicit GrpcLedgerClient(std::string const& port)
44  : GRPCTestClientBase(port)
45  {
46  }
47 
48  void
49  GetLedger()
50  {
51  status = stub_->GetLedger(&context, request, &reply);
52  }
53  };
54  void
55  testGetLedger()
56  {
57  testcase("GetLedger");
58  using namespace test::jtx;
59  std::unique_ptr<Config> config = envconfig(addGrpcConfig);
60  std::string grpcPort = *(*config)["port_grpc"].get<std::string>("port");
61  Env env(*this, std::move(config));
62 
63  env.close();
64 
65  auto ledger = env.app().getLedgerMaster().getLedgerBySeq(3);
66 
67  BEAST_EXPECT(env.current()->info().seq == 4);
68 
69  auto grpcLedger = [&grpcPort](
70  auto sequence,
71  bool transactions,
72  bool expand,
73  bool get_objects) {
74  GrpcLedgerClient grpcClient{grpcPort};
75 
76  grpcClient.request.mutable_ledger()->set_sequence(sequence);
77  grpcClient.request.set_transactions(transactions);
78  grpcClient.request.set_expand(expand);
79  grpcClient.request.set_get_objects(get_objects);
80 
81  grpcClient.GetLedger();
82  return std::make_pair(grpcClient.status, grpcClient.reply);
83  };
84 
85  {
86  auto [status, reply] = grpcLedger(3, false, false, false);
87 
88  BEAST_EXPECT(status.ok());
89  BEAST_EXPECT(reply.validated());
90  BEAST_EXPECT(!reply.has_hashes_list());
91  BEAST_EXPECT(!reply.has_transactions_list());
92  BEAST_EXPECT(!reply.skiplist_included());
93  BEAST_EXPECT(reply.ledger_objects().objects_size() == 0);
94 
95  Serializer s;
96  addRaw(ledger->info(), s, true);
97  BEAST_EXPECT(s.slice() == makeSlice(reply.ledger_header()));
98  }
99 
100  Account const alice{"alice"};
101  Account const bob{"bob"};
102  env.fund(XRP(10000), alice);
103  env.fund(XRP(10000), bob);
104  env.close();
105 
106  ledger = env.app().getLedgerMaster().getLedgerBySeq(4);
107 
108  std::vector<uint256> hashes;
109  std::vector<std::shared_ptr<const STTx>> transactions;
110  std::vector<std::shared_ptr<const STObject>> metas;
111  for (auto& [sttx, meta] : ledger->txs)
112  {
113  hashes.push_back(sttx->getTransactionID());
114  transactions.push_back(sttx);
115  metas.push_back(meta);
116  }
117 
118  Serializer s;
119  addRaw(ledger->info(), s, true);
120 
121  {
122  auto [status, reply] = grpcLedger(4, true, false, false);
123  BEAST_EXPECT(status.ok());
124  BEAST_EXPECT(reply.validated());
125  BEAST_EXPECT(reply.has_hashes_list());
126  BEAST_EXPECT(reply.hashes_list().hashes_size() == hashes.size());
127  BEAST_EXPECT(
128  uint256::fromVoid(reply.hashes_list().hashes(0).data()) ==
129  hashes[0]);
130  BEAST_EXPECT(
131  uint256::fromVoid(reply.hashes_list().hashes(1).data()) ==
132  hashes[1]);
133  BEAST_EXPECT(
134  uint256::fromVoid(reply.hashes_list().hashes(2).data()) ==
135  hashes[2]);
136  BEAST_EXPECT(
137  uint256::fromVoid(reply.hashes_list().hashes(3).data()) ==
138  hashes[3]);
139 
140  BEAST_EXPECT(!reply.has_transactions_list());
141  BEAST_EXPECT(!reply.skiplist_included());
142  BEAST_EXPECT(reply.ledger_objects().objects_size() == 0);
143 
144  BEAST_EXPECT(s.slice() == makeSlice(reply.ledger_header()));
145  }
146 
147  {
148  auto [status, reply] = grpcLedger(4, true, true, false);
149 
150  BEAST_EXPECT(status.ok());
151  BEAST_EXPECT(reply.validated());
152  BEAST_EXPECT(!reply.has_hashes_list());
153 
154  BEAST_EXPECT(reply.has_transactions_list());
155  BEAST_EXPECT(reply.transactions_list().transactions_size() == 4);
156 
157  BEAST_EXPECT(
158  makeSlice(reply.transactions_list()
159  .transactions(0)
160  .transaction_blob()) ==
161  transactions[0]->getSerializer().slice());
162 
163  BEAST_EXPECT(
164  makeSlice(reply.transactions_list()
165  .transactions(0)
166  .metadata_blob()) ==
167  metas[0]->getSerializer().slice());
168 
169  BEAST_EXPECT(
170  makeSlice(reply.transactions_list()
171  .transactions(1)
172  .transaction_blob()) ==
173  transactions[1]->getSerializer().slice());
174 
175  BEAST_EXPECT(
176  makeSlice(reply.transactions_list()
177  .transactions(1)
178  .metadata_blob()) ==
179  metas[1]->getSerializer().slice());
180 
181  BEAST_EXPECT(
182  makeSlice(reply.transactions_list()
183  .transactions(2)
184  .transaction_blob()) ==
185  transactions[2]->getSerializer().slice());
186 
187  BEAST_EXPECT(
188  makeSlice(reply.transactions_list()
189  .transactions(2)
190  .metadata_blob()) ==
191  metas[2]->getSerializer().slice());
192 
193  BEAST_EXPECT(
194  makeSlice(reply.transactions_list()
195  .transactions(3)
196  .transaction_blob()) ==
197  transactions[3]->getSerializer().slice());
198 
199  BEAST_EXPECT(
200  makeSlice(reply.transactions_list()
201  .transactions(3)
202  .metadata_blob()) ==
203  metas[3]->getSerializer().slice());
204 
205  BEAST_EXPECT(!reply.skiplist_included());
206  BEAST_EXPECT(reply.ledger_objects().objects_size() == 0);
207 
208  BEAST_EXPECT(s.slice() == makeSlice(reply.ledger_header()));
209  }
210 
211  {
212  auto [status, reply] = grpcLedger(4, true, true, true);
213 
214  BEAST_EXPECT(status.ok());
215  BEAST_EXPECT(reply.validated());
216  BEAST_EXPECT(!reply.has_hashes_list());
217 
218  BEAST_EXPECT(reply.has_transactions_list());
219  BEAST_EXPECT(reply.transactions_list().transactions_size() == 4);
220 
221  BEAST_EXPECT(
222  makeSlice(reply.transactions_list()
223  .transactions(0)
224  .transaction_blob()) ==
225  transactions[0]->getSerializer().slice());
226 
227  BEAST_EXPECT(
228  makeSlice(reply.transactions_list()
229  .transactions(0)
230  .metadata_blob()) ==
231  metas[0]->getSerializer().slice());
232 
233  BEAST_EXPECT(
234  makeSlice(reply.transactions_list()
235  .transactions(1)
236  .transaction_blob()) ==
237  transactions[1]->getSerializer().slice());
238 
239  BEAST_EXPECT(
240  makeSlice(reply.transactions_list()
241  .transactions(1)
242  .metadata_blob()) ==
243  metas[1]->getSerializer().slice());
244 
245  BEAST_EXPECT(
246  makeSlice(reply.transactions_list()
247  .transactions(2)
248  .transaction_blob()) ==
249  transactions[2]->getSerializer().slice());
250 
251  BEAST_EXPECT(
252  makeSlice(reply.transactions_list()
253  .transactions(2)
254  .metadata_blob()) ==
255  metas[2]->getSerializer().slice());
256 
257  BEAST_EXPECT(
258  makeSlice(reply.transactions_list()
259  .transactions(3)
260  .transaction_blob()) ==
261  transactions[3]->getSerializer().slice());
262 
263  BEAST_EXPECT(
264  makeSlice(reply.transactions_list()
265  .transactions(3)
266  .metadata_blob()) ==
267  metas[3]->getSerializer().slice());
268  BEAST_EXPECT(reply.skiplist_included());
269 
270  BEAST_EXPECT(s.slice() == makeSlice(reply.ledger_header()));
271 
272  auto parent = env.app().getLedgerMaster().getLedgerBySeq(3);
273 
274  SHAMap::Delta differences;
275 
276  int maxDifferences = std::numeric_limits<int>::max();
277 
278  bool res = parent->stateMap().compare(
279  ledger->stateMap(), differences, maxDifferences);
280  BEAST_EXPECT(res);
281 
282  size_t idx = 0;
283  for (auto& [k, v] : differences)
284  {
285  BEAST_EXPECT(
286  k ==
287  uint256::fromVoid(
288  reply.ledger_objects().objects(idx).key().data()));
289  if (v.second)
290  {
291  BEAST_EXPECT(
292  v.second->slice() ==
293  makeSlice(reply.ledger_objects().objects(idx).data()));
294  }
295  ++idx;
296  }
297  }
298 
299  // Delete an account
300 
301  env(noop(alice));
302 
303  std::uint32_t const ledgerCount{
304  env.current()->seq() + 257 - env.seq(alice)};
305 
306  for (std::uint32_t i = 0; i < ledgerCount; ++i)
307  env.close();
308 
309  auto const acctDelFee{drops(env.current()->fees().increment)};
310  env(acctdelete(alice, bob), fee(acctDelFee));
311  env.close();
312 
313  {
314  auto [status, reply] =
315  grpcLedger(env.closed()->seq(), true, true, true);
316 
317  BEAST_EXPECT(status.ok());
318  BEAST_EXPECT(reply.validated());
319  auto base =
320  env.app().getLedgerMaster().getLedgerBySeq(env.closed()->seq());
321 
322  auto parent = env.app().getLedgerMaster().getLedgerBySeq(
323  env.closed()->seq() - 1);
324 
325  SHAMap::Delta differences;
326 
327  int maxDifferences = std::numeric_limits<int>::max();
328 
329  bool res = parent->stateMap().compare(
330  base->stateMap(), differences, maxDifferences);
331  BEAST_EXPECT(res);
332 
333  size_t idx = 0;
334  for (auto& [k, v] : differences)
335  {
336  BEAST_EXPECT(
337  k ==
338  uint256::fromVoid(
339  reply.ledger_objects().objects(idx).key().data()));
340  if (v.second)
341  {
342  BEAST_EXPECT(
343  v.second->slice() ==
344  makeSlice(reply.ledger_objects().objects(idx).data()));
345  }
346 
347  ++idx;
348  }
349  }
350  }
351 
352  // gRPC stuff
353  class GrpcLedgerDataClient : public GRPCTestClientBase
354  {
355  public:
356  org::xrpl::rpc::v1::GetLedgerDataRequest request;
357  org::xrpl::rpc::v1::GetLedgerDataResponse reply;
358 
359  explicit GrpcLedgerDataClient(std::string const& port)
360  : GRPCTestClientBase(port)
361  {
362  }
363 
364  void
365  GetLedgerData()
366  {
367  status = stub_->GetLedgerData(&context, request, &reply);
368  }
369  };
370  void
371  testGetLedgerData()
372  {
373  testcase("GetLedgerData");
374  using namespace test::jtx;
375  std::unique_ptr<Config> config = envconfig(addGrpcConfig);
376  std::string grpcPort = *(*config)["port_grpc"].get<std::string>("port");
377  Env env(*this, std::move(config));
378  auto grpcLedgerData = [&grpcPort](
379  auto sequence, std::string marker = "") {
380  GrpcLedgerDataClient grpcClient{grpcPort};
381 
382  grpcClient.request.mutable_ledger()->set_sequence(sequence);
383  if (marker.size())
384  {
385  grpcClient.request.set_marker(marker);
386  }
387 
388  grpcClient.GetLedgerData();
389  return std::make_pair(grpcClient.status, grpcClient.reply);
390  };
391 
392  Account const alice{"alice"};
393  env.fund(XRP(100000), alice);
394 
395  int num_accounts = 10;
396 
397  for (auto i = 0; i < num_accounts; i++)
398  {
399  Account const bob{std::string("bob") + std::to_string(i)};
400  env.fund(XRP(1000), bob);
401  }
402  env.close();
403 
404  {
405  auto [status, reply] = grpcLedgerData(env.closed()->seq());
406  BEAST_EXPECT(status.ok());
407 
408  BEAST_EXPECT(
409  reply.ledger_objects().objects_size() == num_accounts + 3);
410  BEAST_EXPECT(reply.marker().size() == 0);
411  auto ledger = env.closed();
412  size_t idx = 0;
413  for (auto& sle : ledger->sles)
414  {
415  BEAST_EXPECT(
416  sle->getSerializer().slice() ==
417  makeSlice(reply.ledger_objects().objects(idx).data()));
418  ++idx;
419  }
420  }
421 
422  {
423  auto [status, reply] =
424  grpcLedgerData(env.closed()->seq(), "bad marker");
425  BEAST_EXPECT(!status.ok());
426  BEAST_EXPECT(
427  status.error_code() == grpc::StatusCode::INVALID_ARGUMENT);
428  }
429 
430  num_accounts = 3000;
431 
432  for (auto i = 0; i < num_accounts; i++)
433  {
434  Account const cat{std::string("cat") + std::to_string(i)};
435  env.fund(XRP(1000), cat);
436  if (i % 100 == 0)
437  env.close();
438  }
439  env.close();
440 
441  {
442  auto [status, reply] = grpcLedgerData(env.closed()->seq());
443  BEAST_EXPECT(status.ok());
444 
445  int maxLimit = RPC::Tuning::pageLength(true);
446  BEAST_EXPECT(reply.ledger_objects().objects_size() == maxLimit);
447  BEAST_EXPECT(reply.marker().size() != 0);
448 
449  auto [status2, reply2] =
450  grpcLedgerData(env.closed()->seq(), reply.marker());
451  BEAST_EXPECT(status2.ok());
452  BEAST_EXPECT(reply2.marker().size() == 0);
453 
454  auto ledger = env.closed();
455  size_t idx = 0;
456  for (auto& sle : ledger->sles)
457  {
458  auto& obj = idx < maxLimit
459  ? reply.ledger_objects().objects(idx)
460  : reply2.ledger_objects().objects(idx - maxLimit);
461 
462  BEAST_EXPECT(
463  sle->getSerializer().slice() == makeSlice(obj.data()));
464  ++idx;
465  }
466  BEAST_EXPECT(
467  idx ==
468  reply.ledger_objects().objects_size() +
469  reply2.ledger_objects().objects_size());
470  }
471  }
472 
473  // gRPC stuff
474  class GrpcLedgerDiffClient : public GRPCTestClientBase
475  {
476  public:
477  org::xrpl::rpc::v1::GetLedgerDiffRequest request;
478  org::xrpl::rpc::v1::GetLedgerDiffResponse reply;
479 
480  explicit GrpcLedgerDiffClient(std::string const& port)
481  : GRPCTestClientBase(port)
482  {
483  }
484 
485  void
486  GetLedgerDiff()
487  {
488  status = stub_->GetLedgerDiff(&context, request, &reply);
489  }
490  };
491 
492  void
493  testGetLedgerDiff()
494  {
495  testcase("GetLedgerDiff");
496  using namespace test::jtx;
497  std::unique_ptr<Config> config = envconfig(addGrpcConfig);
498  std::string grpcPort = *(*config)["port_grpc"].get<std::string>("port");
499  Env env(*this, std::move(config));
500 
501  auto grpcLedgerDiff = [&grpcPort](
502  auto baseSequence, auto desiredSequence) {
503  GrpcLedgerDiffClient grpcClient{grpcPort};
504 
505  grpcClient.request.mutable_base_ledger()->set_sequence(
506  baseSequence);
507  grpcClient.request.mutable_desired_ledger()->set_sequence(
508  desiredSequence);
509  grpcClient.request.set_include_blobs(true);
510 
511  grpcClient.GetLedgerDiff();
512  return std::make_pair(grpcClient.status, grpcClient.reply);
513  };
514 
515  int num_accounts = 20;
516  for (auto i = 0; i < num_accounts; i++)
517  {
518  Account const cat{std::string("cat") + std::to_string(i)};
519  env.fund(XRP(1000), cat);
520  if (i % 2 == 0)
521  env.close();
522  }
523  env.close();
524 
525  auto compareDiffs = [&](auto baseSequence, auto desiredSequence) {
526  auto [status, reply] =
527  grpcLedgerDiff(baseSequence, desiredSequence);
528 
529  BEAST_EXPECT(status.ok());
530  auto desired =
531  env.app().getLedgerMaster().getLedgerBySeq(desiredSequence);
532 
533  auto base =
534  env.app().getLedgerMaster().getLedgerBySeq(baseSequence);
535 
536  SHAMap::Delta differences;
537 
538  int maxDifferences = std::numeric_limits<int>::max();
539 
540  bool res = base->stateMap().compare(
541  desired->stateMap(), differences, maxDifferences);
542  if (!BEAST_EXPECT(res))
543  return false;
544 
545  size_t idx = 0;
546  for (auto& [k, v] : differences)
547  {
548  if (!BEAST_EXPECT(
549  k ==
550  uint256::fromVoid(
551  reply.ledger_objects().objects(idx).key().data())))
552  return false;
553  if (v.second)
554  {
555  if (!BEAST_EXPECT(
556  v.second->slice() ==
557  makeSlice(
558  reply.ledger_objects().objects(idx).data())))
559  return false;
560  }
561 
562  ++idx;
563  }
564  return true;
565  };
566 
567  // Adjacent ledgers
568  BEAST_EXPECT(
569  compareDiffs(env.closed()->seq() - 1, env.closed()->seq()));
570 
571  // Adjacent ledgers further in the past
572  BEAST_EXPECT(
573  compareDiffs(env.closed()->seq() - 3, env.closed()->seq() - 2));
574 
575  // Non-adjacent ledgers
576  BEAST_EXPECT(
577  compareDiffs(env.closed()->seq() - 5, env.closed()->seq() - 1));
578 
579  // Adjacent ledgers but in reverse order
580  BEAST_EXPECT(
581  compareDiffs(env.closed()->seq(), env.closed()->seq() - 1));
582 
583  // Non-adjacent ledgers in reverse order
584  BEAST_EXPECT(
585  compareDiffs(env.closed()->seq() - 1, env.closed()->seq() - 5));
586  }
587 
588  // gRPC stuff
589  class GrpcLedgerEntryClient : public GRPCTestClientBase
590  {
591  public:
592  org::xrpl::rpc::v1::GetLedgerEntryRequest request;
593  org::xrpl::rpc::v1::GetLedgerEntryResponse reply;
594 
595  explicit GrpcLedgerEntryClient(std::string const& port)
596  : GRPCTestClientBase(port)
597  {
598  }
599 
600  void
601  GetLedgerEntry()
602  {
603  status = stub_->GetLedgerEntry(&context, request, &reply);
604  }
605  };
606 
607  void
608  testGetLedgerEntry()
609  {
610  testcase("GetLedgerDiff");
611  using namespace test::jtx;
612  std::unique_ptr<Config> config = envconfig(addGrpcConfig);
613  std::string grpcPort = *(*config)["port_grpc"].get<std::string>("port");
614  Env env(*this, std::move(config));
615 
616  auto grpcLedgerEntry = [&grpcPort](auto sequence, auto key) {
617  GrpcLedgerEntryClient grpcClient{grpcPort};
618 
619  grpcClient.request.mutable_ledger()->set_sequence(sequence);
620  grpcClient.request.set_key(key.data(), key.size());
621 
622  grpcClient.GetLedgerEntry();
623  return std::make_pair(grpcClient.status, grpcClient.reply);
624  };
625 
626  Account const alice{"alice"};
627  env.fund(XRP(1000), alice);
628  env.close();
629 
630  for (auto& sle : env.closed()->sles)
631  {
632  auto [status, reply] =
633  grpcLedgerEntry(env.closed()->seq(), sle->key());
634 
635  BEAST_EXPECT(status.ok());
636 
637  BEAST_EXPECT(
638  uint256::fromVoid(reply.ledger_object().key().data()) ==
639  sle->key());
640  BEAST_EXPECT(
641  makeSlice(reply.ledger_object().data()) ==
642  sle->getSerializer().slice());
643  }
644  }
645 
646  void
647  testNeedCurrentOrClosed()
648  {
649  testcase("NeedCurrentOrClosed");
650  {
651  org::xrpl::rpc::v1::GetAccountInfoRequest request;
652  request.mutable_ledger()->set_sequence(1);
653  BEAST_EXPECT(!needCurrentOrClosed(request));
654  request.mutable_ledger()->set_hash("");
655  BEAST_EXPECT(!needCurrentOrClosed(request));
656  request.mutable_ledger()->set_shortcut(
657  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_VALIDATED);
658  BEAST_EXPECT(!needCurrentOrClosed(request));
659  request.mutable_ledger()->set_shortcut(
660  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_UNSPECIFIED);
661  BEAST_EXPECT(!needCurrentOrClosed(request));
662  request.mutable_ledger()->set_shortcut(
663  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CURRENT);
664  BEAST_EXPECT(needCurrentOrClosed(request));
665  request.mutable_ledger()->set_shortcut(
666  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CLOSED);
667  BEAST_EXPECT(needCurrentOrClosed(request));
668  }
669 
670  {
671  org::xrpl::rpc::v1::GetLedgerRequest request;
672  request.mutable_ledger()->set_sequence(1);
673  BEAST_EXPECT(!needCurrentOrClosed(request));
674  request.mutable_ledger()->set_hash("");
675  BEAST_EXPECT(!needCurrentOrClosed(request));
676  request.mutable_ledger()->set_shortcut(
677  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_VALIDATED);
678  BEAST_EXPECT(!needCurrentOrClosed(request));
679  request.mutable_ledger()->set_shortcut(
680  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_UNSPECIFIED);
681  BEAST_EXPECT(!needCurrentOrClosed(request));
682  request.mutable_ledger()->set_shortcut(
683  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CURRENT);
684  BEAST_EXPECT(needCurrentOrClosed(request));
685  request.mutable_ledger()->set_shortcut(
686  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CLOSED);
687  BEAST_EXPECT(needCurrentOrClosed(request));
688  }
689 
690  {
691  org::xrpl::rpc::v1::GetLedgerDataRequest request;
692  request.mutable_ledger()->set_sequence(1);
693  BEAST_EXPECT(!needCurrentOrClosed(request));
694  request.mutable_ledger()->set_hash("");
695  BEAST_EXPECT(!needCurrentOrClosed(request));
696  request.mutable_ledger()->set_shortcut(
697  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_VALIDATED);
698  BEAST_EXPECT(!needCurrentOrClosed(request));
699  request.mutable_ledger()->set_shortcut(
700  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_UNSPECIFIED);
701  BEAST_EXPECT(!needCurrentOrClosed(request));
702  request.mutable_ledger()->set_shortcut(
703  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CURRENT);
704  BEAST_EXPECT(needCurrentOrClosed(request));
705  request.mutable_ledger()->set_shortcut(
706  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CLOSED);
707  BEAST_EXPECT(needCurrentOrClosed(request));
708  }
709 
710  {
711  org::xrpl::rpc::v1::GetLedgerEntryRequest request;
712  request.mutable_ledger()->set_sequence(1);
713  BEAST_EXPECT(!needCurrentOrClosed(request));
714  request.mutable_ledger()->set_hash("");
715  BEAST_EXPECT(!needCurrentOrClosed(request));
716  request.mutable_ledger()->set_shortcut(
717  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_VALIDATED);
718  BEAST_EXPECT(!needCurrentOrClosed(request));
719  request.mutable_ledger()->set_shortcut(
720  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_UNSPECIFIED);
721  BEAST_EXPECT(!needCurrentOrClosed(request));
722  request.mutable_ledger()->set_shortcut(
723  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CURRENT);
724  BEAST_EXPECT(needCurrentOrClosed(request));
725  request.mutable_ledger()->set_shortcut(
726  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CLOSED);
727  BEAST_EXPECT(needCurrentOrClosed(request));
728  }
729 
730  {
731  org::xrpl::rpc::v1::GetLedgerDiffRequest request;
732 
733  // set desired ledger, so desired ledger does not need current or
734  // closed
735  request.mutable_base_ledger()->set_shortcut(
736  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_VALIDATED);
737 
738  request.mutable_base_ledger()->set_sequence(1);
739  BEAST_EXPECT(!needCurrentOrClosed(request));
740  request.mutable_base_ledger()->set_hash("");
741  BEAST_EXPECT(!needCurrentOrClosed(request));
742  request.mutable_base_ledger()->set_shortcut(
743  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_VALIDATED);
744  BEAST_EXPECT(!needCurrentOrClosed(request));
745  request.mutable_base_ledger()->set_shortcut(
746  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_UNSPECIFIED);
747  BEAST_EXPECT(!needCurrentOrClosed(request));
748  request.mutable_base_ledger()->set_shortcut(
749  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CURRENT);
750  BEAST_EXPECT(needCurrentOrClosed(request));
751  request.mutable_base_ledger()->set_shortcut(
752  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CLOSED);
753  BEAST_EXPECT(needCurrentOrClosed(request));
754 
755  // reset base ledger, so base ledger doesn't need current or closed
756  request.mutable_base_ledger()->set_shortcut(
757  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_VALIDATED);
758 
759  request.mutable_desired_ledger()->set_sequence(1);
760  BEAST_EXPECT(!needCurrentOrClosed(request));
761  request.mutable_desired_ledger()->set_hash("");
762  BEAST_EXPECT(!needCurrentOrClosed(request));
763  request.mutable_desired_ledger()->set_shortcut(
764  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_VALIDATED);
765  BEAST_EXPECT(!needCurrentOrClosed(request));
766  request.mutable_desired_ledger()->set_shortcut(
767  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_UNSPECIFIED);
768  BEAST_EXPECT(!needCurrentOrClosed(request));
769  request.mutable_desired_ledger()->set_shortcut(
770  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CURRENT);
771  BEAST_EXPECT(needCurrentOrClosed(request));
772  request.mutable_desired_ledger()->set_shortcut(
773  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CLOSED);
774  BEAST_EXPECT(needCurrentOrClosed(request));
775 
776  // both base and desired need current or closed
777  request.mutable_base_ledger()->set_shortcut(
778  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CURRENT);
779  BEAST_EXPECT(needCurrentOrClosed(request));
780  }
781 
782  {
783  org::xrpl::rpc::v1::GetFeeRequest feeRequest;
784  BEAST_EXPECT(!needCurrentOrClosed(feeRequest));
785 
786  org::xrpl::rpc::v1::GetAccountTransactionHistoryRequest
787  accountTxRequest;
788  BEAST_EXPECT(!needCurrentOrClosed(accountTxRequest));
789 
790  org::xrpl::rpc::v1::GetTransactionRequest txRequest;
791  BEAST_EXPECT(!needCurrentOrClosed(txRequest));
792  }
793  }
794 
795  void
796  testSecureGateway()
797  {
798  testcase("SecureGateway");
799  using namespace test::jtx;
800  {
801  std::unique_ptr<Config> config = envconfig(
802  addGrpcConfigWithSecureGateway, getEnvLocalhostAddr());
803  std::string grpcPort =
804  *(*config)["port_grpc"].get<std::string>("port");
805  Env env(*this, std::move(config));
806 
807  env.close();
808 
809  auto ledger = env.app().getLedgerMaster().getLedgerBySeq(3);
810 
811  BEAST_EXPECT(env.current()->info().seq == 4);
812 
813  auto grpcLedger = [&grpcPort](
814  auto sequence,
815  std::string const& clientIp,
816  std::string const& user) {
817  GrpcLedgerClient grpcClient{grpcPort};
818 
819  grpcClient.request.mutable_ledger()->set_sequence(sequence);
820  grpcClient.request.set_client_ip(clientIp);
821  grpcClient.request.set_user(user);
822 
823  grpcClient.GetLedger();
824  return std::make_pair(grpcClient.status, grpcClient.reply);
825  };
826 
827  {
828  auto [status, reply] =
829  grpcLedger(env.current()->info().seq, "", "");
830  BEAST_EXPECT(!reply.is_unlimited());
831  BEAST_EXPECT(status.ok());
832  }
833  {
834  auto [status, reply] =
835  grpcLedger(env.current()->info().seq, "", "ETL");
836  BEAST_EXPECT(reply.is_unlimited());
837  BEAST_EXPECT(status.ok());
838  }
839  {
840  auto [status, reply] =
841  grpcLedger(env.current()->info().seq, "", "Reporting");
842  BEAST_EXPECT(reply.is_unlimited());
843  BEAST_EXPECT(status.ok());
844  }
845  {
846  auto [status, reply] =
847  grpcLedger(env.current()->info().seq, "127.0.0.1", "ETL");
848  BEAST_EXPECT(!reply.is_unlimited());
849  BEAST_EXPECT(status.ok());
850  }
851  {
852  auto [status, reply] =
853  grpcLedger(env.current()->info().seq, "127.0.0.1", "");
854  BEAST_EXPECT(!reply.is_unlimited());
855  BEAST_EXPECT(status.ok());
856  }
857  }
858 
859  {
860  std::string secureGatewayIp = "44.124.234.79";
861  std::unique_ptr<Config> config =
862  envconfig(addGrpcConfigWithSecureGateway, secureGatewayIp);
863  std::string grpcPort =
864  *(*config)["port_grpc"].get<std::string>("port");
865  Env env(*this, std::move(config));
866 
867  env.close();
868 
869  auto ledger = env.app().getLedgerMaster().getLedgerBySeq(3);
870 
871  BEAST_EXPECT(env.current()->info().seq == 4);
872 
873  auto grpcLedger = [&grpcPort](
874  auto sequence,
875  std::string const& clientIp,
876  std::string const& user) {
877  GrpcLedgerClient grpcClient{grpcPort};
878 
879  grpcClient.request.mutable_ledger()->set_sequence(sequence);
880  grpcClient.request.set_client_ip(clientIp);
881  grpcClient.request.set_user(user);
882 
883  grpcClient.GetLedger();
884  return std::make_pair(grpcClient.status, grpcClient.reply);
885  };
886 
887  {
888  auto [status, reply] =
889  grpcLedger(env.current()->info().seq, "", "");
890  BEAST_EXPECT(!reply.is_unlimited());
891  BEAST_EXPECT(status.ok());
892  }
893  {
894  auto [status, reply] =
895  grpcLedger(env.current()->info().seq, "", "ETL");
896  BEAST_EXPECT(!reply.is_unlimited());
897  BEAST_EXPECT(status.ok());
898  }
899  {
900  auto [status, reply] = grpcLedger(
901  env.current()->info().seq, secureGatewayIp, "ETL");
902  BEAST_EXPECT(!reply.is_unlimited());
903  BEAST_EXPECT(status.ok());
904  }
905  {
906  auto [status, reply] =
907  grpcLedger(env.current()->info().seq, secureGatewayIp, "");
908  BEAST_EXPECT(!reply.is_unlimited());
909  BEAST_EXPECT(status.ok());
910  }
911  }
912 
913  {
914  std::unique_ptr<Config> config = envconfig(
915  addGrpcConfigWithSecureGateway, getEnvLocalhostAddr());
916  std::string grpcPort =
917  *(*config)["port_grpc"].get<std::string>("port");
918  Env env(*this, std::move(config));
919 
920  env.close();
921 
922  auto ledger = env.app().getLedgerMaster().getLedgerBySeq(3);
923 
924  BEAST_EXPECT(env.current()->info().seq == 4);
925  auto grpcLedgerData = [&grpcPort](
926  auto sequence,
927  std::string const& clientIp,
928  std::string const& user) {
929  GrpcLedgerDataClient grpcClient{grpcPort};
930 
931  grpcClient.request.mutable_ledger()->set_sequence(sequence);
932  grpcClient.request.set_client_ip(clientIp);
933  grpcClient.request.set_user(user);
934 
935  grpcClient.GetLedgerData();
936  return std::make_pair(grpcClient.status, grpcClient.reply);
937  };
938  {
939  auto [status, reply] =
940  grpcLedgerData(env.current()->info().seq, "", "");
941  BEAST_EXPECT(!reply.is_unlimited());
942  BEAST_EXPECT(status.ok());
943  }
944  {
945  auto [status, reply] =
946  grpcLedgerData(env.current()->info().seq, "", "ETL");
947  BEAST_EXPECT(reply.is_unlimited());
948  BEAST_EXPECT(status.ok());
949  }
950  {
951  auto [status, reply] =
952  grpcLedgerData(env.current()->info().seq, "", "Reporting");
953  BEAST_EXPECT(reply.is_unlimited());
954  BEAST_EXPECT(status.ok());
955  }
956  {
957  auto [status, reply] = grpcLedgerData(
958  env.current()->info().seq, "127.0.0.1", "ETL");
959  BEAST_EXPECT(!reply.is_unlimited());
960  BEAST_EXPECT(status.ok());
961  }
962  {
963  auto [status, reply] =
964  grpcLedgerData(env.current()->info().seq, "127.0.0.1", "");
965  BEAST_EXPECT(!reply.is_unlimited());
966  BEAST_EXPECT(status.ok());
967  }
968  }
969  {
970  std::string secureGatewayIp = "44.124.234.79";
971  std::unique_ptr<Config> config =
972  envconfig(addGrpcConfigWithSecureGateway, secureGatewayIp);
973  std::string grpcPort =
974  *(*config)["port_grpc"].get<std::string>("port");
975  Env env(*this, std::move(config));
976 
977  env.close();
978 
979  auto ledger = env.app().getLedgerMaster().getLedgerBySeq(3);
980 
981  BEAST_EXPECT(env.current()->info().seq == 4);
982 
983  auto grpcLedgerData = [&grpcPort](
984  auto sequence,
985  std::string const& clientIp,
986  std::string const& user) {
987  GrpcLedgerDataClient grpcClient{grpcPort};
988 
989  grpcClient.request.mutable_ledger()->set_sequence(sequence);
990  grpcClient.request.set_client_ip(clientIp);
991  grpcClient.request.set_user(user);
992 
993  grpcClient.GetLedgerData();
994  return std::make_pair(grpcClient.status, grpcClient.reply);
995  };
996 
997  {
998  auto [status, reply] =
999  grpcLedgerData(env.current()->info().seq, "", "");
1000  BEAST_EXPECT(!reply.is_unlimited());
1001  BEAST_EXPECT(status.ok());
1002  }
1003  {
1004  auto [status, reply] =
1005  grpcLedgerData(env.current()->info().seq, "", "ETL");
1006  BEAST_EXPECT(!reply.is_unlimited());
1007  BEAST_EXPECT(status.ok());
1008  }
1009  {
1010  auto [status, reply] = grpcLedgerData(
1011  env.current()->info().seq, secureGatewayIp, "ETL");
1012  BEAST_EXPECT(!reply.is_unlimited());
1013  BEAST_EXPECT(status.ok());
1014  }
1015  {
1016  auto [status, reply] = grpcLedgerData(
1017  env.current()->info().seq, secureGatewayIp, "");
1018  BEAST_EXPECT(!reply.is_unlimited());
1019  BEAST_EXPECT(status.ok());
1020  }
1021  }
1022  }
1023 
1024 public:
1025  void
1026  run() override
1027  {
1028  testGetLedger();
1029 
1030  testGetLedgerData();
1031 
1032  testGetLedgerDiff();
1033 
1034  testGetLedgerEntry();
1035 
1036  testNeedCurrentOrClosed();
1037 
1038  testSecureGateway();
1039  }
1040 };
1041 
1042 BEAST_DEFINE_TESTSUITE_PRIO(ReportingETL, app, ripple, 2);
1043 
1044 } // namespace test
1045 } // namespace ripple
ripple::test::ReportingETL_test::GrpcLedgerDiffClient::request
org::xrpl::rpc::v1::GetLedgerDiffRequest request
Definition: ReportingETL_test.cpp:477
ripple::test::jtx::noop
Json::Value noop(Account const &account)
The null transaction.
Definition: noop.h:31
ripple::test::ReportingETL_test::run
void run() override
Definition: ReportingETL_test.cpp:1026
ripple::test::jtx::XRP
const XRP_t XRP
Converts to XRP Issue or STAmount.
Definition: amount.cpp:105
ripple::makeSlice
std::enable_if_t< std::is_same< T, char >::value||std::is_same< T, unsigned char >::value, Slice > makeSlice(std::array< T, N > const &a)
Definition: Slice.h:240
std::string
STL class.
ripple::test::jtx::drops
PrettyAmount drops(Integer i)
Returns an XRP PrettyAmount, which is trivially convertible to STAmount.
Definition: amount.h:241
ripple::test::ReportingETL_test::testGetLedgerDiff
void testGetLedgerDiff()
Definition: ReportingETL_test.cpp:493
ripple::test::GRPCTestClientBase::stub_
std::unique_ptr< org::xrpl::rpc::v1::XRPLedgerAPIService::Stub > stub_
Definition: GRPCTestClientBase.h:44
ripple::addRaw
void addRaw(LedgerInfo const &info, Serializer &s, bool includeHash)
Definition: View.cpp:164
std::vector
STL class.
ripple::test::ReportingETL_test::GrpcLedgerClient
Definition: ReportingETL_test.cpp:37
std::vector::size
T size(T... args)
ripple::test::jtx::addGrpcConfig
std::unique_ptr< Config > addGrpcConfig(std::unique_ptr< Config >)
add a grpc address and port to config
Definition: envconfig.cpp:113
ripple::test::ReportingETL_test::GrpcLedgerDataClient
Definition: ReportingETL_test.cpp:353
ripple::test::ReportingETL_test
Definition: ReportingETL_test.cpp:34
ripple::test::jtx::addGrpcConfigWithSecureGateway
std::unique_ptr< Config > addGrpcConfigWithSecureGateway(std::unique_ptr< Config >, std::string const &secureGateway)
add a grpc address, port and secure_gateway to config
Definition: envconfig.cpp:122
ripple::test::ReportingETL_test::testNeedCurrentOrClosed
void testNeedCurrentOrClosed()
Definition: ReportingETL_test.cpp:647
ripple::test::jtx::envconfig
std::unique_ptr< Config > envconfig()
creates and initializes a default configuration for jtx::Env
Definition: envconfig.h:49
ripple::needCurrentOrClosed
bool needCurrentOrClosed(Request &request)
Definition: P2pProxy.h:47
ripple::test::ReportingETL_test::GrpcLedgerDiffClient::reply
org::xrpl::rpc::v1::GetLedgerDiffResponse reply
Definition: ReportingETL_test.cpp:478
ripple::test::ReportingETL_test::testGetLedger
void testGetLedger()
Definition: ReportingETL_test.cpp:55
ripple::test::GRPCTestClientBase::status
grpc::Status status
Definition: GRPCTestClientBase.h:42
ripple::test::BEAST_DEFINE_TESTSUITE_PRIO
BEAST_DEFINE_TESTSUITE_PRIO(AccountDelete, app, ripple, 2)
ripple::test::ReportingETL_test::GrpcLedgerDiffClient::GetLedgerDiff
void GetLedgerDiff()
Definition: ReportingETL_test.cpp:486
ripple::test::ReportingETL_test::GrpcLedgerClient::reply
org::xrpl::rpc::v1::GetLedgerResponse reply
Definition: ReportingETL_test.cpp:41
ripple::test::GRPCTestClientBase
Definition: GRPCTestClientBase.h:29
std::vector::push_back
T push_back(T... args)
ripple::test::getEnvLocalhostAddr
const char * getEnvLocalhostAddr()
Definition: envconfig.h:31
ripple::test::ReportingETL_test::GrpcLedgerEntryClient::GrpcLedgerEntryClient
GrpcLedgerEntryClient(std::string const &port)
Definition: ReportingETL_test.cpp:595
ripple::test::ReportingETL_test::testGetLedgerData
void testGetLedgerData()
Definition: ReportingETL_test.cpp:371
ripple::test::ReportingETL_test::GrpcLedgerClient::GrpcLedgerClient
GrpcLedgerClient(std::string const &port)
Definition: ReportingETL_test.cpp:43
std::to_string
T to_string(T... args)
ripple::Serializer::slice
Slice slice() const noexcept
Definition: Serializer.h:63
ripple::ReportingETL
This class is responsible for continuously extracting data from a p2p node, and writing that data to ...
Definition: ReportingETL.h:70
ripple::RPC::Tuning::pageLength
constexpr int pageLength(bool isBinary)
Maximum number of pages in a LedgerData response.
Definition: rpc/impl/Tuning.h:69
std::uint32_t
ripple::test::ReportingETL_test::GrpcLedgerEntryClient
Definition: ReportingETL_test.cpp:589
std::map
STL class.
ripple::test::GRPCTestClientBase::context
grpc::ClientContext context
Definition: GRPCTestClientBase.h:43
ripple::test::ReportingETL_test::GrpcLedgerDataClient::request
org::xrpl::rpc::v1::GetLedgerDataRequest request
Definition: ReportingETL_test.cpp:356
ripple::test::jtx::fee
Set the fee on a JTx.
Definition: fee.h:35
ripple::Serializer
Definition: Serializer.h:39
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
ripple::test::ReportingETL_test::GrpcLedgerDataClient::GetLedgerData
void GetLedgerData()
Definition: ReportingETL_test.cpp:365
ripple::base_uint< 256 >::fromVoid
static base_uint fromVoid(void const *data)
Definition: base_uint.h:305
ripple::test::ReportingETL_test::GrpcLedgerClient::GetLedger
void GetLedger()
Definition: ReportingETL_test.cpp:49
ripple::test::ReportingETL_test::GrpcLedgerDiffClient::GrpcLedgerDiffClient
GrpcLedgerDiffClient(std::string const &port)
Definition: ReportingETL_test.cpp:480
ripple::test::ReportingETL_test::testSecureGateway
void testSecureGateway()
Definition: ReportingETL_test.cpp:796
ripple::test::ReportingETL_test::GrpcLedgerDataClient::GrpcLedgerDataClient
GrpcLedgerDataClient(std::string const &port)
Definition: ReportingETL_test.cpp:359
ripple::test::jtx::acctdelete
Json::Value acctdelete(Account const &account, Account const &dest)
Delete account.
Definition: acctdelete.cpp:29
ripple::test::ReportingETL_test::testGetLedgerEntry
void testGetLedgerEntry()
Definition: ReportingETL_test.cpp:608
ripple::test::ReportingETL_test::GrpcLedgerDataClient::reply
org::xrpl::rpc::v1::GetLedgerDataResponse reply
Definition: ReportingETL_test.cpp:357
ripple::test::jtx::Account
Immutable cryptographic account descriptor.
Definition: Account.h:37
ripple::test::ReportingETL_test::GrpcLedgerClient::request
org::xrpl::rpc::v1::GetLedgerRequest request
Definition: ReportingETL_test.cpp:40
std::make_pair
T make_pair(T... args)
ripple::test::ReportingETL_test::GrpcLedgerEntryClient::reply
org::xrpl::rpc::v1::GetLedgerEntryResponse reply
Definition: ReportingETL_test.cpp:593
ripple::test::ReportingETL_test::GrpcLedgerEntryClient::request
org::xrpl::rpc::v1::GetLedgerEntryRequest request
Definition: ReportingETL_test.cpp:592
std::numeric_limits::max
T max(T... args)
std::unique_ptr
STL class.
ripple::test::ReportingETL_test::GrpcLedgerDiffClient
Definition: ReportingETL_test.cpp:474
ripple::test::jtx::Env
A transaction testing environment.
Definition: Env.h:115
ripple::test::ReportingETL_test::GrpcLedgerEntryClient::GetLedgerEntry
void GetLedgerEntry()
Definition: ReportingETL_test.cpp:601
Generated by   doxygen 1.8.17