XmlOutput& XmlOutput::operator<<(const xml_output& o)
{
switch(o.xo_type) {
case tNothing:
break;
case tRaw:
addRaw(o.xo_text);
break;
case tDeclaration:
addDeclaration(o.xo_text, o.xo_value);
break;
case tTag:
newTagOpen(o.xo_text);
break;
case tCloseTag:
if (o.xo_value.count())
closeAll();
else if (o.xo_text.count())
closeTo(o.xo_text);
else
closeTag();
break;
case tAttribute:
addAttribute(o.xo_text, o.xo_value);
break;
case tData:
{
// Special case to be able to close tag in normal
// way ("</tag>", not "/>") without using addRaw()..
if (!o.xo_text.count()) {
closeOpen();
break;
}
QString output = doConversion(o.xo_text);
output.replace('\n', "\n" + currentIndent);
addRaw(QString("\n%1%2").arg(currentIndent).arg(output));
}
break;
case tComment:
{
QString output("<!--%1-->");
addRaw(output.arg(o.xo_text));
}
break;
case tCDATA:
{
QString output("<![CDATA[\n%1\n]]>");
addRaw(output.arg(o.xo_text));
}
break;
}
return *this;
}
/** We got some data for a ledger we are no longer acquiring
Since we paid the price to receive it, we might as well stash it in case we need it.
Nodes are received in wire format and must be stashed/hashed in prefix format
*/
void gotStaleData (std::shared_ptr<protocol::TMLedgerData> packet_ptr)
{
const uint256 uZero;
Serializer s;
try
{
for (int i = 0; i < packet_ptr->nodes ().size (); ++i)
{
auto const& node = packet_ptr->nodes (i);
if (!node.has_nodeid () || !node.has_nodedata ())
return;
auto newNode = SHAMapAbstractNode::make(
Blob (node.nodedata().begin(), node.nodedata().end()),
0, snfWIRE, uZero, false);
if (!newNode)
return;
s.erase();
newNode->addRaw(s, snfPREFIX);
auto blob = std::make_shared<Blob> (s.begin(), s.end());
getApp().getOPs().addFetchPack (newNode->getNodeHash(), blob);
}
}
catch (...)
{
}
}
/** We got some data for a ledger we are no longer acquiring Since we paid
the price to receive it, we might as well stash it in case we need it.
Nodes are received in wire format and must be stashed/hashed in prefix
format
*/
void gotStaleData (std::shared_ptr<protocol::TMLedgerData> packet_ptr) override
{
const uint256 uZero;
Serializer s;
try
{
for (int i = 0; i < packet_ptr->nodes ().size (); ++i)
{
auto const& node = packet_ptr->nodes (i);
if (!node.has_nodeid () || !node.has_nodedata ())
return;
auto id_string = node.nodeid();
auto newNode = SHAMapAbstractNode::make(
makeSlice(node.nodedata()),
0, snfWIRE, SHAMapHash{uZero}, false, app_.journal ("SHAMapNodeID"),
SHAMapNodeID(id_string.data(), id_string.size()));
if (!newNode)
return;
s.erase();
newNode->addRaw(s, snfPREFIX);
auto blob = std::make_shared<Blob> (s.begin(), s.end());
app_.getLedgerMaster().addFetchPack(
newNode->getNodeHash().as_uint256(), blob);
}
}
catch (std::exception const&)
{
}
}
void RawManager::loadActionRaws(SimpleXML& aXml) {
aXml.resetCurrentChild();
while(aXml.findChild("Action")) {
Action* a = NULL;
try {
a = addAction(aXml.getIntChildAttrib("ID"), aXml.getChildAttrib("Name"), aXml.getBoolChildAttrib("Enabled"));
} catch(const Exception&) {
continue;
}
aXml.stepIn();
while(aXml.findChild("Raw")) {
try {
Raw r;
r.setEnabled(aXml.getBoolChildAttrib("Enabled"));
r.setId(aXml.getIntChildAttrib("ID"));
r.setName(aXml.getChildAttrib("Name"));
r.setRaw(aXml.getChildAttrib("Raw"));
r.setTime(aXml.getIntChildAttrib("Time"));
r.setLua(aXml.getBoolChildAttrib("UseLua"));
addRaw(a, r);
} catch(const Exception&) {
// ...
}
}
aXml.stepOut();
}
}
typename std::enable_if<
std::is_base_of<BaseSet, TSet>::value, Object>::type
BaseSet::php_skipWhile(const Variant& fn) {
CallCtx ctx;
vm_decode_function(fn, nullptr, false, ctx);
if (!ctx.func) {
SystemLib::throwInvalidArgumentExceptionObject(
"Parameter must be a valid callback");
}
auto set = req::make<TSet>();
if (!m_size) return Object(std::move(set));
// we don't reserve(), because we don't know how selective fn will be
set->mutate();
int32_t version UNUSED;
if (std::is_same<c_Set, TSet>::value) {
version = m_version;
}
uint32_t used = posLimit();
uint32_t i = 0;
for (; i < used; ++i) {
if (isTombstone(i)) continue;
Elm& e = data()[i];
bool b = invokeAndCastToBool(ctx, 1, &e.data);
if (std::is_same<c_Set, TSet>::value) {
if (UNLIKELY(version != m_version)) {
throw_collection_modified();
}
}
if (!b) break;
}
for (; i < used; ++i) {
if (isTombstone(i)) continue;
Elm& e = data()[i];
if (e.hasIntKey()) {
set->addRaw(e.data.m_data.num);
} else {
assert(e.hasStrKey());
set->addRaw(e.data.m_data.pstr);
}
}
return Object(std::move(set));
}
typename std::enable_if<
std::is_base_of<BaseSet, TSet>::value, Object>::type
BaseSet::php_filter(const Variant& callback) const {
VMRegGuard _;
CallCtx ctx;
vm_decode_function(callback, nullptr, false, ctx);
if (!ctx.func) {
SystemLib::throwInvalidArgumentExceptionObject(
"Parameter must be a valid callback");
}
auto set = req::make<TSet>();
if (!m_size) return Object(std::move(set));
// we don't reserve(), because we don't know how selective callback will be
set->mutate();
int32_t version = m_version;
constexpr int64_t argc = useKey ? 2 : 1;
TypedValue argv[argc];
for (ssize_t pos = iter_begin(); iter_valid(pos); pos = iter_next(pos)) {
auto e = iter_elm(pos);
if (useKey) {
argv[0] = e->data;
}
argv[argc-1] = e->data;
bool b = invokeAndCastToBool(ctx, argc, argv);
if (UNLIKELY(version != m_version)) {
throw_collection_modified();
}
if (!b) continue;
e = iter_elm(pos);
if (e->hasIntKey()) {
set->addRaw(e->data.m_data.num);
} else {
assert(e->hasStrKey());
set->addRaw(e->data.m_data.pstr);
}
}
return Object(std::move(set));
}
void XmlOutput::addDeclaration(const QString &version, const QString &encoding)
{
switch(currentState) {
case Bare:
break;
case Tag:
case Attribute:
//warn_msg(WarnLogic, "<%s>: Cannot add declaration when not in bare state", tagStack.last().toLatin1().constData());
qDebug("<%s>: Cannot add declaration when not in bare state", tagStack.last().toLatin1().constData());
return;
}
QString outData = QString("<?xml version=\"%1\" encoding=\"%2\"?>")
.arg(doConversion(version))
.arg(doConversion(encoding));
addRaw(outData);
}
LRESULT CFavTabRaw::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) {
ctrlList.Attach(GetDlgItem(IDC_ACTIONS));
// nasty workaround to get checkboxes created in the right way
ctrlList.ModifyStyle(TVS_CHECKBOXES, 0);
ctrlList.ModifyStyle(0, TVS_CHECKBOXES);
ctrlList.SetRedraw(FALSE);
const Action::ActionList& a = RawManager::getInstance()->getActions();
for(Action::ActionList::const_iterator i = a.begin(); i != a.end(); ++i) {
HTREEITEM actionItem = addAction(*i);
for(Action::RawsList::const_iterator j = (*i)->raw.begin(); j != (*i)->raw.end(); ++j)
addRaw(actionItem, (*i)->getId(), &(*j));
}
ctrlList.SetRedraw(TRUE);
ctrlList.Invalidate();
return 0;
}
bool Logger::setLogFile(QString fileName)
{
// checking if have to generate a file name
if( true == fileName.isEmpty() )
fileName = qApp->applicationFilePath() + ".log";
// setting the file name
m_logFile.setFileName( fileName );
// opening the file, and chek if we can write
if( false == m_logFile.open(QIODevice::Append) )
return false;
addRaw("\n\n#####################################################################################################");
addInfo("Logging framework is up and running. Time - " + QTime::currentTime().toString(Qt::LocalDate), LOGGER );
// returning success
return true;
}
void RawEditorWidget::customContextMenuRequested(const QPoint &pos)
{
QTreeWidgetItem *it;
it=(QTreeWidgetItem *)m_pTreeWidget->itemAt(pos);
KVI_ASSERT(m_bOneTimeSetupDone);
m_pContextPopup->clear();
if(it)
{
if(it->parent())
{
if(!(((RawHandlerTreeWidgetItem *)it)->m_bEnabled))
m_pContextPopup->addAction(
*(g_pIconManager->getSmallIcon(KviIconManager::Handler)),
__tr2qs_ctx("&Enable Handler","editor"),this,SLOT(toggleCurrentHandlerEnabled()));
else
m_pContextPopup->addAction(
*(g_pIconManager->getSmallIcon(KviIconManager::HandlerDisabled)),
__tr2qs_ctx("&Disable Handler","editor"),this,SLOT(toggleCurrentHandlerEnabled()));
m_pContextPopup->addAction(
*(g_pIconManager->getSmallIcon(KviIconManager::Discard)),
__tr2qs_ctx("Re&move Handler","editor"),
this,SLOT(removeCurrentHandler()));
m_pContextPopup->addAction(
*(g_pIconManager->getSmallIcon(KviIconManager::Save)),
__tr2qs_ctx("&Export Handler to...","editor"),
this,SLOT(exportCurrentHandler()));
} else {
m_pContextPopup->addAction(
*(g_pIconManager->getSmallIcon(KviIconManager::Handler)),
__tr2qs_ctx("&New Handler","editor"),
this,SLOT(addHandlerForCurrentRaw()));
}
}
m_pContextPopup->addSeparator();
m_pContextPopup->addAction(
*(g_pIconManager->getSmallIcon(KviIconManager::RawEvent)),
__tr2qs_ctx("&Add RAW Event...","editor"),
this,SLOT(addRaw()));
m_pContextPopup->popup(mapToGlobal(QPoint(pos.x()+15,pos.y())));
}
void BaseSet::addAll(const Variant& t) {
if (t.isNull()) { return; } // nothing to do
decltype(cap()) oldCap = 0;
bool ok = IterateV(
*t.asTypedValue(),
[&](ArrayData* adata) {
auto sz = adata->size();
if (!sz) return true;
if (m_size) {
oldCap = cap(); // assume minimal collisions
}
reserve(m_size + sz);
mutateAndBump();
return false;
},
[this](const TypedValue* value) {
addRaw(tvAsCVarRef(value));
},
[this](ObjectData* coll) {
if (!m_size && coll->collectionType() == CollectionType::Set) {
auto hc = static_cast<HashCollection*>(coll);
replaceArray(hc->arrayData());
setIntLikeStrKeys(BaseSet::intLikeStrKeys(hc));
return true;
}
if (coll->collectionType() == CollectionType::Pair) {
mutateAndBump();
}
return false;
},
[this](const TypedValue* value) {
add(tvAsCVarRef(value));
});
if (UNLIKELY(!ok)) {
throw_invalid_collection_parameter();
}
// ... and shrink back if that was incorrect
if (oldCap) shrinkIfCapacityTooHigh(oldCap);
}
typename std::enable_if<
std::is_base_of<BaseSet, TSet>::value, Object>::type
BaseSet::php_map(const Variant& callback) const {
VMRegGuard _;
CallCtx ctx;
vm_decode_function(callback, nullptr, false, ctx);
if (!ctx.func) {
SystemLib::throwInvalidArgumentExceptionObject(
"Parameter must be a valid callback");
}
auto set = req::make<TSet>();
if (!m_size) return Object{std::move(set)};
assert(posLimit() != 0);
assert(hashSize() > 0);
assert(set->arrayData() == staticEmptyMixedArray());
auto oldCap = set->cap();
set->reserve(posLimit()); // presume minimum collisions ...
assert(set->canMutateBuffer());
constexpr int64_t argc = useKey ? 2 : 1;
TypedValue argv[argc];
for (ssize_t pos = iter_begin(); iter_valid(pos); pos = iter_next(pos)) {
auto e = iter_elm(pos);
TypedValue tvCbRet;
int32_t pVer = m_version;
if (useKey) {
argv[0] = e->data;
}
argv[argc-1] = e->data;
g_context->invokeFuncFew(&tvCbRet, ctx, argc, argv);
// Now that tvCbRet is live, make sure to decref even if we throw.
SCOPE_EXIT { tvRefcountedDecRef(&tvCbRet); };
if (UNLIKELY(m_version != pVer)) throw_collection_modified();
set->addRaw(&tvCbRet);
}
// ... and shrink back if that was incorrect
set->shrinkIfCapacityTooHigh(oldCap);
return Object{std::move(set)};
}
typename std::enable_if<
std::is_base_of<BaseVector, TVector>::value, Object>::type
BaseSet::php_concat(const Variant& iterable) {
size_t itSize;
ArrayIter iter = getArrayIterHelper(iterable, itSize);
auto vec = req::make<TVector>();
uint32_t sz = m_size;
vec->reserve((size_t)sz + itSize);
assert(vec->canMutateBuffer());
vec->setSize(sz);
uint32_t used = posLimit();
for (uint32_t i = 0, j = 0; i < used; ++i) {
if (isTombstone(i)) {
continue;
}
cellDup(data()[i].data, vec->data()[j]);
++j;
}
for (; iter; ++iter) {
vec->addRaw(iter.second());
}
return Object{std::move(vec)};
}
static bool saveValidatedLedger (
Application& app,
std::shared_ptr<Ledger const> const& ledger,
bool current)
{
auto j = app.journal ("Ledger");
if (! app.pendingSaves().startWork (ledger->info().seq))
{
// The save was completed synchronously
JLOG (j.debug()) << "Save aborted";
return true;
}
// TODO(tom): Fix this hard-coded SQL!
JLOG (j.trace())
<< "saveValidatedLedger "
<< (current ? "" : "fromAcquire ") << ledger->info().seq;
static boost::format deleteLedger (
"DELETE FROM Ledgers WHERE LedgerSeq = %u;");
static boost::format deleteTrans1 (
"DELETE FROM Transactions WHERE LedgerSeq = %u;");
static boost::format deleteTrans2 (
"DELETE FROM AccountTransactions WHERE LedgerSeq = %u;");
static boost::format deleteAcctTrans (
"DELETE FROM AccountTransactions WHERE TransID = '%s';");
auto seq = ledger->info().seq;
if (! ledger->info().accountHash.isNonZero ())
{
JLOG (j.fatal()) << "AH is zero: "
<< getJson (*ledger);
assert (false);
}
if (ledger->info().accountHash != ledger->stateMap().getHash ().as_uint256())
{
JLOG (j.fatal()) << "sAL: " << ledger->info().accountHash
<< " != " << ledger->stateMap().getHash ();
JLOG (j.fatal()) << "saveAcceptedLedger: seq="
<< seq << ", current=" << current;
assert (false);
}
assert (ledger->info().txHash == ledger->txMap().getHash ().as_uint256());
// Save the ledger header in the hashed object store
{
Serializer s (128);
s.add32 (HashPrefix::ledgerMaster);
addRaw(ledger->info(), s);
app.getNodeStore ().store (
hotLEDGER, std::move (s.modData ()), ledger->info().hash);
}
AcceptedLedger::pointer aLedger;
try
{
aLedger = app.getAcceptedLedgerCache().fetch (ledger->info().hash);
if (! aLedger)
{
aLedger = std::make_shared<AcceptedLedger>(ledger, app.accountIDCache(), app.logs());
app.getAcceptedLedgerCache().canonicalize(ledger->info().hash, aLedger);
}
}
catch (std::exception const&)
{
JLOG (j.warn()) << "An accepted ledger was missing nodes";
app.getLedgerMaster().failedSave(seq, ledger->info().hash);
// Clients can now trust the database for information about this
// ledger sequence.
app.pendingSaves().finishWork(seq);
return false;
}
{
auto db = app.getLedgerDB ().checkoutDb();
*db << boost::str (deleteLedger % seq);
}
{
auto db = app.getTxnDB ().checkoutDb ();
soci::transaction tr(*db);
*db << boost::str (deleteTrans1 % seq);
*db << boost::str (deleteTrans2 % seq);
std::string const ledgerSeq (std::to_string (seq));
for (auto const& vt : aLedger->getMap ())
{
uint256 transactionID = vt.second->getTransactionID ();
app.getMasterTransaction ().inLedger (
transactionID, seq);
std::string const txnId (to_string (transactionID));
std::string const txnSeq (std::to_string (vt.second->getTxnSeq ()));
*db << boost::str (deleteAcctTrans % transactionID);
auto const& accts = vt.second->getAffected ();
if (!accts.empty ())
{
std::string sql (
"INSERT INTO AccountTransactions "
"(TransID, Account, LedgerSeq, TxnSeq) VALUES ");
// Try to make an educated guess on how much space we'll need
// for our arguments. In argument order we have:
// 64 + 34 + 10 + 10 = 118 + 10 extra = 128 bytes
sql.reserve (sql.length () + (accts.size () * 128));
bool first = true;
for (auto const& account : accts)
{
if (!first)
sql += ", ('";
else
{
sql += "('";
first = false;
}
sql += txnId;
sql += "','";
sql += app.accountIDCache().toBase58(account);
sql += "',";
sql += ledgerSeq;
sql += ",";
sql += txnSeq;
sql += ")";
}
sql += ";";
JLOG (j.trace()) << "ActTx: " << sql;
*db << sql;
}
else
{
JLOG (j.warn())
<< "Transaction in ledger " << seq
<< " affects no accounts";
JLOG (j.warn())
<< vt.second->getTxn()->getJson(0);
}
*db <<
(STTx::getMetaSQLInsertReplaceHeader () +
vt.second->getTxn ()->getMetaSQL (
seq, vt.second->getEscMeta ()) + ";");
}
tr.commit ();
}
{
static std::string addLedger(
R"sql(INSERT OR REPLACE INTO Ledgers
(LedgerHash,LedgerSeq,PrevHash,TotalCoins,ClosingTime,PrevClosingTime,
CloseTimeRes,CloseFlags,AccountSetHash,TransSetHash)
VALUES
(:ledgerHash,:ledgerSeq,:prevHash,:totalCoins,:closingTime,:prevClosingTime,
:closeTimeRes,:closeFlags,:accountSetHash,:transSetHash);)sql");
static std::string updateVal(
R"sql(UPDATE Validations SET LedgerSeq = :ledgerSeq, InitialSeq = :initialSeq
WHERE LedgerHash = :ledgerHash;)sql");
auto db (app.getLedgerDB ().checkoutDb ());
soci::transaction tr(*db);
auto const hash = to_string (ledger->info().hash);
auto const parentHash = to_string (ledger->info().parentHash);
auto const drops = to_string (ledger->info().drops);
auto const closeTime =
ledger->info().closeTime.time_since_epoch().count();
auto const parentCloseTime =
ledger->info().parentCloseTime.time_since_epoch().count();
auto const closeTimeResolution =
ledger->info().closeTimeResolution.count();
auto const closeFlags = ledger->info().closeFlags;
auto const accountHash = to_string (ledger->info().accountHash);
auto const txHash = to_string (ledger->info().txHash);
*db << addLedger,
soci::use(hash),
soci::use(seq),
soci::use(parentHash),
soci::use(drops),
soci::use(closeTime),
soci::use(parentCloseTime),
soci::use(closeTimeResolution),
soci::use(closeFlags),
soci::use(accountHash),
soci::use(txHash);
*db << updateVal,
soci::use(seq),
soci::use(seq),
soci::use(hash);
tr.commit();
}
void addRaw(const char* raw)
{
addRaw(raw, strlen(raw));
}
