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  num_accounts = 3000;
423 
424  for (auto i = 0; i < num_accounts; i++)
425  {
426  Account const cat{std::string("cat") + std::to_string(i)};
427  env.fund(XRP(1000), cat);
428  if (i % 100 == 0)
429  env.close();
430  }
431  env.close();
432 
433  {
434  auto [status, reply] = grpcLedgerData(env.closed()->seq());
435  BEAST_EXPECT(status.ok());
436 
437  int maxLimit = RPC::Tuning::pageLength(true);
438  BEAST_EXPECT(reply.ledger_objects().objects_size() == maxLimit);
439  BEAST_EXPECT(reply.marker().size() != 0);
440 
441  auto [status2, reply2] =
442  grpcLedgerData(env.closed()->seq(), reply.marker());
443  BEAST_EXPECT(status2.ok());
444  BEAST_EXPECT(reply2.marker().size() == 0);
445 
446  auto ledger = env.closed();
447  size_t idx = 0;
448  for (auto& sle : ledger->sles)
449  {
450  auto& obj = idx < maxLimit
451  ? reply.ledger_objects().objects(idx)
452  : reply2.ledger_objects().objects(idx - maxLimit);
453 
454  BEAST_EXPECT(
455  sle->getSerializer().slice() == makeSlice(obj.data()));
456  ++idx;
457  }
458  BEAST_EXPECT(
459  idx ==
460  reply.ledger_objects().objects_size() +
461  reply2.ledger_objects().objects_size());
462  }
463  }
464 
465  // gRPC stuff
466  class GrpcLedgerDiffClient : public GRPCTestClientBase
467  {
468  public:
469  org::xrpl::rpc::v1::GetLedgerDiffRequest request;
470  org::xrpl::rpc::v1::GetLedgerDiffResponse reply;
471 
472  explicit GrpcLedgerDiffClient(std::string const& port)
473  : GRPCTestClientBase(port)
474  {
475  }
476 
477  void
478  GetLedgerDiff()
479  {
480  status = stub_->GetLedgerDiff(&context, request, &reply);
481  }
482  };
483 
484  void
485  testGetLedgerDiff()
486  {
487  testcase("GetLedgerDiff");
488  using namespace test::jtx;
489  std::unique_ptr<Config> config = envconfig(addGrpcConfig);
490  std::string grpcPort = *(*config)["port_grpc"].get<std::string>("port");
491  Env env(*this, std::move(config));
492 
493  auto grpcLedgerDiff = [&grpcPort](
494  auto baseSequence, auto desiredSequence) {
495  GrpcLedgerDiffClient grpcClient{grpcPort};
496 
497  grpcClient.request.mutable_base_ledger()->set_sequence(
498  baseSequence);
499  grpcClient.request.mutable_desired_ledger()->set_sequence(
500  desiredSequence);
501  grpcClient.request.set_include_blobs(true);
502 
503  grpcClient.GetLedgerDiff();
504  return std::make_pair(grpcClient.status, grpcClient.reply);
505  };
506 
507  int num_accounts = 20;
508  for (auto i = 0; i < num_accounts; i++)
509  {
510  Account const cat{std::string("cat") + std::to_string(i)};
511  env.fund(XRP(1000), cat);
512  if (i % 2 == 0)
513  env.close();
514  }
515  env.close();
516 
517  auto compareDiffs = [&](auto baseSequence, auto desiredSequence) {
518  auto [status, reply] =
519  grpcLedgerDiff(baseSequence, desiredSequence);
520 
521  BEAST_EXPECT(status.ok());
522  auto desired =
523  env.app().getLedgerMaster().getLedgerBySeq(desiredSequence);
524 
525  auto base =
526  env.app().getLedgerMaster().getLedgerBySeq(baseSequence);
527 
528  SHAMap::Delta differences;
529 
530  int maxDifferences = std::numeric_limits<int>::max();
531 
532  bool res = base->stateMap().compare(
533  desired->stateMap(), differences, maxDifferences);
534  if (!BEAST_EXPECT(res))
535  return false;
536 
537  size_t idx = 0;
538  for (auto& [k, v] : differences)
539  {
540  if (!BEAST_EXPECT(
541  k ==
542  uint256::fromVoid(
543  reply.ledger_objects().objects(idx).key().data())))
544  return false;
545  if (v.second)
546  {
547  if (!BEAST_EXPECT(
548  v.second->slice() ==
549  makeSlice(
550  reply.ledger_objects().objects(idx).data())))
551  return false;
552  }
553 
554  ++idx;
555  }
556  return true;
557  };
558 
559  // Adjacent ledgers
560  BEAST_EXPECT(
561  compareDiffs(env.closed()->seq() - 1, env.closed()->seq()));
562 
563  // Adjacent ledgers further in the past
564  BEAST_EXPECT(
565  compareDiffs(env.closed()->seq() - 3, env.closed()->seq() - 2));
566 
567  // Non-adjacent ledgers
568  BEAST_EXPECT(
569  compareDiffs(env.closed()->seq() - 5, env.closed()->seq() - 1));
570 
571  // Adjacent ledgers but in reverse order
572  BEAST_EXPECT(
573  compareDiffs(env.closed()->seq(), env.closed()->seq() - 1));
574 
575  // Non-adjacent ledgers in reverse order
576  BEAST_EXPECT(
577  compareDiffs(env.closed()->seq() - 1, env.closed()->seq() - 5));
578  }
579 
580  // gRPC stuff
581  class GrpcLedgerEntryClient : public GRPCTestClientBase
582  {
583  public:
584  org::xrpl::rpc::v1::GetLedgerEntryRequest request;
585  org::xrpl::rpc::v1::GetLedgerEntryResponse reply;
586 
587  explicit GrpcLedgerEntryClient(std::string const& port)
588  : GRPCTestClientBase(port)
589  {
590  }
591 
592  void
593  GetLedgerEntry()
594  {
595  status = stub_->GetLedgerEntry(&context, request, &reply);
596  }
597  };
598 
599  void
600  testGetLedgerEntry()
601  {
602  testcase("GetLedgerDiff");
603  using namespace test::jtx;
604  std::unique_ptr<Config> config = envconfig(addGrpcConfig);
605  std::string grpcPort = *(*config)["port_grpc"].get<std::string>("port");
606  Env env(*this, std::move(config));
607 
608  auto grpcLedgerEntry = [&grpcPort](auto sequence, auto key) {
609  GrpcLedgerEntryClient grpcClient{grpcPort};
610 
611  grpcClient.request.mutable_ledger()->set_sequence(sequence);
612  grpcClient.request.set_key(key.data(), key.size());
613 
614  grpcClient.GetLedgerEntry();
615  return std::make_pair(grpcClient.status, grpcClient.reply);
616  };
617 
618  Account const alice{"alice"};
619  env.fund(XRP(1000), alice);
620  env.close();
621 
622  for (auto& sle : env.closed()->sles)
623  {
624  auto [status, reply] =
625  grpcLedgerEntry(env.closed()->seq(), sle->key());
626 
627  BEAST_EXPECT(status.ok());
628 
629  BEAST_EXPECT(
630  uint256::fromVoid(reply.ledger_object().key().data()) ==
631  sle->key());
632  BEAST_EXPECT(
633  makeSlice(reply.ledger_object().data()) ==
634  sle->getSerializer().slice());
635  }
636  }
637 
638  void
639  testNeedCurrentOrClosed()
640  {
641  testcase("NeedCurrentOrClosed");
642  {
643  org::xrpl::rpc::v1::GetAccountInfoRequest request;
644  request.mutable_ledger()->set_sequence(1);
645  BEAST_EXPECT(!needCurrentOrClosed(request));
646  request.mutable_ledger()->set_hash("");
647  BEAST_EXPECT(!needCurrentOrClosed(request));
648  request.mutable_ledger()->set_shortcut(
649  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_VALIDATED);
650  BEAST_EXPECT(!needCurrentOrClosed(request));
651  request.mutable_ledger()->set_shortcut(
652  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_UNSPECIFIED);
653  BEAST_EXPECT(!needCurrentOrClosed(request));
654  request.mutable_ledger()->set_shortcut(
655  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CURRENT);
656  BEAST_EXPECT(needCurrentOrClosed(request));
657  request.mutable_ledger()->set_shortcut(
658  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CLOSED);
659  BEAST_EXPECT(needCurrentOrClosed(request));
660  }
661 
662  {
663  org::xrpl::rpc::v1::GetLedgerRequest request;
664  request.mutable_ledger()->set_sequence(1);
665  BEAST_EXPECT(!needCurrentOrClosed(request));
666  request.mutable_ledger()->set_hash("");
667  BEAST_EXPECT(!needCurrentOrClosed(request));
668  request.mutable_ledger()->set_shortcut(
669  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_VALIDATED);
670  BEAST_EXPECT(!needCurrentOrClosed(request));
671  request.mutable_ledger()->set_shortcut(
672  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_UNSPECIFIED);
673  BEAST_EXPECT(!needCurrentOrClosed(request));
674  request.mutable_ledger()->set_shortcut(
675  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CURRENT);
676  BEAST_EXPECT(needCurrentOrClosed(request));
677  request.mutable_ledger()->set_shortcut(
678  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CLOSED);
679  BEAST_EXPECT(needCurrentOrClosed(request));
680  }
681 
682  {
683  org::xrpl::rpc::v1::GetLedgerDataRequest request;
684  request.mutable_ledger()->set_sequence(1);
685  BEAST_EXPECT(!needCurrentOrClosed(request));
686  request.mutable_ledger()->set_hash("");
687  BEAST_EXPECT(!needCurrentOrClosed(request));
688  request.mutable_ledger()->set_shortcut(
689  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_VALIDATED);
690  BEAST_EXPECT(!needCurrentOrClosed(request));
691  request.mutable_ledger()->set_shortcut(
692  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_UNSPECIFIED);
693  BEAST_EXPECT(!needCurrentOrClosed(request));
694  request.mutable_ledger()->set_shortcut(
695  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CURRENT);
696  BEAST_EXPECT(needCurrentOrClosed(request));
697  request.mutable_ledger()->set_shortcut(
698  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CLOSED);
699  BEAST_EXPECT(needCurrentOrClosed(request));
700  }
701 
702  {
703  org::xrpl::rpc::v1::GetLedgerEntryRequest request;
704  request.mutable_ledger()->set_sequence(1);
705  BEAST_EXPECT(!needCurrentOrClosed(request));
706  request.mutable_ledger()->set_hash("");
707  BEAST_EXPECT(!needCurrentOrClosed(request));
708  request.mutable_ledger()->set_shortcut(
709  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_VALIDATED);
710  BEAST_EXPECT(!needCurrentOrClosed(request));
711  request.mutable_ledger()->set_shortcut(
712  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_UNSPECIFIED);
713  BEAST_EXPECT(!needCurrentOrClosed(request));
714  request.mutable_ledger()->set_shortcut(
715  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CURRENT);
716  BEAST_EXPECT(needCurrentOrClosed(request));
717  request.mutable_ledger()->set_shortcut(
718  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CLOSED);
719  BEAST_EXPECT(needCurrentOrClosed(request));
720  }
721 
722  {
723  org::xrpl::rpc::v1::GetLedgerDiffRequest request;
724 
725  // set desired ledger, so desired ledger does not need current or
726  // closed
727  request.mutable_base_ledger()->set_shortcut(
728  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_VALIDATED);
729 
730  request.mutable_base_ledger()->set_sequence(1);
731  BEAST_EXPECT(!needCurrentOrClosed(request));
732  request.mutable_base_ledger()->set_hash("");
733  BEAST_EXPECT(!needCurrentOrClosed(request));
734  request.mutable_base_ledger()->set_shortcut(
735  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_VALIDATED);
736  BEAST_EXPECT(!needCurrentOrClosed(request));
737  request.mutable_base_ledger()->set_shortcut(
738  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_UNSPECIFIED);
739  BEAST_EXPECT(!needCurrentOrClosed(request));
740  request.mutable_base_ledger()->set_shortcut(
741  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CURRENT);
742  BEAST_EXPECT(needCurrentOrClosed(request));
743  request.mutable_base_ledger()->set_shortcut(
744  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CLOSED);
745  BEAST_EXPECT(needCurrentOrClosed(request));
746 
747  // reset base ledger, so base ledger doesn't need current or closed
748  request.mutable_base_ledger()->set_shortcut(
749  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_VALIDATED);
750 
751  request.mutable_desired_ledger()->set_sequence(1);
752  BEAST_EXPECT(!needCurrentOrClosed(request));
753  request.mutable_desired_ledger()->set_hash("");
754  BEAST_EXPECT(!needCurrentOrClosed(request));
755  request.mutable_desired_ledger()->set_shortcut(
756  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_VALIDATED);
757  BEAST_EXPECT(!needCurrentOrClosed(request));
758  request.mutable_desired_ledger()->set_shortcut(
759  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_UNSPECIFIED);
760  BEAST_EXPECT(!needCurrentOrClosed(request));
761  request.mutable_desired_ledger()->set_shortcut(
762  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CURRENT);
763  BEAST_EXPECT(needCurrentOrClosed(request));
764  request.mutable_desired_ledger()->set_shortcut(
765  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CLOSED);
766  BEAST_EXPECT(needCurrentOrClosed(request));
767 
768  // both base and desired need current or closed
769  request.mutable_base_ledger()->set_shortcut(
770  org::xrpl::rpc::v1::LedgerSpecifier::SHORTCUT_CURRENT);
771  BEAST_EXPECT(needCurrentOrClosed(request));
772  }
773 
774  {
775  org::xrpl::rpc::v1::GetFeeRequest feeRequest;
776  BEAST_EXPECT(!needCurrentOrClosed(feeRequest));
777 
778  org::xrpl::rpc::v1::GetAccountTransactionHistoryRequest
779  accountTxRequest;
780  BEAST_EXPECT(!needCurrentOrClosed(accountTxRequest));
781 
782  org::xrpl::rpc::v1::GetTransactionRequest txRequest;
783  BEAST_EXPECT(!needCurrentOrClosed(txRequest));
784  }
785  }
786 
787  void
788  testSecureGateway()
789  {
790  testcase("SecureGateway");
791  using namespace test::jtx;
792  {
793  std::unique_ptr<Config> config = envconfig(
794  addGrpcConfigWithSecureGateway, getEnvLocalhostAddr());
795  std::string grpcPort =
796  *(*config)["port_grpc"].get<std::string>("port");
797  Env env(*this, std::move(config));
798 
799  env.close();
800 
801  auto ledger = env.app().getLedgerMaster().getLedgerBySeq(3);
802 
803  BEAST_EXPECT(env.current()->info().seq == 4);
804 
805  auto grpcLedger = [&grpcPort](
806  auto sequence,
807  std::string const& clientIp,
808  std::string const& user) {
809  GrpcLedgerClient grpcClient{grpcPort};
810 
811  grpcClient.request.mutable_ledger()->set_sequence(sequence);
812  grpcClient.request.set_client_ip(clientIp);
813  grpcClient.request.set_user(user);
814 
815  grpcClient.GetLedger();
816  return std::make_pair(grpcClient.status, grpcClient.reply);
817  };
818 
819  {
820  auto [status, reply] =
821  grpcLedger(env.current()->info().seq, "", "");
822  BEAST_EXPECT(!reply.is_unlimited());
823  BEAST_EXPECT(status.ok());
824  }
825  {
826  auto [status, reply] =
827  grpcLedger(env.current()->info().seq, "", "ETL");
828  BEAST_EXPECT(reply.is_unlimited());
829  BEAST_EXPECT(status.ok());
830  }
831  {
832  auto [status, reply] =
833  grpcLedger(env.current()->info().seq, "", "Reporting");
834  BEAST_EXPECT(reply.is_unlimited());
835  BEAST_EXPECT(status.ok());
836  }
837  {
838  auto [status, reply] =
839  grpcLedger(env.current()->info().seq, "127.0.0.1", "ETL");
840  BEAST_EXPECT(!reply.is_unlimited());
841  BEAST_EXPECT(status.ok());
842  }
843  {
844  auto [status, reply] =
845  grpcLedger(env.current()->info().seq, "127.0.0.1", "");
846  BEAST_EXPECT(!reply.is_unlimited());
847  BEAST_EXPECT(status.ok());
848  }
849  }
850 
851  {
852  std::string secureGatewayIp = "44.124.234.79";
853  std::unique_ptr<Config> config =
854  envconfig(addGrpcConfigWithSecureGateway, secureGatewayIp);
855  std::string grpcPort =
856  *(*config)["port_grpc"].get<std::string>("port");
857  Env env(*this, std::move(config));
858 
859  env.close();
860 
861  auto ledger = env.app().getLedgerMaster().getLedgerBySeq(3);
862 
863  BEAST_EXPECT(env.current()->info().seq == 4);
864 
865  auto grpcLedger = [&grpcPort](
866  auto sequence,
867  std::string const& clientIp,
868  std::string const& user) {
869  GrpcLedgerClient grpcClient{grpcPort};
870 
871  grpcClient.request.mutable_ledger()->set_sequence(sequence);
872  grpcClient.request.set_client_ip(clientIp);
873  grpcClient.request.set_user(user);
874 
875  grpcClient.GetLedger();
876  return std::make_pair(grpcClient.status, grpcClient.reply);
877  };
878 
879  {
880  auto [status, reply] =
881  grpcLedger(env.current()->info().seq, "", "");
882  BEAST_EXPECT(!reply.is_unlimited());
883  BEAST_EXPECT(status.ok());
884  }
885  {
886  auto [status, reply] =
887  grpcLedger(env.current()->info().seq, "", "ETL");
888  BEAST_EXPECT(!reply.is_unlimited());
889  BEAST_EXPECT(status.ok());
890  }
891  {
892  auto [status, reply] = grpcLedger(
893  env.current()->info().seq, secureGatewayIp, "ETL");
894  BEAST_EXPECT(!reply.is_unlimited());
895  BEAST_EXPECT(status.ok());
896  }
897  {
898  auto [status, reply] =
899  grpcLedger(env.current()->info().seq, secureGatewayIp, "");
900  BEAST_EXPECT(!reply.is_unlimited());
901  BEAST_EXPECT(status.ok());
902  }
903  }
904 
905  {
906  std::unique_ptr<Config> config = envconfig(
907  addGrpcConfigWithSecureGateway, getEnvLocalhostAddr());
908  std::string grpcPort =
909  *(*config)["port_grpc"].get<std::string>("port");
910  Env env(*this, std::move(config));
911 
912  env.close();
913 
914  auto ledger = env.app().getLedgerMaster().getLedgerBySeq(3);
915 
916  BEAST_EXPECT(env.current()->info().seq == 4);
917  auto grpcLedgerData = [&grpcPort](
918  auto sequence,
919  std::string const& clientIp,
920  std::string const& user) {
921  GrpcLedgerDataClient grpcClient{grpcPort};
922 
923  grpcClient.request.mutable_ledger()->set_sequence(sequence);
924  grpcClient.request.set_client_ip(clientIp);
925  grpcClient.request.set_user(user);
926 
927  grpcClient.GetLedgerData();
928  return std::make_pair(grpcClient.status, grpcClient.reply);
929  };
930  {
931  auto [status, reply] =
932  grpcLedgerData(env.current()->info().seq, "", "");
933  BEAST_EXPECT(!reply.is_unlimited());
934  BEAST_EXPECT(status.ok());
935  }
936  {
937  auto [status, reply] =
938  grpcLedgerData(env.current()->info().seq, "", "ETL");
939  BEAST_EXPECT(reply.is_unlimited());
940  BEAST_EXPECT(status.ok());
941  }
942  {
943  auto [status, reply] =
944  grpcLedgerData(env.current()->info().seq, "", "Reporting");
945  BEAST_EXPECT(reply.is_unlimited());
946  BEAST_EXPECT(status.ok());
947  }
948  {
949  auto [status, reply] = grpcLedgerData(
950  env.current()->info().seq, "127.0.0.1", "ETL");
951  BEAST_EXPECT(!reply.is_unlimited());
952  BEAST_EXPECT(status.ok());
953  }
954  {
955  auto [status, reply] =
956  grpcLedgerData(env.current()->info().seq, "127.0.0.1", "");
957  BEAST_EXPECT(!reply.is_unlimited());
958  BEAST_EXPECT(status.ok());
959  }
960  }
961  {
962  std::string secureGatewayIp = "44.124.234.79";
963  std::unique_ptr<Config> config =
964  envconfig(addGrpcConfigWithSecureGateway, secureGatewayIp);
965  std::string grpcPort =
966  *(*config)["port_grpc"].get<std::string>("port");
967  Env env(*this, std::move(config));
968 
969  env.close();
970 
971  auto ledger = env.app().getLedgerMaster().getLedgerBySeq(3);
972 
973  BEAST_EXPECT(env.current()->info().seq == 4);
974 
975  auto grpcLedgerData = [&grpcPort](
976  auto sequence,
977  std::string const& clientIp,
978  std::string const& user) {
979  GrpcLedgerDataClient grpcClient{grpcPort};
980 
981  grpcClient.request.mutable_ledger()->set_sequence(sequence);
982  grpcClient.request.set_client_ip(clientIp);
983  grpcClient.request.set_user(user);
984 
985  grpcClient.GetLedgerData();
986  return std::make_pair(grpcClient.status, grpcClient.reply);
987  };
988 
989  {
990  auto [status, reply] =
991  grpcLedgerData(env.current()->info().seq, "", "");
992  BEAST_EXPECT(!reply.is_unlimited());
993  BEAST_EXPECT(status.ok());
994  }
995  {
996  auto [status, reply] =
997  grpcLedgerData(env.current()->info().seq, "", "ETL");
998  BEAST_EXPECT(!reply.is_unlimited());
999  BEAST_EXPECT(status.ok());
1000  }
1001  {
1002  auto [status, reply] = grpcLedgerData(
1003  env.current()->info().seq, secureGatewayIp, "ETL");
1004  BEAST_EXPECT(!reply.is_unlimited());
1005  BEAST_EXPECT(status.ok());
1006  }
1007  {
1008  auto [status, reply] = grpcLedgerData(
1009  env.current()->info().seq, secureGatewayIp, "");
1010  BEAST_EXPECT(!reply.is_unlimited());
1011  BEAST_EXPECT(status.ok());
1012  }
1013  }
1014  }
1015 
1016 public:
1017  void
1018  run() override
1019  {
1020  testGetLedger();
1021 
1022  testGetLedgerData();
1023 
1024  testGetLedgerDiff();
1025 
1026  testGetLedgerEntry();
1027 
1028  testNeedCurrentOrClosed();
1029 
1030  testSecureGateway();
1031  }
1032 };
1033 
1034 BEAST_DEFINE_TESTSUITE(ReportingETL, app, ripple);
1035 
1036 } // namespace test
1037 } // namespace ripple
ripple::test::ReportingETL_test::GrpcLedgerDiffClient::request
org::xrpl::rpc::v1::GetLedgerDiffRequest request
Definition: ReportingETL_test.cpp:469
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:1018
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
ripple::test::BEAST_DEFINE_TESTSUITE
BEAST_DEFINE_TESTSUITE(AccountDelete, app, ripple)
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:485
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:43
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:639
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:470
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::ReportingETL_test::GrpcLedgerDiffClient::GetLedgerDiff
void GetLedgerDiff()
Definition: ReportingETL_test.cpp:478
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:587
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:581
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:34
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:223
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:472
ripple::test::ReportingETL_test::testSecureGateway
void testSecureGateway()
Definition: ReportingETL_test.cpp:788
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:600
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:585
ripple::test::ReportingETL_test::GrpcLedgerEntryClient::request
org::xrpl::rpc::v1::GetLedgerEntryRequest request
Definition: ReportingETL_test.cpp:584
std::numeric_limits::max
T max(T... args)
std::unique_ptr
STL class.
ripple::test::ReportingETL_test::GrpcLedgerDiffClient
Definition: ReportingETL_test.cpp:466
ripple::test::jtx::Env
A transaction testing environment.
Definition: Env.h:115
ripple::test::ReportingETL_test::GrpcLedgerEntryClient::GetLedgerEntry
void GetLedgerEntry()
Definition: ReportingETL_test.cpp:593
Generated by   doxygen 1.8.17