size_t
LedgerHeaderFrame::copyLedgerHeadersToStream(Database& db, soci::session& sess,
uint32_t ledgerSeq,
uint32_t ledgerCount,
XDROutputFileStream& headersOut)
{
auto timer = db.getSelectTimer("ledger-header-history");
uint32_t begin = ledgerSeq, end = ledgerSeq + ledgerCount;
size_t n = 0;
string headerEncoded;
assert(begin <= end);
soci::statement st =
(sess.prepare << "SELECT data FROM ledgerheaders "
"WHERE ledgerseq >= :begin AND ledgerseq < :end ORDER "
"BY ledgerseq ASC",
into(headerEncoded), use(begin), use(end));
st.execute(true);
while (st.got_data())
{
LedgerHeaderHistoryEntry lhe;
LedgerHeaderFrame::pointer lhf = decodeFromData(headerEncoded);
lhe.hash = lhf->getHash();
lhe.header = lhf->mHeader;
CLOG(DEBUG, "Ledger") << "Streaming ledger-header "
<< lhe.header.ledgerSeq;
headersOut.writeOne(lhe);
++n;
st.fetch();
}
return n;
}
void
put(BucketEntry const& e)
{
if (!mKeepDeadEntries && e.type() == DEADENTRY)
{
return;
}
// Check to see if there's an existing buffered entry.
if (mBuf)
{
// mCmp(e, *mBuf) means e < *mBuf; this should never be true since
// it would mean that we're getting entries out of order.
assert(!mCmp(e, *mBuf));
// Check to see if the new entry should flush (greater identity), or
// merely replace (same identity), the buffered entry.
if (mCmp(*mBuf, e))
{
mOut.writeOne(*mBuf, mHasher.get(), &mBytesPut);
mObjectsPut++;
}
}
else
{
mBuf = make_unique<BucketEntry>();
}
// In any case, replace *mBuf with e.
*mBuf = e;
}
OutputIterator(std::string const& tmpDir, bool keepDeadEntries)
: mFilename(randomBucketName(tmpDir))
, mBuf(nullptr)
, mHasher(SHA256::create())
, mKeepDeadEntries(keepDeadEntries)
{
CLOG(TRACE, "Bucket")
<< "Bucket::OutputIterator opening file to write: " << mFilename;
mOut.open(mFilename);
}
static void
saveTransactionHelper(Database& db, soci::session& sess, uint32 ledgerSeq,
TxSetFrame& txSet, TransactionHistoryResultEntry& results,
XDROutputFileStream& txOut,
XDROutputFileStream& txResultOut)
{
// prepare the txset for saving
LedgerHeaderFrame::pointer lh =
LedgerHeaderFrame::loadBySequence(ledgerSeq, db, sess);
if (!lh)
{
throw std::runtime_error("Could not find ledger");
}
txSet.previousLedgerHash() = lh->mHeader.previousLedgerHash;
txSet.sortForHash();
TransactionHistoryEntry hist;
hist.ledgerSeq = ledgerSeq;
txSet.toXDR(hist.txSet);
txOut.writeOne(hist);
txResultOut.writeOne(results);
}
void
genfuzz(std::string const& filename)
{
Logging::setFmt("<fuzz>");
size_t n = 8;
LOG(INFO) << "Writing " << n << "-message random fuzz file " << filename;
XDROutputFileStream out;
out.open(filename);
autocheck::generator<StellarMessage> gen;
for (size_t i = 0; i < n; ++i)
{
try
{
StellarMessage m(gen(10));
out.writeOne(m);
LOG(INFO) << "Message " << i << ": " << msgSummary(m);
}
catch (xdr::xdr_bad_discriminant const&)
{
LOG(INFO) << "Message " << i << ": malformed, omitted";
}
}
}
std::shared_ptr<Bucket>
getBucket(BucketManager& bucketManager)
{
assert(mOut);
if (mBuf)
{
mOut.writeOne(*mBuf, mHasher.get(), &mBytesPut);
mObjectsPut++;
mBuf.reset();
}
mOut.close();
if (mObjectsPut == 0 || mBytesPut == 0)
{
assert(mObjectsPut == 0);
assert(mBytesPut == 0);
CLOG(DEBUG, "Bucket") << "Deleting empty bucket file " << mFilename;
std::remove(mFilename.c_str());
return std::make_shared<Bucket>();
}
return bucketManager.adoptFileAsBucket(mFilename, mHasher->finish(),
mObjectsPut, mBytesPut);
}
