ARCHIVE/hpcore
1
0
Fork 0
mirror of https://github.com/EvernodeXRPL/hpcore.git synced 2026-04-29 15:37:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

Introducing ledger shards and new ledger syncing logic. (#247)

Browse Source 
- The ledgers are stored in a sqlite database in ledger file system.
- Ledgers are organized in shards inside primary folder.
- Raw inputs are saved as shards inside blob folder. No input files are created if neither inputs nor outputs are available.
- Both last primary shard hash and last blob shard hashes are subjected to consensus and necessary sync operations are performed if out of sync.
- Hpfs sync support setting single sync targets from both ends of the list. (Targets set from front are prioritized).
- Contract and ledger syncs and serving are performed independently.
This commit is contained in:
Savinda Senevirathne
2021-02-18 11:24:05 +05:30
committed by GitHub
parent e394497698
commit 16c5b3fae2
53 changed files with 1917 additions and 2317 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/msg/fbuf/fullhistory_schema.fbs
View File

@@ -1,14 +0,0 @@
namespace msg.fbuf.ledger;
table FullHistoryBlock {
version:string;
raw_inputs: [RawInput];
}
table RawInput {
hash:[ubyte];
pubkey:[ubyte];
input:[ubyte];
}
root_type FullHistoryBlock;

217
src/msg/fbuf/fullhistory_schema_generated.h
View File

@@ -1,217 +0,0 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_FULLHISTORYSCHEMA_MSG_FBUF_LEDGER_H_
#define FLATBUFFERS_GENERATED_FULLHISTORYSCHEMA_MSG_FBUF_LEDGER_H_
#include "flatbuffers/flatbuffers.h"
namespace msg {
namespace fbuf {
namespace ledger {
struct FullHistoryBlock;
struct FullHistoryBlockBuilder;
struct RawInput;
struct RawInputBuilder;
struct FullHistoryBlock FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef FullHistoryBlockBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_VERSION = 4,
VT_RAW_INPUTS = 6
};
const flatbuffers::String *version() const {
return GetPointer<const flatbuffers::String *>(VT_VERSION);
}
flatbuffers::String *mutable_version() {
return GetPointer<flatbuffers::String *>(VT_VERSION);
}
const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledger::RawInput>> *raw_inputs() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledger::RawInput>> *>(VT_RAW_INPUTS);
}
flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledger::RawInput>> *mutable_raw_inputs() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledger::RawInput>> *>(VT_RAW_INPUTS);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_VERSION) &&
verifier.VerifyString(version()) &&
VerifyOffset(verifier, VT_RAW_INPUTS) &&
verifier.VerifyVector(raw_inputs()) &&
verifier.VerifyVectorOfTables(raw_inputs()) &&
verifier.EndTable();
}
};
struct FullHistoryBlockBuilder {
typedef FullHistoryBlock Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_version(flatbuffers::Offset<flatbuffers::String> version) {
fbb_.AddOffset(FullHistoryBlock::VT_VERSION, version);
}
void add_raw_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledger::RawInput>>> raw_inputs) {
fbb_.AddOffset(FullHistoryBlock::VT_RAW_INPUTS, raw_inputs);
}
explicit FullHistoryBlockBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<FullHistoryBlock> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<FullHistoryBlock>(end);
return o;
}
};
inline flatbuffers::Offset<FullHistoryBlock> CreateFullHistoryBlock(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::String> version = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledger::RawInput>>> raw_inputs = 0) {
FullHistoryBlockBuilder builder_(_fbb);
builder_.add_raw_inputs(raw_inputs);
builder_.add_version(version);
return builder_.Finish();
}
inline flatbuffers::Offset<FullHistoryBlock> CreateFullHistoryBlockDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const char *version = nullptr,
const std::vector<flatbuffers::Offset<msg::fbuf::ledger::RawInput>> *raw_inputs = nullptr) {
auto version__ = version ? _fbb.CreateString(version) : 0;
auto raw_inputs__ = raw_inputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ledger::RawInput>>(*raw_inputs) : 0;
return msg::fbuf::ledger::CreateFullHistoryBlock(
_fbb,
version__,
raw_inputs__);
}
struct RawInput FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef RawInputBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_HASH = 4,
VT_PUBKEY = 6,
VT_INPUT = 8
};
const flatbuffers::Vector<uint8_t> *hash() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_HASH);
}
flatbuffers::Vector<uint8_t> *mutable_hash() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_HASH);
}
const flatbuffers::Vector<uint8_t> *pubkey() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_PUBKEY);
}
flatbuffers::Vector<uint8_t> *mutable_pubkey() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_PUBKEY);
}
const flatbuffers::Vector<uint8_t> *input() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_INPUT);
}
flatbuffers::Vector<uint8_t> *mutable_input() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_INPUT);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_HASH) &&
verifier.VerifyVector(hash()) &&
VerifyOffset(verifier, VT_PUBKEY) &&
verifier.VerifyVector(pubkey()) &&
VerifyOffset(verifier, VT_INPUT) &&
verifier.VerifyVector(input()) &&
verifier.EndTable();
}
};
struct RawInputBuilder {
typedef RawInput Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_hash(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> hash) {
fbb_.AddOffset(RawInput::VT_HASH, hash);
}
void add_pubkey(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey) {
fbb_.AddOffset(RawInput::VT_PUBKEY, pubkey);
}
void add_input(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> input) {
fbb_.AddOffset(RawInput::VT_INPUT, input);
}
explicit RawInputBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<RawInput> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<RawInput>(end);
return o;
}
};
inline flatbuffers::Offset<RawInput> CreateRawInput(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> hash = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> input = 0) {
RawInputBuilder builder_(_fbb);
builder_.add_input(input);
builder_.add_pubkey(pubkey);
builder_.add_hash(hash);
return builder_.Finish();
}
inline flatbuffers::Offset<RawInput> CreateRawInputDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *hash = nullptr,
const std::vector<uint8_t> *pubkey = nullptr,
const std::vector<uint8_t> *input = nullptr) {
auto hash__ = hash ? _fbb.CreateVector<uint8_t>(*hash) : 0;
auto pubkey__ = pubkey ? _fbb.CreateVector<uint8_t>(*pubkey) : 0;
auto input__ = input ? _fbb.CreateVector<uint8_t>(*input) : 0;
return msg::fbuf::ledger::CreateRawInput(
_fbb,
hash__,
pubkey__,
input__);
}
inline const msg::fbuf::ledger::FullHistoryBlock *GetFullHistoryBlock(const void *buf) {
return flatbuffers::GetRoot<msg::fbuf::ledger::FullHistoryBlock>(buf);
}
inline const msg::fbuf::ledger::FullHistoryBlock *GetSizePrefixedFullHistoryBlock(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<msg::fbuf::ledger::FullHistoryBlock>(buf);
}
inline FullHistoryBlock *GetMutableFullHistoryBlock(void *buf) {
return flatbuffers::GetMutableRoot<FullHistoryBlock>(buf);
}
inline bool VerifyFullHistoryBlockBuffer(
flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<msg::fbuf::ledger::FullHistoryBlock>(nullptr);
}
inline bool VerifySizePrefixedFullHistoryBlockBuffer(
flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<msg::fbuf::ledger::FullHistoryBlock>(nullptr);
}
inline void FinishFullHistoryBlockBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<msg::fbuf::ledger::FullHistoryBlock> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedFullHistoryBlockBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<msg::fbuf::ledger::FullHistoryBlock> root) {
fbb.FinishSizePrefixed(root);
}
} // namespace ledger
} // namespace fbuf
} // namespace msg
#endif // FLATBUFFERS_GENERATED_FULLHISTORYSCHEMA_MSG_FBUF_LEDGER_H_

27
src/msg/fbuf/ledger_blob_schema.fbs Normal file
View File

@@ -0,0 +1,27 @@
namespace msg.fbuf.ledgermsg;
table LedgerBlob {
ledger_hash:[ubyte];
raw_inputs:[RawInputCollection];
raw_outputs:[RawOutputCollection];
}
table RawInputCollection {
pubkey:[ubyte];
inputs:[RawInput];
}
table RawInput {
input: [ubyte];
}
table RawOutputCollection {
pubkey:[ubyte];
outputs:[RawOutput];
}
table RawOutput {
output: [ubyte];
}
root_type LedgerBlob;

408
src/msg/fbuf/ledger_blob_schema_generated.h Normal file
View File

@@ -0,0 +1,408 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_LEDGERBLOBSCHEMA_MSG_FBUF_LEDGERMSG_H_
#define FLATBUFFERS_GENERATED_LEDGERBLOBSCHEMA_MSG_FBUF_LEDGERMSG_H_
#include "flatbuffers/flatbuffers.h"
namespace msg {
namespace fbuf {
namespace ledgermsg {
struct LedgerBlob;
struct LedgerBlobBuilder;
struct RawInputCollection;
struct RawInputCollectionBuilder;
struct RawInput;
struct RawInputBuilder;
struct RawOutputCollection;
struct RawOutputCollectionBuilder;
struct RawOutput;
struct RawOutputBuilder;
struct LedgerBlob FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef LedgerBlobBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_LEDGER_HASH = 4,
VT_RAW_INPUTS = 6,
VT_RAW_OUTPUTS = 8
};
const flatbuffers::Vector<uint8_t> *ledger_hash() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_LEDGER_HASH);
}
flatbuffers::Vector<uint8_t> *mutable_ledger_hash() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_LEDGER_HASH);
}
const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInputCollection>> *raw_inputs() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInputCollection>> *>(VT_RAW_INPUTS);
}
flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInputCollection>> *mutable_raw_inputs() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInputCollection>> *>(VT_RAW_INPUTS);
}
const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutputCollection>> *raw_outputs() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutputCollection>> *>(VT_RAW_OUTPUTS);
}
flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutputCollection>> *mutable_raw_outputs() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutputCollection>> *>(VT_RAW_OUTPUTS);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_LEDGER_HASH) &&
verifier.VerifyVector(ledger_hash()) &&
VerifyOffset(verifier, VT_RAW_INPUTS) &&
verifier.VerifyVector(raw_inputs()) &&
verifier.VerifyVectorOfTables(raw_inputs()) &&
VerifyOffset(verifier, VT_RAW_OUTPUTS) &&
verifier.VerifyVector(raw_outputs()) &&
verifier.VerifyVectorOfTables(raw_outputs()) &&
verifier.EndTable();
}
};
struct LedgerBlobBuilder {
typedef LedgerBlob Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_ledger_hash(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> ledger_hash) {
fbb_.AddOffset(LedgerBlob::VT_LEDGER_HASH, ledger_hash);
}
void add_raw_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInputCollection>>> raw_inputs) {
fbb_.AddOffset(LedgerBlob::VT_RAW_INPUTS, raw_inputs);
}
void add_raw_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutputCollection>>> raw_outputs) {
fbb_.AddOffset(LedgerBlob::VT_RAW_OUTPUTS, raw_outputs);
}
explicit LedgerBlobBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<LedgerBlob> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<LedgerBlob>(end);
return o;
}
};
inline flatbuffers::Offset<LedgerBlob> CreateLedgerBlob(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> ledger_hash = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInputCollection>>> raw_inputs = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutputCollection>>> raw_outputs = 0) {
LedgerBlobBuilder builder_(_fbb);
builder_.add_raw_outputs(raw_outputs);
builder_.add_raw_inputs(raw_inputs);
builder_.add_ledger_hash(ledger_hash);
return builder_.Finish();
}
inline flatbuffers::Offset<LedgerBlob> CreateLedgerBlobDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *ledger_hash = nullptr,
const std::vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInputCollection>> *raw_inputs = nullptr,
const std::vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutputCollection>> *raw_outputs = nullptr) {
auto ledger_hash__ = ledger_hash ? _fbb.CreateVector<uint8_t>(*ledger_hash) : 0;
auto raw_inputs__ = raw_inputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInputCollection>>(*raw_inputs) : 0;
auto raw_outputs__ = raw_outputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutputCollection>>(*raw_outputs) : 0;
return msg::fbuf::ledgermsg::CreateLedgerBlob(
_fbb,
ledger_hash__,
raw_inputs__,
raw_outputs__);
}
struct RawInputCollection FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef RawInputCollectionBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_PUBKEY = 4,
VT_INPUTS = 6
};
const flatbuffers::Vector<uint8_t> *pubkey() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_PUBKEY);
}
flatbuffers::Vector<uint8_t> *mutable_pubkey() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_PUBKEY);
}
const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInput>> *inputs() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInput>> *>(VT_INPUTS);
}
flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInput>> *mutable_inputs() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInput>> *>(VT_INPUTS);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_PUBKEY) &&
verifier.VerifyVector(pubkey()) &&
VerifyOffset(verifier, VT_INPUTS) &&
verifier.VerifyVector(inputs()) &&
verifier.VerifyVectorOfTables(inputs()) &&
verifier.EndTable();
}
};
struct RawInputCollectionBuilder {
typedef RawInputCollection Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_pubkey(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey) {
fbb_.AddOffset(RawInputCollection::VT_PUBKEY, pubkey);
}
void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInput>>> inputs) {
fbb_.AddOffset(RawInputCollection::VT_INPUTS, inputs);
}
explicit RawInputCollectionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<RawInputCollection> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<RawInputCollection>(end);
return o;
}
};
inline flatbuffers::Offset<RawInputCollection> CreateRawInputCollection(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInput>>> inputs = 0) {
RawInputCollectionBuilder builder_(_fbb);
builder_.add_inputs(inputs);
builder_.add_pubkey(pubkey);
return builder_.Finish();
}
inline flatbuffers::Offset<RawInputCollection> CreateRawInputCollectionDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *pubkey = nullptr,
const std::vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInput>> *inputs = nullptr) {
auto pubkey__ = pubkey ? _fbb.CreateVector<uint8_t>(*pubkey) : 0;
auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInput>>(*inputs) : 0;
return msg::fbuf::ledgermsg::CreateRawInputCollection(
_fbb,
pubkey__,
inputs__);
}
struct RawInput FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef RawInputBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_INPUT = 4
};
const flatbuffers::Vector<uint8_t> *input() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_INPUT);
}
flatbuffers::Vector<uint8_t> *mutable_input() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_INPUT);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_INPUT) &&
verifier.VerifyVector(input()) &&
verifier.EndTable();
}
};
struct RawInputBuilder {
typedef RawInput Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_input(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> input) {
fbb_.AddOffset(RawInput::VT_INPUT, input);
}
explicit RawInputBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<RawInput> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<RawInput>(end);
return o;
}
};
inline flatbuffers::Offset<RawInput> CreateRawInput(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> input = 0) {
RawInputBuilder builder_(_fbb);
builder_.add_input(input);
return builder_.Finish();
}
inline flatbuffers::Offset<RawInput> CreateRawInputDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *input = nullptr) {
auto input__ = input ? _fbb.CreateVector<uint8_t>(*input) : 0;
return msg::fbuf::ledgermsg::CreateRawInput(
_fbb,
input__);
}
struct RawOutputCollection FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef RawOutputCollectionBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_PUBKEY = 4,
VT_OUTPUTS = 6
};
const flatbuffers::Vector<uint8_t> *pubkey() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_PUBKEY);
}
flatbuffers::Vector<uint8_t> *mutable_pubkey() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_PUBKEY);
}
const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutput>> *outputs() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutput>> *>(VT_OUTPUTS);
}
flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutput>> *mutable_outputs() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutput>> *>(VT_OUTPUTS);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_PUBKEY) &&
verifier.VerifyVector(pubkey()) &&
VerifyOffset(verifier, VT_OUTPUTS) &&
verifier.VerifyVector(outputs()) &&
verifier.VerifyVectorOfTables(outputs()) &&
verifier.EndTable();
}
};
struct RawOutputCollectionBuilder {
typedef RawOutputCollection Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_pubkey(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey) {
fbb_.AddOffset(RawOutputCollection::VT_PUBKEY, pubkey);
}
void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutput>>> outputs) {
fbb_.AddOffset(RawOutputCollection::VT_OUTPUTS, outputs);
}
explicit RawOutputCollectionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<RawOutputCollection> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<RawOutputCollection>(end);
return o;
}
};
inline flatbuffers::Offset<RawOutputCollection> CreateRawOutputCollection(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutput>>> outputs = 0) {
RawOutputCollectionBuilder builder_(_fbb);
builder_.add_outputs(outputs);
builder_.add_pubkey(pubkey);
return builder_.Finish();
}
inline flatbuffers::Offset<RawOutputCollection> CreateRawOutputCollectionDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *pubkey = nullptr,
const std::vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutput>> *outputs = nullptr) {
auto pubkey__ = pubkey ? _fbb.CreateVector<uint8_t>(*pubkey) : 0;
auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutput>>(*outputs) : 0;
return msg::fbuf::ledgermsg::CreateRawOutputCollection(
_fbb,
pubkey__,
outputs__);
}
struct RawOutput FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef RawOutputBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_OUTPUT = 4
};
const flatbuffers::Vector<uint8_t> *output() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_OUTPUT);
}
flatbuffers::Vector<uint8_t> *mutable_output() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_OUTPUT);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_OUTPUT) &&
verifier.VerifyVector(output()) &&
verifier.EndTable();
}
};
struct RawOutputBuilder {
typedef RawOutput Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_output(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> output) {
fbb_.AddOffset(RawOutput::VT_OUTPUT, output);
}
explicit RawOutputBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<RawOutput> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<RawOutput>(end);
return o;
}
};
inline flatbuffers::Offset<RawOutput> CreateRawOutput(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> output = 0) {
RawOutputBuilder builder_(_fbb);
builder_.add_output(output);
return builder_.Finish();
}
inline flatbuffers::Offset<RawOutput> CreateRawOutputDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *output = nullptr) {
auto output__ = output ? _fbb.CreateVector<uint8_t>(*output) : 0;
return msg::fbuf::ledgermsg::CreateRawOutput(
_fbb,
output__);
}
inline const msg::fbuf::ledgermsg::LedgerBlob *GetLedgerBlob(const void *buf) {
return flatbuffers::GetRoot<msg::fbuf::ledgermsg::LedgerBlob>(buf);
}
inline const msg::fbuf::ledgermsg::LedgerBlob *GetSizePrefixedLedgerBlob(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<msg::fbuf::ledgermsg::LedgerBlob>(buf);
}
inline LedgerBlob *GetMutableLedgerBlob(void *buf) {
return flatbuffers::GetMutableRoot<LedgerBlob>(buf);
}
inline bool VerifyLedgerBlobBuffer(
flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<msg::fbuf::ledgermsg::LedgerBlob>(nullptr);
}
inline bool VerifySizePrefixedLedgerBlobBuffer(
flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<msg::fbuf::ledgermsg::LedgerBlob>(nullptr);
}
inline void FinishLedgerBlobBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<msg::fbuf::ledgermsg::LedgerBlob> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedLedgerBlobBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<msg::fbuf::ledgermsg::LedgerBlob> root) {
fbb.FinishSizePrefixed(root);
}
} // namespace ledgermsg
} // namespace fbuf
} // namespace msg
#endif // FLATBUFFERS_GENERATED_LEDGERBLOBSCHEMA_MSG_FBUF_LEDGERMSG_H_

80
src/msg/fbuf/ledger_helpers.cpp
View File

@@ -1,11 +1,11 @@
#include "../../pchheader.hpp"
#include "../../p2p/p2p.hpp"
#include "ledger_schema_generated.h"
#include "fullhistory_schema_generated.h"
#include "ledger_blob_schema_generated.h"
#include "common_helpers.hpp"
#include "ledger_helpers.hpp"
namespace msg::fbuf::ledger
namespace msg::fbuf::ledgermsg
{
/**
* Create ledger block from the given proposal struct.
@@ -13,8 +13,8 @@ namespace msg::fbuf::ledger
*/
void create_ledger_block_from_proposal(flatbuffers::FlatBufferBuilder &builder, const p2p::proposal &p, const uint64_t seq_no)
{
flatbuffers::Offset<ledger::LedgerBlock> ledger =
ledger::CreateLedgerBlock(
flatbuffers::Offset<ledgermsg::LedgerBlock> ledger =
ledgermsg::CreateLedgerBlock(
builder,
sv_to_flatbuff_str(builder, conf::cfg.hp_version),
seq_no,
@@ -31,7 +31,7 @@ namespace msg::fbuf::ledger
p2p::proposal create_proposal_from_ledger_block(const std::vector<uint8_t> &ledger_buf)
{
auto ledger = msg::fbuf::ledger::GetLedgerBlock(ledger_buf.data());
auto ledger = msg::fbuf::ledgermsg::GetLedgerBlock(ledger_buf.data());
p2p::proposal p;
p.lcl = flatbuff_bytes_to_sv(ledger->lcl());
p.state_hash = flatbuff_bytes_to_hash(ledger->state_hash());
@@ -47,45 +47,51 @@ namespace msg::fbuf::ledger
}
/**
* Create full history block from the given raw input map.
* @param map The raw input map to be placed in full history.
* Create ledger blob msg from ledger blob struct.
* @param ledger_blob Ledger blob to be placed in file.
*/
void create_full_history_block_from_raw_input_map(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map<std::string, usr::raw_user_input> &map)
void create_ledger_blob_msg_from_ledger_blob(flatbuffers::FlatBufferBuilder &builder, const ledger::ledger_blob &ledger_blob)
{
std::vector<flatbuffers::Offset<msg::fbuf::ledger::RawInput>> fbvec;
fbvec.reserve(map.size());
for (auto const &[key, value] : map)
std::vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInputCollection>> raw_inputs;
raw_inputs.reserve(ledger_blob.inputs.size());
std::vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutputCollection>> raw_outputs;
raw_outputs.reserve(ledger_blob.outputs.size());
for (const auto &[key, value] : ledger_blob.inputs)
{
fbvec.push_back(ledger::CreateRawInput(
std::vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawInput>> inputs;
inputs.reserve(value.size());
for (const auto &input : value)
inputs.push_back(ledgermsg::CreateRawInput(builder, sv_to_flatbuff_bytes(builder, input)));
raw_inputs.push_back(ledgermsg::CreateRawInputCollection(
builder,
sv_to_flatbuff_bytes(builder, key),
sv_to_flatbuff_bytes(builder, value.pubkey),
sv_to_flatbuff_bytes(builder, value.input)));
builder.CreateVector(inputs)));
}
flatbuffers::Offset<ledger::FullHistoryBlock> fullhistory =
ledger::CreateFullHistoryBlock(
builder,
sv_to_flatbuff_str(builder, conf::cfg.hp_version),
builder.CreateVector(fbvec));
builder.Finish(fullhistory); // Finished building message content to get serialised content.
}
const std::unordered_map<std::string, usr::raw_user_input> create_raw_input_map_from_full_history_block(const std::vector<uint8_t> &fullhist_buf)
{
const auto fullhistory = msg::fbuf::ledger::GetFullHistoryBlock(fullhist_buf.data());
const auto fbvec = fullhistory->raw_inputs();
std::unordered_map<std::string, usr::raw_user_input> map;
map.reserve(fbvec->size());
for (auto el : *fbvec)
for (const auto &[key, value] : ledger_blob.outputs)
{
map.emplace(flatbuff_bytes_to_sv(el->hash()),
usr::raw_user_input{
std::string(flatbuff_bytes_to_sv(el->pubkey())),
std::string(flatbuff_bytes_to_sv(el->input()))});
std::vector<flatbuffers::Offset<msg::fbuf::ledgermsg::RawOutput>> outputs;
outputs.reserve(value.size());
for (const auto &output : value)
outputs.push_back(ledgermsg::CreateRawOutput(builder, sv_to_flatbuff_bytes(builder, output)));
raw_outputs.push_back(ledgermsg::CreateRawOutputCollection(
builder,
sv_to_flatbuff_bytes(builder, key),
builder.CreateVector(outputs)));
}
return map;
flatbuffers::Offset<ledgermsg::LedgerBlob> blob =
ledgermsg::CreateLedgerBlob(
builder,
sv_to_flatbuff_bytes(builder, ledger_blob.ledger_hash),
builder.CreateVector(raw_inputs),
builder.CreateVector(raw_outputs));
builder.Finish(blob); // Finished building message content to get serialised content.
}
} // namespace msg::fbuf::ledger
} // namespace msg::fbuf::ledgermsg

8
src/msg/fbuf/ledger_helpers.hpp
View File

@@ -3,9 +3,10 @@
#include "../../pchheader.hpp"
#include "../../p2p/p2p.hpp"
#include "../../ledger/ledger.hpp"
#include "ledger_schema_generated.h"
namespace msg::fbuf::ledger
namespace msg::fbuf::ledgermsg
{
void create_ledger_block_from_proposal(flatbuffers::FlatBufferBuilder &builder, const p2p::proposal &p, const uint64_t seq_no);
@@ -14,9 +15,8 @@ namespace msg::fbuf::ledger
bool verify_ledger_block_buffer(const uint8_t *ledger_buf_ptr, const size_t buf_len);
void create_full_history_block_from_raw_input_map(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map<std::string, usr::raw_user_input> &map);
void create_ledger_blob_msg_from_ledger_blob(flatbuffers::FlatBufferBuilder &builder, const ledger::ledger_blob &ledger_blob);
const std::unordered_map<std::string, usr::raw_user_input> create_raw_input_map_from_full_history_block(const std::vector<uint8_t> &fullhist_buf);
} // namespace msg::fbuf::ledger
} // namespace msg::fbuf::ledgermsg
#endif

2
src/msg/fbuf/ledger_schema.fbs
View File

@@ -1,6 +1,6 @@
include "common_schema.fbs";
namespace msg.fbuf.ledger;
namespace msg.fbuf.ledgermsg;
table LedgerBlock {
version:string;

28
src/msg/fbuf/ledger_schema_generated.h
View File

@@ -1,8 +1,8 @@
// automatically generated by the FlatBuffers compiler, do not modify
#ifndef FLATBUFFERS_GENERATED_LEDGERSCHEMA_MSG_FBUF_LEDGER_H_
#define FLATBUFFERS_GENERATED_LEDGERSCHEMA_MSG_FBUF_LEDGER_H_
#ifndef FLATBUFFERS_GENERATED_LEDGERSCHEMA_MSG_FBUF_LEDGERMSG_H_
#define FLATBUFFERS_GENERATED_LEDGERSCHEMA_MSG_FBUF_LEDGERMSG_H_
#include "flatbuffers/flatbuffers.h"
@@ -10,7 +10,7 @@
namespace msg {
namespace fbuf {
namespace ledger {
namespace ledgermsg {
struct LedgerBlock;
struct LedgerBlockBuilder;
@@ -190,7 +190,7 @@ inline flatbuffers::Offset<LedgerBlock> CreateLedgerBlockDirect(
auto users__ = users ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*users) : 0;
auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::ByteArray>>(*inputs) : 0;
auto output__ = output ? _fbb.CreateVector<uint8_t>(*output) : 0;
return msg::fbuf::ledger::CreateLedgerBlock(
return msg::fbuf::ledgermsg::CreateLedgerBlock(
_fbb,
version__,
seq_no,
@@ -203,12 +203,12 @@ inline flatbuffers::Offset<LedgerBlock> CreateLedgerBlockDirect(
output__);
}
inline const msg::fbuf::ledger::LedgerBlock *GetLedgerBlock(const void *buf) {
return flatbuffers::GetRoot<msg::fbuf::ledger::LedgerBlock>(buf);
inline const msg::fbuf::ledgermsg::LedgerBlock *GetLedgerBlock(const void *buf) {
return flatbuffers::GetRoot<msg::fbuf::ledgermsg::LedgerBlock>(buf);
}
inline const msg::fbuf::ledger::LedgerBlock *GetSizePrefixedLedgerBlock(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<msg::fbuf::ledger::LedgerBlock>(buf);
inline const msg::fbuf::ledgermsg::LedgerBlock *GetSizePrefixedLedgerBlock(const void *buf) {
return flatbuffers::GetSizePrefixedRoot<msg::fbuf::ledgermsg::LedgerBlock>(buf);
}
inline LedgerBlock *GetMutableLedgerBlock(void *buf) {
@@ -217,28 +217,28 @@ inline LedgerBlock *GetMutableLedgerBlock(void *buf) {
inline bool VerifyLedgerBlockBuffer(
flatbuffers::Verifier &verifier) {
return verifier.VerifyBuffer<msg::fbuf::ledger::LedgerBlock>(nullptr);
return verifier.VerifyBuffer<msg::fbuf::ledgermsg::LedgerBlock>(nullptr);
}
inline bool VerifySizePrefixedLedgerBlockBuffer(
flatbuffers::Verifier &verifier) {
return verifier.VerifySizePrefixedBuffer<msg::fbuf::ledger::LedgerBlock>(nullptr);
return verifier.VerifySizePrefixedBuffer<msg::fbuf::ledgermsg::LedgerBlock>(nullptr);
}
inline void FinishLedgerBlockBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<msg::fbuf::ledger::LedgerBlock> root) {
flatbuffers::Offset<msg::fbuf::ledgermsg::LedgerBlock> root) {
fbb.Finish(root);
}
inline void FinishSizePrefixedLedgerBlockBuffer(
flatbuffers::FlatBufferBuilder &fbb,
flatbuffers::Offset<msg::fbuf::ledger::LedgerBlock> root) {
flatbuffers::Offset<msg::fbuf::ledgermsg::LedgerBlock> root) {
fbb.FinishSizePrefixed(root);
}
} // namespace ledger
} // namespace ledgermsg
} // namespace fbuf
} // namespace msg
#endif // FLATBUFFERS_GENERATED_LEDGERSCHEMA_MSG_FBUF_LEDGER_H_
#endif // FLATBUFFERS_GENERATED_LEDGERSCHEMA_MSG_FBUF_LEDGERMSG_H_

1
src/msg/fbuf/p2pmsg_container.fbs
View File

@@ -10,6 +10,7 @@ table Container { //root type for message
timestamp:uint64;
pubkey:[ubyte];
lcl:[ubyte];
last_primary_shard_id:Sequence_Hash;
signature:[ubyte]; // signature of the message content
content:[ubyte]; // message content: byte array of proposal,npl,etc
}

20
src/msg/fbuf/p2pmsg_container_generated.h
View File

@@ -23,8 +23,9 @@ struct Container FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_TIMESTAMP = 6,
VT_PUBKEY = 8,
VT_LCL = 10,
VT_SIGNATURE = 12,
VT_CONTENT = 14
VT_LAST_PRIMARY_SHARD_ID = 12,
VT_SIGNATURE = 14,
VT_CONTENT = 16
};
uint16_t version() const {
return GetField<uint16_t>(VT_VERSION, 0);
@@ -50,6 +51,12 @@ struct Container FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
flatbuffers::Vector<uint8_t> *mutable_lcl() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_LCL);
}
const msg::fbuf::p2pmsg::Sequence_Hash *last_primary_shard_id() const {
return GetPointer<const msg::fbuf::p2pmsg::Sequence_Hash *>(VT_LAST_PRIMARY_SHARD_ID);
}
msg::fbuf::p2pmsg::Sequence_Hash *mutable_last_primary_shard_id() {
return GetPointer<msg::fbuf::p2pmsg::Sequence_Hash *>(VT_LAST_PRIMARY_SHARD_ID);
}
const flatbuffers::Vector<uint8_t> *signature() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_SIGNATURE);
}
@@ -70,6 +77,8 @@ struct Container FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyVector(pubkey()) &&
VerifyOffset(verifier, VT_LCL) &&
verifier.VerifyVector(lcl()) &&
VerifyOffset(verifier, VT_LAST_PRIMARY_SHARD_ID) &&
verifier.VerifyTable(last_primary_shard_id()) &&
VerifyOffset(verifier, VT_SIGNATURE) &&
verifier.VerifyVector(signature()) &&
VerifyOffset(verifier, VT_CONTENT) &&
@@ -94,6 +103,9 @@ struct ContainerBuilder {
void add_lcl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl) {
fbb_.AddOffset(Container::VT_LCL, lcl);
}
void add_last_primary_shard_id(flatbuffers::Offset<msg::fbuf::p2pmsg::Sequence_Hash> last_primary_shard_id) {
fbb_.AddOffset(Container::VT_LAST_PRIMARY_SHARD_ID, last_primary_shard_id);
}
void add_signature(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> signature) {
fbb_.AddOffset(Container::VT_SIGNATURE, signature);
}
@@ -117,12 +129,14 @@ inline flatbuffers::Offset<Container> CreateContainer(
uint64_t timestamp = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> pubkey = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl = 0,
flatbuffers::Offset<msg::fbuf::p2pmsg::Sequence_Hash> last_primary_shard_id = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> signature = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> content = 0) {
ContainerBuilder builder_(_fbb);
builder_.add_timestamp(timestamp);
builder_.add_content(content);
builder_.add_signature(signature);
builder_.add_last_primary_shard_id(last_primary_shard_id);
builder_.add_lcl(lcl);
builder_.add_pubkey(pubkey);
builder_.add_version(version);
@@ -135,6 +149,7 @@ inline flatbuffers::Offset<Container> CreateContainerDirect(
uint64_t timestamp = 0,
const std::vector<uint8_t> *pubkey = nullptr,
const std::vector<uint8_t> *lcl = nullptr,
flatbuffers::Offset<msg::fbuf::p2pmsg::Sequence_Hash> last_primary_shard_id = 0,
const std::vector<uint8_t> *signature = nullptr,
const std::vector<uint8_t> *content = nullptr) {
auto pubkey__ = pubkey ? _fbb.CreateVector<uint8_t>(*pubkey) : 0;
@@ -147,6 +162,7 @@ inline flatbuffers::Offset<Container> CreateContainerDirect(
timestamp,
pubkey__,
lcl__,
last_primary_shard_id,
signature__,
content__);
}

28
src/msg/fbuf/p2pmsg_content.fbs
View File

@@ -34,8 +34,6 @@ union Message {
Npl_Message,
Hpfs_Request_Message,
Hpfs_Response_Message,
History_Request_Message,
History_Response_Message,
Peer_Requirement_Announcement_Message,
Peer_List_Request_Message,
Peer_List_Response_Message,
@@ -57,18 +55,20 @@ table Proposal_Message { //Proposal type message schema
nonce: [ubyte];
users:[ByteArray];
input_hashes:[ByteArray];
last_blob_shard_id: Sequence_Hash;
output_hash:[ubyte];
output_sig:[ubyte];
state_hash: [ubyte];
patch_hash: [ubyte];
}
table Npl_Message { //NPL type message schema
data:[ubyte];
table Sequence_Hash {
shard_seq_no: uint64;
shard_hash: [ubyte];
}
table History_Request_Message { //Ledger History request type message schema
required_lcl:[ubyte];
table Npl_Message { //NPL type message schema
data:[ubyte];
}
enum Ledger_Response_Error : ubyte
@@ -78,22 +78,6 @@ enum Ledger_Response_Error : ubyte
Req_Ledger_Not_Found = 2
}
table History_Response_Message { //Ledger History request type message schema
requester_lcl:[ubyte];
hist_ledger_blocks:[HistoryLedgerBlockPair];
error: Ledger_Response_Error;
}
table HistoryLedgerBlockPair { //A key, value pair of byte[].
seq_no:uint64;
ledger:HistoryLedgerBlock;
}
table HistoryLedgerBlock {
lcl:[ubyte];
block_buffer:[ubyte];
}
table Hpfs_Request_Message { //Hpfs request message schema
mount_id: uint32;
parent_path:string;

455
src/msg/fbuf/p2pmsg_content_generated.h
View File

@@ -33,21 +33,12 @@ struct NonUnl_Proposal_MessageBuilder;
struct Proposal_Message;
struct Proposal_MessageBuilder;
struct Sequence_Hash;
struct Sequence_HashBuilder;
struct Npl_Message;
struct Npl_MessageBuilder;
struct History_Request_Message;
struct History_Request_MessageBuilder;
struct History_Response_Message;
struct History_Response_MessageBuilder;
struct HistoryLedgerBlockPair;
struct HistoryLedgerBlockPairBuilder;
struct HistoryLedgerBlock;
struct HistoryLedgerBlockBuilder;
struct Hpfs_Request_Message;
struct Hpfs_Request_MessageBuilder;
@@ -81,7 +72,7 @@ struct Peer_List_Response_MessageBuilder;
struct Peer_Properties;
struct Peer_PropertiesBuilder;
enum Message {
enum Message : uint8_t {
Message_NONE = 0,
Message_Peer_Challenge_Response_Message = 1,
Message_Peer_Challenge_Message = 2,
@@ -90,17 +81,15 @@ enum Message {
Message_Npl_Message = 5,
Message_Hpfs_Request_Message = 6,
Message_Hpfs_Response_Message = 7,
Message_History_Request_Message = 8,
Message_History_Response_Message = 9,
Message_Peer_Requirement_Announcement_Message = 10,
Message_Peer_List_Request_Message = 11,
Message_Peer_List_Response_Message = 12,
Message_Available_Capacity_Announcement_Message = 13,
Message_Peer_Requirement_Announcement_Message = 8,
Message_Peer_List_Request_Message = 9,
Message_Peer_List_Response_Message = 10,
Message_Available_Capacity_Announcement_Message = 11,
Message_MIN = Message_NONE,
Message_MAX = Message_Available_Capacity_Announcement_Message
};
inline const Message (&EnumValuesMessage())[14] {
inline const Message (&EnumValuesMessage())[12] {
static const Message values[] = {
Message_NONE,
Message_Peer_Challenge_Response_Message,
@@ -110,8 +99,6 @@ inline const Message (&EnumValuesMessage())[14] {
Message_Npl_Message,
Message_Hpfs_Request_Message,
Message_Hpfs_Response_Message,
Message_History_Request_Message,
Message_History_Response_Message,
Message_Peer_Requirement_Announcement_Message,
Message_Peer_List_Request_Message,
Message_Peer_List_Response_Message,
@@ -121,7 +108,7 @@ inline const Message (&EnumValuesMessage())[14] {
}
inline const char * const *EnumNamesMessage() {
static const char * const names[15] = {
static const char * const names[13] = {
"NONE",
"Peer_Challenge_Response_Message",
"Peer_Challenge_Message",
@@ -130,8 +117,6 @@ inline const char * const *EnumNamesMessage() {
"Npl_Message",
"Hpfs_Request_Message",
"Hpfs_Response_Message",
"History_Request_Message",
"History_Response_Message",
"Peer_Requirement_Announcement_Message",
"Peer_List_Request_Message",
"Peer_List_Response_Message",
@@ -179,14 +164,6 @@ template<> struct MessageTraits<msg::fbuf::p2pmsg::Hpfs_Response_Message> {
static const Message enum_value = Message_Hpfs_Response_Message;
};
template<> struct MessageTraits<msg::fbuf::p2pmsg::History_Request_Message> {
static const Message enum_value = Message_History_Request_Message;
};
template<> struct MessageTraits<msg::fbuf::p2pmsg::History_Response_Message> {
static const Message enum_value = Message_History_Response_Message;
};
template<> struct MessageTraits<msg::fbuf::p2pmsg::Peer_Requirement_Announcement_Message> {
static const Message enum_value = Message_Peer_Requirement_Announcement_Message;
};
@@ -206,7 +183,7 @@ template<> struct MessageTraits<msg::fbuf::p2pmsg::Available_Capacity_Announceme
bool VerifyMessage(flatbuffers::Verifier &verifier, const void *obj, Message type);
bool VerifyMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
enum Ledger_Response_Error {
enum Ledger_Response_Error : uint8_t {
Ledger_Response_Error_None = 0,
Ledger_Response_Error_Invalid_Min_Ledger = 1,
Ledger_Response_Error_Req_Ledger_Not_Found = 2,
@@ -239,7 +216,7 @@ inline const char *EnumNameLedger_Response_Error(Ledger_Response_Error e) {
return EnumNamesLedger_Response_Error()[index];
}
enum Hpfs_Response {
enum Hpfs_Response : uint8_t {
Hpfs_Response_NONE = 0,
Hpfs_Response_File_HashMap_Response = 1,
Hpfs_Response_Block_Response = 2,
@@ -347,7 +324,6 @@ struct Peer_Challenge_MessageBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Peer_Challenge_MessageBuilder &operator=(const Peer_Challenge_MessageBuilder &);
flatbuffers::Offset<Peer_Challenge_Message> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Peer_Challenge_Message>(end);
@@ -423,7 +399,6 @@ struct Peer_Challenge_Response_MessageBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Peer_Challenge_Response_MessageBuilder &operator=(const Peer_Challenge_Response_MessageBuilder &);
flatbuffers::Offset<Peer_Challenge_Response_Message> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Peer_Challenge_Response_Message>(end);
@@ -506,7 +481,6 @@ struct UserInputBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
UserInputBuilder &operator=(const UserInputBuilder &);
flatbuffers::Offset<UserInput> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<UserInput>(end);
@@ -583,7 +557,6 @@ struct UserInputGroupBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
UserInputGroupBuilder &operator=(const UserInputGroupBuilder &);
flatbuffers::Offset<UserInputGroup> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<UserInputGroup>(end);
@@ -647,12 +620,6 @@ struct Content FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const msg::fbuf::p2pmsg::Hpfs_Response_Message *message_as_Hpfs_Response_Message() const {
return message_type() == msg::fbuf::p2pmsg::Message_Hpfs_Response_Message ? static_cast<const msg::fbuf::p2pmsg::Hpfs_Response_Message *>(message()) : nullptr;
}
const msg::fbuf::p2pmsg::History_Request_Message *message_as_History_Request_Message() const {
return message_type() == msg::fbuf::p2pmsg::Message_History_Request_Message ? static_cast<const msg::fbuf::p2pmsg::History_Request_Message *>(message()) : nullptr;
}
const msg::fbuf::p2pmsg::History_Response_Message *message_as_History_Response_Message() const {
return message_type() == msg::fbuf::p2pmsg::Message_History_Response_Message ? static_cast<const msg::fbuf::p2pmsg::History_Response_Message *>(message()) : nullptr;
}
const msg::fbuf::p2pmsg::Peer_Requirement_Announcement_Message *message_as_Peer_Requirement_Announcement_Message() const {
return message_type() == msg::fbuf::p2pmsg::Message_Peer_Requirement_Announcement_Message ? static_cast<const msg::fbuf::p2pmsg::Peer_Requirement_Announcement_Message *>(message()) : nullptr;
}
@@ -705,14 +672,6 @@ template<> inline const msg::fbuf::p2pmsg::Hpfs_Response_Message *Content::messa
return message_as_Hpfs_Response_Message();
}
template<> inline const msg::fbuf::p2pmsg::History_Request_Message *Content::message_as<msg::fbuf::p2pmsg::History_Request_Message>() const {
return message_as_History_Request_Message();
}
template<> inline const msg::fbuf::p2pmsg::History_Response_Message *Content::message_as<msg::fbuf::p2pmsg::History_Response_Message>() const {
return message_as_History_Response_Message();
}
template<> inline const msg::fbuf::p2pmsg::Peer_Requirement_Announcement_Message *Content::message_as<msg::fbuf::p2pmsg::Peer_Requirement_Announcement_Message>() const {
return message_as_Peer_Requirement_Announcement_Message();
}
@@ -743,7 +702,6 @@ struct ContentBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
ContentBuilder &operator=(const ContentBuilder &);
flatbuffers::Offset<Content> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Content>(end);
@@ -792,7 +750,6 @@ struct NonUnl_Proposal_MessageBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
NonUnl_Proposal_MessageBuilder &operator=(const NonUnl_Proposal_MessageBuilder &);
flatbuffers::Offset<NonUnl_Proposal_Message> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<NonUnl_Proposal_Message>(end);
@@ -826,10 +783,11 @@ struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_NONCE = 10,
VT_USERS = 12,
VT_INPUT_HASHES = 14,
VT_OUTPUT_HASH = 16,
VT_OUTPUT_SIG = 18,
VT_STATE_HASH = 20,
VT_PATCH_HASH = 22
VT_LAST_BLOB_SHARD_ID = 16,
VT_OUTPUT_HASH = 18,
VT_OUTPUT_SIG = 20,
VT_STATE_HASH = 22,
VT_PATCH_HASH = 24
};
uint8_t stage() const {
return GetField<uint8_t>(VT_STAGE, 0);
@@ -867,6 +825,12 @@ struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *mutable_input_hashes() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *>(VT_INPUT_HASHES);
}
const msg::fbuf::p2pmsg::Sequence_Hash *last_blob_shard_id() const {
return GetPointer<const msg::fbuf::p2pmsg::Sequence_Hash *>(VT_LAST_BLOB_SHARD_ID);
}
msg::fbuf::p2pmsg::Sequence_Hash *mutable_last_blob_shard_id() {
return GetPointer<msg::fbuf::p2pmsg::Sequence_Hash *>(VT_LAST_BLOB_SHARD_ID);
}
const flatbuffers::Vector<uint8_t> *output_hash() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_OUTPUT_HASH);
}
@@ -904,6 +868,8 @@ struct Proposal_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyOffset(verifier, VT_INPUT_HASHES) &&
verifier.VerifyVector(input_hashes()) &&
verifier.VerifyVectorOfTables(input_hashes()) &&
VerifyOffset(verifier, VT_LAST_BLOB_SHARD_ID) &&
verifier.VerifyTable(last_blob_shard_id()) &&
VerifyOffset(verifier, VT_OUTPUT_HASH) &&
verifier.VerifyVector(output_hash()) &&
VerifyOffset(verifier, VT_OUTPUT_SIG) &&
@@ -938,6 +904,9 @@ struct Proposal_MessageBuilder {
void add_input_hashes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> input_hashes) {
fbb_.AddOffset(Proposal_Message::VT_INPUT_HASHES, input_hashes);
}
void add_last_blob_shard_id(flatbuffers::Offset<msg::fbuf::p2pmsg::Sequence_Hash> last_blob_shard_id) {
fbb_.AddOffset(Proposal_Message::VT_LAST_BLOB_SHARD_ID, last_blob_shard_id);
}
void add_output_hash(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> output_hash) {
fbb_.AddOffset(Proposal_Message::VT_OUTPUT_HASH, output_hash);
}
@@ -954,7 +923,6 @@ struct Proposal_MessageBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Proposal_MessageBuilder &operator=(const Proposal_MessageBuilder &);
flatbuffers::Offset<Proposal_Message> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Proposal_Message>(end);
@@ -970,6 +938,7 @@ inline flatbuffers::Offset<Proposal_Message> CreateProposal_Message(
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> nonce = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> users = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::ByteArray>>> input_hashes = 0,
flatbuffers::Offset<msg::fbuf::p2pmsg::Sequence_Hash> last_blob_shard_id = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> output_hash = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> output_sig = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> state_hash = 0,
@@ -980,6 +949,7 @@ inline flatbuffers::Offset<Proposal_Message> CreateProposal_Message(
builder_.add_state_hash(state_hash);
builder_.add_output_sig(output_sig);
builder_.add_output_hash(output_hash);
builder_.add_last_blob_shard_id(last_blob_shard_id);
builder_.add_input_hashes(input_hashes);
builder_.add_users(users);
builder_.add_nonce(nonce);
@@ -996,6 +966,7 @@ inline flatbuffers::Offset<Proposal_Message> CreateProposal_MessageDirect(
const std::vector<uint8_t> *nonce = nullptr,
const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *users = nullptr,
const std::vector<flatbuffers::Offset<msg::fbuf::ByteArray>> *input_hashes = nullptr,
flatbuffers::Offset<msg::fbuf::p2pmsg::Sequence_Hash> last_blob_shard_id = 0,
const std::vector<uint8_t> *output_hash = nullptr,
const std::vector<uint8_t> *output_sig = nullptr,
const std::vector<uint8_t> *state_hash = nullptr,
@@ -1015,12 +986,82 @@ inline flatbuffers::Offset<Proposal_Message> CreateProposal_MessageDirect(
nonce__,
users__,
input_hashes__,
last_blob_shard_id,
output_hash__,
output_sig__,
state_hash__,
patch_hash__);
}
struct Sequence_Hash FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef Sequence_HashBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SHARD_SEQ_NO = 4,
VT_SHARD_HASH = 6
};
uint64_t shard_seq_no() const {
return GetField<uint64_t>(VT_SHARD_SEQ_NO, 0);
}
bool mutate_shard_seq_no(uint64_t _shard_seq_no) {
return SetField<uint64_t>(VT_SHARD_SEQ_NO, _shard_seq_no, 0);
}
const flatbuffers::Vector<uint8_t> *shard_hash() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_SHARD_HASH);
}
flatbuffers::Vector<uint8_t> *mutable_shard_hash() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_SHARD_HASH);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_SHARD_SEQ_NO) &&
VerifyOffset(verifier, VT_SHARD_HASH) &&
verifier.VerifyVector(shard_hash()) &&
verifier.EndTable();
}
};
struct Sequence_HashBuilder {
typedef Sequence_Hash Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_shard_seq_no(uint64_t shard_seq_no) {
fbb_.AddElement<uint64_t>(Sequence_Hash::VT_SHARD_SEQ_NO, shard_seq_no, 0);
}
void add_shard_hash(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> shard_hash) {
fbb_.AddOffset(Sequence_Hash::VT_SHARD_HASH, shard_hash);
}
explicit Sequence_HashBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<Sequence_Hash> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Sequence_Hash>(end);
return o;
}
};
inline flatbuffers::Offset<Sequence_Hash> CreateSequence_Hash(
flatbuffers::FlatBufferBuilder &_fbb,
uint64_t shard_seq_no = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> shard_hash = 0) {
Sequence_HashBuilder builder_(_fbb);
builder_.add_shard_seq_no(shard_seq_no);
builder_.add_shard_hash(shard_hash);
return builder_.Finish();
}
inline flatbuffers::Offset<Sequence_Hash> CreateSequence_HashDirect(
flatbuffers::FlatBufferBuilder &_fbb,
uint64_t shard_seq_no = 0,
const std::vector<uint8_t> *shard_hash = nullptr) {
auto shard_hash__ = shard_hash ? _fbb.CreateVector<uint8_t>(*shard_hash) : 0;
return msg::fbuf::p2pmsg::CreateSequence_Hash(
_fbb,
shard_seq_no,
shard_hash__);
}
struct Npl_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef Npl_MessageBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -1051,7 +1092,6 @@ struct Npl_MessageBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Npl_MessageBuilder &operator=(const Npl_MessageBuilder &);
flatbuffers::Offset<Npl_Message> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Npl_Message>(end);
@@ -1076,280 +1116,6 @@ inline flatbuffers::Offset<Npl_Message> CreateNpl_MessageDirect(
data__);
}
struct History_Request_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef History_Request_MessageBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_REQUIRED_LCL = 4
};
const flatbuffers::Vector<uint8_t> *required_lcl() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_REQUIRED_LCL);
}
flatbuffers::Vector<uint8_t> *mutable_required_lcl() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_REQUIRED_LCL);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_REQUIRED_LCL) &&
verifier.VerifyVector(required_lcl()) &&
verifier.EndTable();
}
};
struct History_Request_MessageBuilder {
typedef History_Request_Message Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_required_lcl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> required_lcl) {
fbb_.AddOffset(History_Request_Message::VT_REQUIRED_LCL, required_lcl);
}
explicit History_Request_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
History_Request_MessageBuilder &operator=(const History_Request_MessageBuilder &);
flatbuffers::Offset<History_Request_Message> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<History_Request_Message>(end);
return o;
}
};
inline flatbuffers::Offset<History_Request_Message> CreateHistory_Request_Message(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> required_lcl = 0) {
History_Request_MessageBuilder builder_(_fbb);
builder_.add_required_lcl(required_lcl);
return builder_.Finish();
}
inline flatbuffers::Offset<History_Request_Message> CreateHistory_Request_MessageDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *required_lcl = nullptr) {
auto required_lcl__ = required_lcl ? _fbb.CreateVector<uint8_t>(*required_lcl) : 0;
return msg::fbuf::p2pmsg::CreateHistory_Request_Message(
_fbb,
required_lcl__);
}
struct History_Response_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef History_Response_MessageBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_REQUESTER_LCL = 4,
VT_HIST_LEDGER_BLOCKS = 6,
VT_ERROR = 8
};
const flatbuffers::Vector<uint8_t> *requester_lcl() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_REQUESTER_LCL);
}
flatbuffers::Vector<uint8_t> *mutable_requester_lcl() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_REQUESTER_LCL);
}
const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>> *hist_ledger_blocks() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>> *>(VT_HIST_LEDGER_BLOCKS);
}
flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>> *mutable_hist_ledger_blocks() {
return GetPointer<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>> *>(VT_HIST_LEDGER_BLOCKS);
}
msg::fbuf::p2pmsg::Ledger_Response_Error error() const {
return static_cast<msg::fbuf::p2pmsg::Ledger_Response_Error>(GetField<uint8_t>(VT_ERROR, 0));
}
bool mutate_error(msg::fbuf::p2pmsg::Ledger_Response_Error _error) {
return SetField<uint8_t>(VT_ERROR, static_cast<uint8_t>(_error), 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_REQUESTER_LCL) &&
verifier.VerifyVector(requester_lcl()) &&
VerifyOffset(verifier, VT_HIST_LEDGER_BLOCKS) &&
verifier.VerifyVector(hist_ledger_blocks()) &&
verifier.VerifyVectorOfTables(hist_ledger_blocks()) &&
VerifyField<uint8_t>(verifier, VT_ERROR) &&
verifier.EndTable();
}
};
struct History_Response_MessageBuilder {
typedef History_Response_Message Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_requester_lcl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> requester_lcl) {
fbb_.AddOffset(History_Response_Message::VT_REQUESTER_LCL, requester_lcl);
}
void add_hist_ledger_blocks(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>>> hist_ledger_blocks) {
fbb_.AddOffset(History_Response_Message::VT_HIST_LEDGER_BLOCKS, hist_ledger_blocks);
}
void add_error(msg::fbuf::p2pmsg::Ledger_Response_Error error) {
fbb_.AddElement<uint8_t>(History_Response_Message::VT_ERROR, static_cast<uint8_t>(error), 0);
}
explicit History_Response_MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
History_Response_MessageBuilder &operator=(const History_Response_MessageBuilder &);
flatbuffers::Offset<History_Response_Message> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<History_Response_Message>(end);
return o;
}
};
inline flatbuffers::Offset<History_Response_Message> CreateHistory_Response_Message(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> requester_lcl = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>>> hist_ledger_blocks = 0,
msg::fbuf::p2pmsg::Ledger_Response_Error error = msg::fbuf::p2pmsg::Ledger_Response_Error_None) {
History_Response_MessageBuilder builder_(_fbb);
builder_.add_hist_ledger_blocks(hist_ledger_blocks);
builder_.add_requester_lcl(requester_lcl);
builder_.add_error(error);
return builder_.Finish();
}
inline flatbuffers::Offset<History_Response_Message> CreateHistory_Response_MessageDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *requester_lcl = nullptr,
const std::vector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>> *hist_ledger_blocks = nullptr,
msg::fbuf::p2pmsg::Ledger_Response_Error error = msg::fbuf::p2pmsg::Ledger_Response_Error_None) {
auto requester_lcl__ = requester_lcl ? _fbb.CreateVector<uint8_t>(*requester_lcl) : 0;
auto hist_ledger_blocks__ = hist_ledger_blocks ? _fbb.CreateVector<flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlockPair>>(*hist_ledger_blocks) : 0;
return msg::fbuf::p2pmsg::CreateHistory_Response_Message(
_fbb,
requester_lcl__,
hist_ledger_blocks__,
error);
}
struct HistoryLedgerBlockPair FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef HistoryLedgerBlockPairBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SEQ_NO = 4,
VT_LEDGER = 6
};
uint64_t seq_no() const {
return GetField<uint64_t>(VT_SEQ_NO, 0);
}
bool mutate_seq_no(uint64_t _seq_no) {
return SetField<uint64_t>(VT_SEQ_NO, _seq_no, 0);
}
const msg::fbuf::p2pmsg::HistoryLedgerBlock *ledger() const {
return GetPointer<const msg::fbuf::p2pmsg::HistoryLedgerBlock *>(VT_LEDGER);
}
msg::fbuf::p2pmsg::HistoryLedgerBlock *mutable_ledger() {
return GetPointer<msg::fbuf::p2pmsg::HistoryLedgerBlock *>(VT_LEDGER);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<uint64_t>(verifier, VT_SEQ_NO) &&
VerifyOffset(verifier, VT_LEDGER) &&
verifier.VerifyTable(ledger()) &&
verifier.EndTable();
}
};
struct HistoryLedgerBlockPairBuilder {
typedef HistoryLedgerBlockPair Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_seq_no(uint64_t seq_no) {
fbb_.AddElement<uint64_t>(HistoryLedgerBlockPair::VT_SEQ_NO, seq_no, 0);
}
void add_ledger(flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlock> ledger) {
fbb_.AddOffset(HistoryLedgerBlockPair::VT_LEDGER, ledger);
}
explicit HistoryLedgerBlockPairBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
HistoryLedgerBlockPairBuilder &operator=(const HistoryLedgerBlockPairBuilder &);
flatbuffers::Offset<HistoryLedgerBlockPair> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<HistoryLedgerBlockPair>(end);
return o;
}
};
inline flatbuffers::Offset<HistoryLedgerBlockPair> CreateHistoryLedgerBlockPair(
flatbuffers::FlatBufferBuilder &_fbb,
uint64_t seq_no = 0,
flatbuffers::Offset<msg::fbuf::p2pmsg::HistoryLedgerBlock> ledger = 0) {
HistoryLedgerBlockPairBuilder builder_(_fbb);
builder_.add_seq_no(seq_no);
builder_.add_ledger(ledger);
return builder_.Finish();
}
struct HistoryLedgerBlock FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef HistoryLedgerBlockBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_LCL = 4,
VT_BLOCK_BUFFER = 6
};
const flatbuffers::Vector<uint8_t> *lcl() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_LCL);
}
flatbuffers::Vector<uint8_t> *mutable_lcl() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_LCL);
}
const flatbuffers::Vector<uint8_t> *block_buffer() const {
return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_BLOCK_BUFFER);
}
flatbuffers::Vector<uint8_t> *mutable_block_buffer() {
return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_BLOCK_BUFFER);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_LCL) &&
verifier.VerifyVector(lcl()) &&
VerifyOffset(verifier, VT_BLOCK_BUFFER) &&
verifier.VerifyVector(block_buffer()) &&
verifier.EndTable();
}
};
struct HistoryLedgerBlockBuilder {
typedef HistoryLedgerBlock Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_lcl(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl) {
fbb_.AddOffset(HistoryLedgerBlock::VT_LCL, lcl);
}
void add_block_buffer(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> block_buffer) {
fbb_.AddOffset(HistoryLedgerBlock::VT_BLOCK_BUFFER, block_buffer);
}
explicit HistoryLedgerBlockBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
HistoryLedgerBlockBuilder &operator=(const HistoryLedgerBlockBuilder &);
flatbuffers::Offset<HistoryLedgerBlock> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<HistoryLedgerBlock>(end);
return o;
}
};
inline flatbuffers::Offset<HistoryLedgerBlock> CreateHistoryLedgerBlock(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> lcl = 0,
flatbuffers::Offset<flatbuffers::Vector<uint8_t>> block_buffer = 0) {
HistoryLedgerBlockBuilder builder_(_fbb);
builder_.add_block_buffer(block_buffer);
builder_.add_lcl(lcl);
return builder_.Finish();
}
inline flatbuffers::Offset<HistoryLedgerBlock> CreateHistoryLedgerBlockDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<uint8_t> *lcl = nullptr,
const std::vector<uint8_t> *block_buffer = nullptr) {
auto lcl__ = lcl ? _fbb.CreateVector<uint8_t>(*lcl) : 0;
auto block_buffer__ = block_buffer ? _fbb.CreateVector<uint8_t>(*block_buffer) : 0;
return msg::fbuf::p2pmsg::CreateHistoryLedgerBlock(
_fbb,
lcl__,
block_buffer__);
}
struct Hpfs_Request_Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef Hpfs_Request_MessageBuilder Builder;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
@@ -1425,7 +1191,6 @@ struct Hpfs_Request_MessageBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Hpfs_Request_MessageBuilder &operator=(const Hpfs_Request_MessageBuilder &);
flatbuffers::Offset<Hpfs_Request_Message> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Hpfs_Request_Message>(end);
@@ -1562,7 +1327,6 @@ struct Hpfs_Response_MessageBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Hpfs_Response_MessageBuilder &operator=(const Hpfs_Response_MessageBuilder &);
flatbuffers::Offset<Hpfs_Response_Message> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Hpfs_Response_Message>(end);
@@ -1635,7 +1399,6 @@ struct Fs_Entry_ResponseBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Fs_Entry_ResponseBuilder &operator=(const Fs_Entry_ResponseBuilder &);
flatbuffers::Offset<Fs_Entry_Response> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Fs_Entry_Response>(end);
@@ -1701,7 +1464,6 @@ struct File_HashMap_ResponseBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
File_HashMap_ResponseBuilder &operator=(const File_HashMap_ResponseBuilder &);
flatbuffers::Offset<File_HashMap_Response> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<File_HashMap_Response>(end);
@@ -1771,7 +1533,6 @@ struct Block_ResponseBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Block_ResponseBuilder &operator=(const Block_ResponseBuilder &);
flatbuffers::Offset<Block_Response> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Block_Response>(end);
@@ -1853,7 +1614,6 @@ struct Hpfs_FS_Hash_EntryBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Hpfs_FS_Hash_EntryBuilder &operator=(const Hpfs_FS_Hash_EntryBuilder &);
flatbuffers::Offset<Hpfs_FS_Hash_Entry> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Hpfs_FS_Hash_Entry>(end);
@@ -1916,7 +1676,6 @@ struct Peer_Requirement_Announcement_MessageBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Peer_Requirement_Announcement_MessageBuilder &operator=(const Peer_Requirement_Announcement_MessageBuilder &);
flatbuffers::Offset<Peer_Requirement_Announcement_Message> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Peer_Requirement_Announcement_Message>(end);
@@ -1972,7 +1731,6 @@ struct Available_Capacity_Announcement_MessageBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Available_Capacity_Announcement_MessageBuilder &operator=(const Available_Capacity_Announcement_MessageBuilder &);
flatbuffers::Offset<Available_Capacity_Announcement_Message> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Available_Capacity_Announcement_Message>(end);
@@ -2006,7 +1764,6 @@ struct Peer_List_Request_MessageBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Peer_List_Request_MessageBuilder &operator=(const Peer_List_Request_MessageBuilder &);
flatbuffers::Offset<Peer_List_Request_Message> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Peer_List_Request_Message>(end);
@@ -2051,7 +1808,6 @@ struct Peer_List_Response_MessageBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Peer_List_Response_MessageBuilder &operator=(const Peer_List_Response_MessageBuilder &);
flatbuffers::Offset<Peer_List_Response_Message> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Peer_List_Response_Message>(end);
@@ -2139,7 +1895,6 @@ struct Peer_PropertiesBuilder {
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
Peer_PropertiesBuilder &operator=(const Peer_PropertiesBuilder &);
flatbuffers::Offset<Peer_Properties> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Peer_Properties>(end);
@@ -2209,14 +1964,6 @@ inline bool VerifyMessage(flatbuffers::Verifier &verifier, const void *obj, Mess
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::Hpfs_Response_Message *>(obj);
return verifier.VerifyTable(ptr);
}
case Message_History_Request_Message: {
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::History_Request_Message *>(obj);
return verifier.VerifyTable(ptr);
}
case Message_History_Response_Message: {
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::History_Response_Message *>(obj);
return verifier.VerifyTable(ptr);
}
case Message_Peer_Requirement_Announcement_Message: {
auto ptr = reinterpret_cast<const msg::fbuf::p2pmsg::Peer_Requirement_Announcement_Message *>(obj);
return verifier.VerifyTable(ptr);

214
src/msg/fbuf/p2pmsg_helpers.cpp
View File

@@ -195,32 +195,11 @@ namespace msg::fbuf::p2pmsg
}
/**
* Creates a history response stuct from the given histrory response message.
* @param msg Flatbuffer History response message received from the peer.
* @return A History response struct representing the message.
*/
const p2p::history_response create_history_response_from_msg(const History_Response_Message &msg)
{
p2p::history_response hr;
if (msg.requester_lcl())
hr.requester_lcl = flatbuff_bytes_to_sv(msg.requester_lcl());
if (msg.hist_ledger_blocks())
hr.hist_ledger_blocks = flatbuf_historyledgermap_to_historyledgermap(msg.hist_ledger_blocks());
if (msg.error())
hr.error = (p2p::LEDGER_RESPONSE_ERROR)msg.error();
return hr;
}
/**
* Creates a proposal stuct from the given proposal message.
* @param The Flatbuffer poposal received from the peer.
* @return A proposal struct representing the message.
*/
const p2p::proposal create_proposal_from_msg(const Proposal_Message &msg, const flatbuffers::Vector<uint8_t> *pubkey, const uint64_t timestamp, const flatbuffers::Vector<uint8_t> *lcl)
* Creates a proposal stuct from the given proposal message.
* @param msg The Flatbuffer poposal received from the peer.
* @return A proposal struct representing the message.
*/
const p2p::proposal create_proposal_from_msg(const Proposal_Message &msg, const flatbuffers::Vector<uint8_t> *pubkey, const uint64_t timestamp, const flatbuffers::Vector<uint8_t> *lcl, const Sequence_Hash &last_primary_shard_id_msg)
{
p2p::proposal p;
@@ -235,6 +214,17 @@ namespace msg::fbuf::p2pmsg
p.state_hash = flatbuff_bytes_to_sv(msg.state_hash());
p.patch_hash = flatbuff_bytes_to_sv(msg.patch_hash());
p2p::sequence_hash last_primary_shard_id;
last_primary_shard_id.seq_no = last_primary_shard_id_msg.shard_seq_no();
last_primary_shard_id.hash = flatbuff_bytes_to_hash(last_primary_shard_id_msg.shard_hash());
p.last_primary_shard_id = last_primary_shard_id;
p2p::sequence_hash last_blob_shard_id;
const Sequence_Hash &last_blob_shard_id_msg = *msg.last_blob_shard_id();
last_blob_shard_id.seq_no = last_blob_shard_id_msg.shard_seq_no();
last_blob_shard_id.hash = flatbuff_bytes_to_hash(last_blob_shard_id_msg.shard_hash());
p.last_blob_shard_id = last_blob_shard_id;
if (msg.users())
p.users = flatbuf_bytearrayvector_to_stringlist(msg.users());
@@ -250,24 +240,6 @@ namespace msg::fbuf::p2pmsg
return p;
}
/**
* Creates a history request struct from the given history request message.
* @param msg Flatbuffer History request message received from the peer.
* @return A History request struct representing the message.
*/
const p2p::history_request create_history_request_from_msg(const History_Request_Message &msg, const flatbuffers::Vector<uint8_t> *lcl)
{
p2p::history_request hr;
if (lcl)
hr.requester_lcl = flatbuff_bytes_to_sv(lcl);
if (msg.required_lcl())
hr.required_lcl = flatbuff_bytes_to_sv(msg.required_lcl());
return hr;
}
/**
* Creates a hpfs request struct from the given hpfs request message.
* @param msg Flatbuffer State request message received from the peer.
@@ -322,7 +294,7 @@ namespace msg::fbuf::p2pmsg
builder.Finish(message); // Finished building message content to get serialised content.
// Now that we have built the content message
create_containermsg_from_content(container_builder, builder, {}, false);
create_containermsg_from_content(container_builder, builder, {}, {}, false);
}
/**
@@ -345,7 +317,7 @@ namespace msg::fbuf::p2pmsg
// Now that we have built the content message,
// we need to sign it and place it inside a container message.
create_containermsg_from_content(container_builder, builder, {}, true);
create_containermsg_from_content(container_builder, builder, {}, {}, true);
}
void create_msg_from_nonunl_proposal(flatbuffers::FlatBufferBuilder &container_builder, const p2p::nonunl_proposal &nup)
@@ -362,7 +334,7 @@ namespace msg::fbuf::p2pmsg
// Now that we have built the content message,
// we need to sign it and place it inside a container message.
create_containermsg_from_content(container_builder, builder, {}, false);
create_containermsg_from_content(container_builder, builder, {}, {}, false);
}
/**
@@ -375,6 +347,11 @@ namespace msg::fbuf::p2pmsg
// todo:get a average propsal message size and allocate content builder based on that.
flatbuffers::FlatBufferBuilder builder(1024);
const flatbuffers::Offset<Sequence_Hash> last_blob_shard_id_msg = CreateSequence_Hash(
builder,
p.last_blob_shard_id.seq_no,
hash_to_flatbuff_bytes(builder, p.last_blob_shard_id.hash));
const flatbuffers::Offset<Proposal_Message> proposal =
CreateProposal_Message(
builder,
@@ -384,6 +361,7 @@ namespace msg::fbuf::p2pmsg
sv_to_flatbuff_bytes(builder, p.nonce),
stringlist_to_flatbuf_bytearrayvector(builder, p.users),
stringlist_to_flatbuf_bytearrayvector(builder, p.input_hashes),
last_blob_shard_id_msg,
sv_to_flatbuff_bytes(builder, p.output_hash),
sv_to_flatbuff_bytes(builder, p.output_sig),
hash_to_flatbuff_bytes(builder, p.state_hash),
@@ -394,7 +372,7 @@ namespace msg::fbuf::p2pmsg
// Now that we have built the content message,
// we need to sign it and place it inside a container message.
create_containermsg_from_content(container_builder, builder, p.lcl, true);
create_containermsg_from_content(container_builder, builder, p.lcl, p.last_primary_shard_id, true);
}
/**
@@ -402,8 +380,9 @@ namespace msg::fbuf::p2pmsg
* @param container_builder Flatbuffer builder for the container message.
* @param msg The message to be sent as NPL message.
* @param lcl Lcl value to be passed in the container message.
* @param last_primary_shard_id Last primary shard id.
*/
void create_msg_from_npl_output(flatbuffers::FlatBufferBuilder &container_builder, const std::string_view &msg, std::string_view lcl)
void create_msg_from_npl_output(flatbuffers::FlatBufferBuilder &container_builder, const std::string_view &msg, std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id)
{
flatbuffers::FlatBufferBuilder builder(1024);
@@ -417,61 +396,17 @@ namespace msg::fbuf::p2pmsg
// Now that we have built the content message,
// we need to sign it and place it inside a container message.
create_containermsg_from_content(container_builder, builder, lcl, true);
}
/**
* Create history request message from the given history request struct.
* @param container_builder Flatbuffer builder for the container message.
* @param hr The History request struct to be placed in the container message.
*/
void create_msg_from_history_request(flatbuffers::FlatBufferBuilder &container_builder, const p2p::history_request &hr)
{
flatbuffers::FlatBufferBuilder builder(1024);
flatbuffers::Offset<History_Request_Message> hrmsg =
CreateHistory_Request_Message(
builder,
sv_to_flatbuff_bytes(builder, hr.required_lcl));
flatbuffers::Offset<Content> message = CreateContent(builder, Message_History_Request_Message, hrmsg.Union());
builder.Finish(message); // Finished building message content to get serialised content.
// Now that we have built the content message,
// we need to sign it and place it inside a container message.
create_containermsg_from_content(container_builder, builder, hr.requester_lcl, false);
}
/**
* Create history response message from the given history response struct.
* @param container_builder Flatbuffer builder for the container message.
* @param hr The History response struct to be placed in the container message.
*/
void create_msg_from_history_response(flatbuffers::FlatBufferBuilder &container_builder, const p2p::history_response &hr)
{
flatbuffers::FlatBufferBuilder builder(1024);
flatbuffers::Offset<History_Response_Message> hrmsg =
CreateHistory_Response_Message(
builder,
sv_to_flatbuff_bytes(builder, hr.requester_lcl),
historyledgermap_to_flatbuf_historyledgermap(builder, hr.hist_ledger_blocks),
(Ledger_Response_Error)hr.error);
flatbuffers::Offset<Content> message = CreateContent(builder, Message_History_Response_Message, hrmsg.Union());
builder.Finish(message); // Finished building message content to get serialised content.
// Now that we have built the content message,
// we need to sign it and place it inside a container message.
create_containermsg_from_content(container_builder, builder, {}, false);
create_containermsg_from_content(container_builder, builder, lcl, last_primary_shard_id, true);
}
/**
* Create hpfs request message from the given hpfs request struct.
* @param container_builder Flatbuffer builder for the container message.
* @param hr The hpfs request struct to be placed in the container message.
* @param lcl Lcl to be include in the container msg.
* @param last_primary_shard_id Last primary shard id.
*/
void create_msg_from_hpfs_request(flatbuffers::FlatBufferBuilder &container_builder, const p2p::hpfs_request &hr, std::string_view lcl)
void create_msg_from_hpfs_request(flatbuffers::FlatBufferBuilder &container_builder, const p2p::hpfs_request &hr, std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id)
{
flatbuffers::FlatBufferBuilder builder(1024);
@@ -489,7 +424,7 @@ namespace msg::fbuf::p2pmsg
// Now that we have built the content message,
// we need to sign it and place it inside a container message.
create_containermsg_from_content(container_builder, builder, lcl, false);
create_containermsg_from_content(container_builder, builder, lcl, last_primary_shard_id, false);
}
/**
@@ -500,10 +435,11 @@ namespace msg::fbuf::p2pmsg
* @param hash_nodes File or directory entries with hashes in the given parent path.
* @param expected_hash The exptected hash of the requested path.
* @param lcl Lcl to be include in the container msg.
* @param last_primary_shard_id Last primary shard id.
*/
void create_msg_from_fsentry_response(
flatbuffers::FlatBufferBuilder &container_builder, const std::string_view path, const uint32_t mount_id,
std::vector<hpfs::child_hash_node> &hash_nodes, util::h32 expected_hash, std::string_view lcl)
std::vector<hpfs::child_hash_node> &hash_nodes, util::h32 expected_hash, std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id)
{
flatbuffers::FlatBufferBuilder builder(1024);
@@ -523,7 +459,7 @@ namespace msg::fbuf::p2pmsg
// Now that we have built the content message,
// we need to sign it and place it inside a container message.
create_containermsg_from_content(container_builder, builder, lcl, true);
create_containermsg_from_content(container_builder, builder, lcl, last_primary_shard_id, true);
}
/**
@@ -533,10 +469,11 @@ namespace msg::fbuf::p2pmsg
* @param mount_id The mount id of the relavent hpfs mount.
* @param hashmap Hashmap of the file
* @param lcl Lcl to be include in the container msg.
* @param last_primary_shard_id Last primary shard id.
*/
void create_msg_from_filehashmap_response(
flatbuffers::FlatBufferBuilder &container_builder, std::string_view path, const uint32_t mount_id,
std::vector<util::h32> &hashmap, std::size_t file_length, util::h32 expected_hash, std::string_view lcl)
std::vector<util::h32> &hashmap, std::size_t file_length, util::h32 expected_hash, std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id)
{
// todo:get a average propsal message size and allocate content builder based on that.
flatbuffers::FlatBufferBuilder builder(1024);
@@ -561,7 +498,7 @@ namespace msg::fbuf::p2pmsg
// Now that we have built the content message,
// we need to sign it and place it inside a container message.
create_containermsg_from_content(container_builder, builder, lcl, true);
create_containermsg_from_content(container_builder, builder, lcl, last_primary_shard_id, true);
}
/**
@@ -570,8 +507,10 @@ namespace msg::fbuf::p2pmsg
* @param block_resp Block response struct to place in the message.
* @param mount_id The mount id of the relavent hpfs mount.
* @param lcl Lcl to be include in the container message.
* @param last_primary_shard_id Last primary shard id.
*/
void create_msg_from_block_response(flatbuffers::FlatBufferBuilder &container_builder, p2p::block_response &block_resp, const uint32_t mount_id, std::string_view lcl)
void create_msg_from_block_response(flatbuffers::FlatBufferBuilder &container_builder, p2p::block_response &block_resp, const uint32_t mount_id,
std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id)
{
// todo:get a average propsal message size and allocate content builder based on that.
flatbuffers::FlatBufferBuilder builder(1024);
@@ -594,7 +533,7 @@ namespace msg::fbuf::p2pmsg
// Now that we have built the content message,
// we need to sign it and place it inside a container message.
create_containermsg_from_content(container_builder, builder, lcl, true);
create_containermsg_from_content(container_builder, builder, lcl, last_primary_shard_id, true);
}
/**
@@ -603,7 +542,8 @@ namespace msg::fbuf::p2pmsg
* @param need_consensus_msg_forwarding True if number of connections are below threshold and false otherwise.
* @param lcl Lcl value to be passed in the container message.
*/
void create_msg_from_peer_requirement_announcement(flatbuffers::FlatBufferBuilder &container_builder, const bool need_consensus_msg_forwarding, std::string_view lcl)
void create_msg_from_peer_requirement_announcement(flatbuffers::FlatBufferBuilder &container_builder, const bool need_consensus_msg_forwarding,
std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id)
{
flatbuffers::FlatBufferBuilder builder(1024);
@@ -616,7 +556,7 @@ namespace msg::fbuf::p2pmsg
builder.Finish(message); // Finished building message content to get serialised content.
// Now that we have built the content message,
create_containermsg_from_content(container_builder, builder, lcl, false);
create_containermsg_from_content(container_builder, builder, lcl, last_primary_shard_id, false);
}
/**
@@ -626,7 +566,8 @@ namespace msg::fbuf::p2pmsg
* @param timestamp Announced timestamp.
* @param lcl Lcl value to be passed in the container message.
*/
void create_msg_from_available_capacity_announcement(flatbuffers::FlatBufferBuilder &container_builder, const int16_t &available_capacity, const uint64_t &timestamp, std::string_view lcl)
void create_msg_from_available_capacity_announcement(flatbuffers::FlatBufferBuilder &container_builder, const int16_t &available_capacity, const uint64_t &timestamp,
std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id)
{
flatbuffers::FlatBufferBuilder builder(1024);
@@ -640,7 +581,7 @@ namespace msg::fbuf::p2pmsg
builder.Finish(message); // Finished building message content to get serialised content.
// Now that we have built the content message,
create_containermsg_from_content(container_builder, builder, lcl, false);
create_containermsg_from_content(container_builder, builder, lcl, last_primary_shard_id, false);
}
/**
@@ -648,7 +589,7 @@ namespace msg::fbuf::p2pmsg
* @param container_builder Flatbuffer builder for the container message.
* @param lcl Lcl value to be passed in the container message.
*/
void create_msg_from_peer_list_request(flatbuffers::FlatBufferBuilder &container_builder, std::string_view lcl)
void create_msg_from_peer_list_request(flatbuffers::FlatBufferBuilder &container_builder, std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id)
{
flatbuffers::FlatBufferBuilder builder(1024);
@@ -660,7 +601,7 @@ namespace msg::fbuf::p2pmsg
builder.Finish(message); // Finished building message content to get serialised content.
// Now that we have built the content message,
create_containermsg_from_content(container_builder, builder, lcl, false);
create_containermsg_from_content(container_builder, builder, lcl, last_primary_shard_id, false);
}
/**
@@ -670,7 +611,8 @@ namespace msg::fbuf::p2pmsg
* @param skipping_peer Peer that does not need to be sent.
* @param lcl Lcl value to be passed in the container message.
*/
void create_msg_from_peer_list_response(flatbuffers::FlatBufferBuilder &container_builder, const std::vector<conf::peer_properties> &peers, const std::optional<conf::peer_ip_port> &skipping_ip_port, std::string_view lcl)
void create_msg_from_peer_list_response(flatbuffers::FlatBufferBuilder &container_builder, const std::vector<conf::peer_properties> &peers, const std::optional<conf::peer_ip_port> &skipping_ip_port,
std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id)
{
flatbuffers::FlatBufferBuilder builder(1024);
@@ -683,7 +625,7 @@ namespace msg::fbuf::p2pmsg
builder.Finish(message); // Finished building message content to get serialised content.
// Now that we have built the content message,
create_containermsg_from_content(container_builder, builder, lcl, false);
create_containermsg_from_content(container_builder, builder, lcl, last_primary_shard_id, false);
}
/**
@@ -694,7 +636,7 @@ namespace msg::fbuf::p2pmsg
* @param sign Whether to sign the message content.
*/
void create_containermsg_from_content(
flatbuffers::FlatBufferBuilder &container_builder, const flatbuffers::FlatBufferBuilder &content_builder, std::string_view lcl, const bool sign)
flatbuffers::FlatBufferBuilder &container_builder, const flatbuffers::FlatBufferBuilder &content_builder, std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id, const bool sign)
{
const uint8_t *content_buf = content_builder.GetBufferPointer();
const flatbuffers::uoffset_t content_size = content_builder.GetSize();
@@ -719,12 +661,18 @@ namespace msg::fbuf::p2pmsg
if (!lcl.empty())
lcl_offset = sv_to_flatbuff_bytes(container_builder, lcl);
const flatbuffers::Offset<Sequence_Hash> last_primary_shard_id_msg = CreateSequence_Hash(
container_builder,
last_primary_shard_id.seq_no,
hash_to_flatbuff_bytes(container_builder, last_primary_shard_id.hash));
const flatbuffers::Offset<Container> container_message = CreateContainer(
container_builder,
util::PEERMSG_VERSION,
util::get_epoch_milliseconds(),
pubkey_offset,
lcl_offset,
last_primary_shard_id_msg,
sig_offset,
content);
@@ -784,46 +732,6 @@ namespace msg::fbuf::p2pmsg
return builder.CreateVector(fbvec);
}
const std::map<uint64_t, const p2p::history_ledger_block>
flatbuf_historyledgermap_to_historyledgermap(const flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerBlockPair>> *fbvec)
{
std::map<uint64_t, const p2p::history_ledger_block> map;
for (const HistoryLedgerBlockPair *pair : *fbvec)
{
std::list<usr::submitted_user_input> msglist;
p2p::history_ledger_block ledger;
ledger.lcl = flatbuff_bytes_to_sv(pair->ledger()->lcl());
auto raw = pair->ledger()->block_buffer();
ledger.block_buffer = std::vector<uint8_t>(raw->begin(), raw->end());
map.emplace(pair->seq_no(), std::move(ledger));
}
return map;
}
const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerBlockPair>>>
historyledgermap_to_flatbuf_historyledgermap(flatbuffers::FlatBufferBuilder &builder, const std::map<uint64_t, const p2p::history_ledger_block> &map)
{
std::vector<flatbuffers::Offset<HistoryLedgerBlockPair>> fbvec;
fbvec.reserve(map.size());
for (auto const &[seq_no, ledger] : map)
{
flatbuffers::Offset<HistoryLedgerBlock> history_ledger = CreateHistoryLedgerBlock(
builder,
sv_to_flatbuff_bytes(builder, ledger.lcl),
builder.CreateVector(ledger.block_buffer));
fbvec.push_back(CreateHistoryLedgerBlockPair(
builder,
seq_no,
history_ledger));
}
return builder.CreateVector(fbvec);
}
void flatbuf_hpfsfshashentry_to_hpfsfshashentry(std::unordered_map<std::string, p2p::hpfs_fs_hash_entry> &fs_entries, const flatbuffers::Vector<flatbuffers::Offset<Hpfs_FS_Hash_Entry>> *fhashes)
{
for (const Hpfs_FS_Hash_Entry *f_hash : *fhashes)

40
src/msg/fbuf/p2pmsg_helpers.hpp
View File

@@ -30,11 +30,7 @@ namespace msg::fbuf::p2pmsg
const p2p::nonunl_proposal create_nonunl_proposal_from_msg(const NonUnl_Proposal_Message &msg, const uint64_t timestamp);
const p2p::proposal create_proposal_from_msg(const Proposal_Message &msg, const flatbuffers::Vector<uint8_t> *pubkey, const uint64_t timestamp, const flatbuffers::Vector<uint8_t> *lcl);
const p2p::history_request create_history_request_from_msg(const History_Request_Message &msg, const flatbuffers::Vector<uint8_t> *lcl);
const p2p::history_response create_history_response_from_msg(const History_Response_Message &msg);
const p2p::proposal create_proposal_from_msg(const Proposal_Message &msg, const flatbuffers::Vector<uint8_t> *pubkey, const uint64_t timestamp, const flatbuffers::Vector<uint8_t> *lcl, const Sequence_Hash &last_primary_shard_id_msg);
const p2p::hpfs_request create_hpfs_request_from_msg(const Hpfs_Request_Message &msg);
@@ -49,34 +45,34 @@ namespace msg::fbuf::p2pmsg
void create_msg_from_proposal(flatbuffers::FlatBufferBuilder &container_builder, const p2p::proposal &p);
void create_msg_from_history_request(flatbuffers::FlatBufferBuilder &container_builder, const p2p::history_request &hr);
void create_msg_from_npl_output(flatbuffers::FlatBufferBuilder &container_builder, const std::string_view &msg, std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id);
void create_msg_from_history_response(flatbuffers::FlatBufferBuilder &container_builder, const p2p::history_response &hr);
void create_msg_from_npl_output(flatbuffers::FlatBufferBuilder &container_builder, const std::string_view &msg, std::string_view lcl);
void create_msg_from_hpfs_request(flatbuffers::FlatBufferBuilder &container_builder, const p2p::hpfs_request &hr, std::string_view lcl);
void create_msg_from_hpfs_request(flatbuffers::FlatBufferBuilder &container_builder, const p2p::hpfs_request &hr, std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id);
void create_msg_from_fsentry_response(
flatbuffers::FlatBufferBuilder &container_builder, const std::string_view path, const uint32_t mount_id,
std::vector<hpfs::child_hash_node> &hash_nodes, util::h32 expected_hash, std::string_view lcl);
std::vector<hpfs::child_hash_node> &hash_nodes, util::h32 expected_hash, std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id);
void create_msg_from_filehashmap_response(
flatbuffers::FlatBufferBuilder &container_builder, std::string_view path, const uint32_t mount_id,
std::vector<util::h32> &hashmap, std::size_t file_length, util::h32 expected_hash, std::string_view lcl);
std::vector<util::h32> &hashmap, std::size_t file_length, util::h32 expected_hash, std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id);
void create_msg_from_block_response(flatbuffers::FlatBufferBuilder &container_builder, p2p::block_response &block_resp, const uint32_t mount_id, std::string_view lcl);
void create_msg_from_block_response(flatbuffers::FlatBufferBuilder &container_builder, p2p::block_response &block_resp, const uint32_t mount_id,
std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id);
void create_containermsg_from_content(
flatbuffers::FlatBufferBuilder &container_builder, const flatbuffers::FlatBufferBuilder &content_builder, std::string_view lcl, const bool sign);
flatbuffers::FlatBufferBuilder &container_builder, const flatbuffers::FlatBufferBuilder &content_builder, std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id, const bool sign);
void create_msg_from_peer_requirement_announcement(flatbuffers::FlatBufferBuilder &container_builder, const bool need_consensus_msg_forwarding, std::string_view lcl);
void create_msg_from_peer_requirement_announcement(flatbuffers::FlatBufferBuilder &container_builder, const bool need_consensus_msg_forwarding,
std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id);
void create_msg_from_available_capacity_announcement(flatbuffers::FlatBufferBuilder &container_builder, const int16_t &available_capacity, const uint64_t &timestamp, std::string_view lcl);
void create_msg_from_available_capacity_announcement(flatbuffers::FlatBufferBuilder &container_builder, const int16_t &available_capacity, const uint64_t &timestamp,
std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id);
void create_msg_from_peer_list_request(flatbuffers::FlatBufferBuilder &container_builder, std::string_view lcl);
void create_msg_from_peer_list_request(flatbuffers::FlatBufferBuilder &container_builder, std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id);
void create_msg_from_peer_list_response(flatbuffers::FlatBufferBuilder &container_builder, const std::vector<conf::peer_properties> &peers, const std::optional<conf::peer_ip_port> &skipping_ip_port, std::string_view lcl);
void create_msg_from_peer_list_response(flatbuffers::FlatBufferBuilder &container_builder, const std::vector<conf::peer_properties> &peers, const std::optional<conf::peer_ip_port> &skipping_ip_port,
std::string_view lcl, const p2p::sequence_hash &last_primary_shard_id);
//---Conversion helpers from flatbuffers data types to std data types---//
@@ -88,15 +84,9 @@ namespace msg::fbuf::p2pmsg
const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<UserInputGroup>>>
user_input_map_to_flatbuf_user_input_group(flatbuffers::FlatBufferBuilder &builder, const std::unordered_map<std::string, std::list<usr::submitted_user_input>> &map);
const std::map<uint64_t, const p2p::history_ledger_block>
flatbuf_historyledgermap_to_historyledgermap(const flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerBlockPair>> *fbvec);
const std::vector<conf::peer_properties>
flatbuf_peer_propertieslist_to_peer_propertiesvector(const flatbuffers::Vector<flatbuffers::Offset<Peer_Properties>> *fbvec);
const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<HistoryLedgerBlockPair>>>
historyledgermap_to_flatbuf_historyledgermap(flatbuffers::FlatBufferBuilder &builder, const std::map<uint64_t, const p2p::history_ledger_block> &map);
const flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Peer_Properties>>>
peer_propertiesvector_to_flatbuf_peer_propertieslist(flatbuffers::FlatBufferBuilder &builder, const std::vector<conf::peer_properties> &peers, const std::optional<conf::peer_ip_port> &skipping_ip_port);