Skip to content

Instantly share code, notes, and snippets.

@celeron55

celeron55/gist:6954775

Created Oct 12, 2013
Star
Embed
What would you like to do?
Learn more about clone URLs
Download ZIP
Raw
gistfile1.diff
diff --git a/src/rollback.cpp b/src/rollback.cpp
index e110068..34c4322 100644
--- a/src/rollback.cpp
+++ b/src/rollback.cpp
@@ -29,11 +29,479 @@
#include "util/string.h"
#include "util/numeric.h"
#include "inventorymanager.h" // deserializing InventoryLocations
+#include "sqlite3.h"
+#include "filesys.h"
#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
#define POINTS_PER_NODE (16.0)
+std::string dbp;
+sqlite3* dbh;
+sqlite3_stmt* dbs_insert;
+sqlite3_stmt* dbs_replace;
+sqlite3_stmt* dbs_select;
+
+bool SQL_createDatabase (void)
+{
+ std::cout << "CreateDB:" << dbp << std::endl;
+
+ int dbs = sqlite3_exec(
+ dbh
+ , "CREATE TABLE `action` ("
+ " `id` INTEGER PRIMARY KEY AUTOINCREMENT,"
+ " `actor` TEXT NOT NULL,"
+ " `timestamp` INTEGER NOT NULL,"
+ " `type` INT NOT NULL,"
+ " `list` TEXT,"
+ " `index` INT,"
+ " `add` INT,"
+ " `stack` TEXT,"
+ " `nodeMeta` INT,"
+ " `x` INTEGER,"
+ " `y` INTEGER,"
+ " `z` INTEGER,"
+ " `oldNode` TEXT,"
+ " `oldParam1` INT,"
+ " `oldParam2` INT,"
+ " `oldMeta` TEXT,"
+ " `newNode` TEXT,"
+ " `newParam1` INT,"
+ " `newParam2` INT,"
+ " `newMeta` TEXT,"
+ " `guessedActor` INTEGER"
+ ");"
+ "CREATE INDEX `actor` on `action` (`actor` ASC, `timestamp` ASC);"
+ , NULL, NULL, NULL
+ );
+ if (dbs == SQLITE_ABORT)
+ throw FileNotGoodException("Could not create sqlite3 database structure");
+ else
+ if (dbs != 0)
+ throw FileNotGoodException("SQL Rollback: Exec statement to create table structure returned a non-zero value");
+ else
+ std::cout << "SQL Rollback: SQLite3 database structure was created" << std::endl;
+
+ return true;
+}
+
+void SQL_databaseCheck (void)
+{
+ if (dbh) return;
+ //std::cout << "Database check" << std::endl;
+
+ bool needsCreate = !fs::PathExists(dbp);
+ int dbo = sqlite3_open_v2(dbp.c_str(), &dbh, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
+
+ if(dbo != SQLITE_OK)
+ {
+ std::cout
+ << "SQLROLLBACK: SQLite3 database failed to open: "
+ << sqlite3_errmsg(dbh)
+ << std::endl;
+ throw FileNotGoodException("Cannot open database file");
+ }
+
+ if (needsCreate) SQL_createDatabase();
+
+ int dbr;
+
+ dbr = sqlite3_prepare_v2(
+ dbh
+ , "INSERT INTO `action`"
+ " ( `actor`, `timestamp`, `type`,"
+ " `list`, `index`, `add`, `stack`, `nodeMeta`,"
+ " `x`, `y`, `z`,"
+ " `oldNode`, `oldParam1`, `oldParam2`, `oldMeta`,"
+ " `newNode`, `newParam1`, `newParam2`, `newMeta`,"
+ " `guessedActor`"
+ " )"
+ "VALUES"
+ " ( ?, ?, ?,"
+ " ?, ?, ?, ?, ?,"
+ " ?, ?, ?,"
+ " ?, ?, ?, ?,"
+ " ?, ?, ?, ?,"
+ " ?"
+ " );"
+ , -1, &dbs_insert, NULL
+ );
+
+ if (dbr != SQLITE_OK)
+ throw FileNotGoodException(sqlite3_errmsg(dbh));
+
+ dbr = sqlite3_prepare_v2(
+ dbh
+ , "REPLACE INTO `action`"
+ " ( `actor`, `timestamp`, `type`,"
+ " `list`, `index`, `add`, `stack`, `nodeMeta`,"
+ " `x`, `y`, `z`,"
+ " `oldNode`, `oldParam1`, `oldParam2`, `oldMeta`,"
+ " `newNode`, `newParam1`, `newParam2`, `newMeta`,"
+ " `guessedActor`, `id`"
+ " )"
+ "VALUES"
+ " ( ?, ?, ?,"
+ " ?, ?, ?, ?, ?,"
+ " ?, ?, ?,"
+ " ?, ?, ?, ?,"
+ " ?, ?, ?, ?,"
+ " ?, ?"
+ " );"
+ , -1, &dbs_replace, NULL
+ );
+
+ if (dbr != SQLITE_OK)
+ throw FileNotGoodException(sqlite3_errmsg(dbh));
+
+ dbr = sqlite3_prepare_v2(
+ dbh
+ , "SELECT "
+ " `actor`, `timestamp`, `type`"
+ " , `list`, `index`, `add`, `stack`, `nodemeta`"
+ " , `x`, `y`, `z`"
+ " , `oldNode`, `oldParam1`, `oldParam2`, `oldMeta`"
+ " , `newNode`, `newParam1`, `newParam2`, `newMeta`"
+ " , `guessedActor`"
+ " FROM `action`"
+ " WHERE `actor` = ?"
+ " AND `timestamp` > ?"
+ " ORDER BY `timestamp` DESC"
+ , -1, &dbs_select, NULL
+ );
+
+ if (dbr != SQLITE_OK)
+ throw FileNotGoodException(itos(dbr).c_str());
+
+ //std::cout << "SQL prepared statements seems OK" << std::endl;
+ return;
+}
+
+struct ActionRow
+{
+ int id;
+ std::string actor;
+ int timestamp;
+ int type;
+ std::string location, list;
+ int index, add;
+ std::string stack;
+ int nodeMeta;
+ int x, y, z;
+ std::string oldNode;
+ int oldParam1, oldParam2;
+ std::string oldMeta;
+ std::string newNode;
+ int newParam1, newParam2;
+ std::string newMeta;
+ int guessed;
+};
+
+bool SQL_registerRow (ActionRow row)
+{
+ SQL_databaseCheck();
+
+ sqlite3_stmt * dbs_do = (row.id)? dbs_replace: dbs_insert;
+
+ /*
+ std::cout
+ << (row.id? "Replacing": "Inserting")
+ << " ActionRow" << std::endl;
+ */
+ sqlite3_reset(dbs_do);
+
+ int bind [20 + (((bool) row.id)? 1: 0)], ii = 0;
+ bool nodeMeta = false;
+
+ bind[ii++] = sqlite3_bind_text (dbs_do, 1, row.actor.c_str(), row.actor.size(), NULL);
+ bind[ii++] = sqlite3_bind_int (dbs_do, 2, row.timestamp);
+ bind[ii++] = sqlite3_bind_int (dbs_do, 3, row.type);
+
+ if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK)
+ {
+ std::string loc = row.location;
+ std::string locType = loc.substr(0, loc.find(":"));
+ nodeMeta = (locType == "nodemeta");
+
+ bind[ii++] = sqlite3_bind_text (dbs_do, 4, row.list.c_str(), row.list.size(), NULL);
+ bind[ii++] = sqlite3_bind_int (dbs_do, 5, row.index);
+ bind[ii++] = sqlite3_bind_int (dbs_do, 6, row.add);
+ bind[ii++] = sqlite3_bind_text (dbs_do, 7, row.stack.c_str(), row.stack.size(), NULL);
+ bind[ii++] = sqlite3_bind_int (dbs_do, 8, (int) nodeMeta);
+
+ if (nodeMeta)
+ {
+ std::string x, y, z;
+ int l, r;
+ l = loc.find(':') + 1;
+ r = loc.find(',');
+ x = loc.substr(l, r - l);
+ l = r + 1;
+ r = loc.find(',', l);
+ y = loc.substr(l, r - l);
+ z = loc.substr(r +1);
+ bind[ii++] = sqlite3_bind_int (dbs_do, 9, atoi(x.c_str()));
+ bind[ii++] = sqlite3_bind_int (dbs_do, 10, atoi(y.c_str()));
+ bind[ii++] = sqlite3_bind_int (dbs_do, 11, atoi(z.c_str()));
+ }
+ }
+ else
+ {
+ bind[ii++] = sqlite3_bind_null (dbs_do, 4);
+ bind[ii++] = sqlite3_bind_null (dbs_do, 5);
+ bind[ii++] = sqlite3_bind_null (dbs_do, 6);
+ bind[ii++] = sqlite3_bind_null (dbs_do, 7);
+ bind[ii++] = sqlite3_bind_null (dbs_do, 8);
+ }
+
+ if (row.type == RollbackAction::TYPE_SET_NODE)
+ {
+ bind[ii++] = sqlite3_bind_int (dbs_do, 9, row.x);
+ bind[ii++] = sqlite3_bind_int (dbs_do, 10, row.y);
+ bind[ii++] = sqlite3_bind_int (dbs_do, 11, row.z);
+ bind[ii++] = sqlite3_bind_text (dbs_do, 12, row.oldNode.c_str(), row.oldNode.size(), NULL);
+ bind[ii++] = sqlite3_bind_int (dbs_do, 13, row.oldParam1);
+ bind[ii++] = sqlite3_bind_int (dbs_do, 14, row.oldParam2);
+ bind[ii++] = sqlite3_bind_text (dbs_do, 15, row.oldMeta.c_str(), row.oldMeta.size(), NULL);
+ bind[ii++] = sqlite3_bind_text (dbs_do, 16, row.newNode.c_str(), row.newNode.size(), NULL);
+ bind[ii++] = sqlite3_bind_int (dbs_do, 17, row.newParam1);
+ bind[ii++] = sqlite3_bind_int (dbs_do, 18, row.newParam2);
+ bind[ii++] = sqlite3_bind_text (dbs_do, 19, row.newMeta.c_str(), row.newMeta.size(), NULL);
+ bind[ii++] = sqlite3_bind_int (dbs_do, 20, row.guessed? 1: 0);
+ }
+ else
+ {
+ if (!nodeMeta)
+ {
+ bind[ii++] = sqlite3_bind_null (dbs_do, 9);
+ bind[ii++] = sqlite3_bind_null (dbs_do, 10);
+ bind[ii++] = sqlite3_bind_null (dbs_do, 11);
+ }
+ bind[ii++] = sqlite3_bind_null (dbs_do, 12);
+ bind[ii++] = sqlite3_bind_null (dbs_do, 13);
+ bind[ii++] = sqlite3_bind_null (dbs_do, 14);
+ bind[ii++] = sqlite3_bind_null (dbs_do, 15);
+ bind[ii++] = sqlite3_bind_null (dbs_do, 16);
+ bind[ii++] = sqlite3_bind_null (dbs_do, 17);
+ bind[ii++] = sqlite3_bind_null (dbs_do, 18);
+ bind[ii++] = sqlite3_bind_null (dbs_do, 19);
+ bind[ii++] = sqlite3_bind_null (dbs_do, 20);
+ }
+
+ if (row.id)
+ bind[ii++] = sqlite3_bind_int (dbs_do, 21, row.id);
+
+ for (ii = 0; ii < 20; ++ii)
+ if (bind[ii] != SQLITE_OK)
+ std::cout
+ << "WARNING: failed to bind param " << ii + 1
+ << " when inserting an entry in table setnode" << std::endl;
+
+ /*
+ std::cout << "========DB-WRITTEN==========" << std::endl;
+ std::cout << "id: " << row.id << std::endl;
+ std::cout << "actor: " << row.actor << std::endl;
+ std::cout << "time: " << row.timestamp << std::endl;
+ std::cout << "type: " << row.type << std::endl;
+ if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK)
+ {
+ std::cout << "Location: " << row.location << std::endl;
+ std::cout << "List: " << row.list << std::endl;
+ std::cout << "Index: " << row.index << std::endl;
+ std::cout << "Add: " << row.add << std::endl;
+ std::cout << "Stack: " << row.stack << std::endl;
+ }
+ if (row.type == RollbackAction::TYPE_SET_NODE)
+ {
+ std::cout << "x: " << row.x << std::endl;
+ std::cout << "y: " << row.y << std::endl;
+ std::cout << "z: " << row.z << std::endl;
+ std::cout << "oldNode: " << row.oldNode << std::endl;
+ std::cout << "oldParam1: " << row.oldParam1 << std::endl;
+ std::cout << "oldParam2: " << row.oldParam2 << std::endl;
+ std::cout << "oldMeta: " << row.oldMeta << std::endl;
+ std::cout << "newNode: " << row.newNode << std::endl;
+ std::cout << "newParam1: " << row.newParam1 << std::endl;
+ std::cout << "newParam2: " << row.newParam2 << std::endl;
+ std::cout << "newMeta: " << row.newMeta << std::endl;
+ std::cout << "DESERIALIZE" << row.newMeta.c_str() << std::endl;
+ std::cout << "guessed: " << row.guessed << std::endl;
+ }
+ */
+
+ int written = sqlite3_step(dbs_do);
+
+ return written == SQLITE_DONE;
+
+ //if (written != SQLITE_DONE)
+ // std::cout << "WARNING: rollback action not written: " << sqlite3_errmsg(dbh) << std::endl;
+ //else std::cout << "Action correctly inserted via SQL" << std::endl;
+}
+
+std::list<ActionRow> SQL_getRowsSince (int firstTime, std::string actor = NULL)
+{
+ std::list<ActionRow> rows;
+
+ sqlite3_reset (dbs_select);
+ sqlite3_bind_text (dbs_select, 1, actor.c_str(), -1, NULL);
+ sqlite3_bind_int (dbs_select, 2, firstTime);
+
+ int select = sqlite3_step(dbs_select);
+ const unsigned char * text;
+ size_t size;
+
+ while (select == SQLITE_ROW)
+ {
+ ActionRow row;
+
+ text = sqlite3_column_text (dbs_select, 0);
+ size = sqlite3_column_bytes (dbs_select, 0);
+ row.actor = std::string(reinterpret_cast<const char*>(text), size);
+ row.timestamp = sqlite3_column_int (dbs_select, 1);
+ row.type = sqlite3_column_int (dbs_select, 2);
+
+ if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK)
+ {
+ text = sqlite3_column_text (dbs_select, 3);
+ size = sqlite3_column_bytes(dbs_select, 3);
+ row.list = std::string(reinterpret_cast<const char*>(text), size);
+ row.index = sqlite3_column_int (dbs_select, 4);
+ row.add = sqlite3_column_int (dbs_select, 5);
+ text = sqlite3_column_text (dbs_select, 6);
+ size = sqlite3_column_bytes(dbs_select, 6);
+ row.stack = std::string(reinterpret_cast<const char*>(text), size);
+ row.nodeMeta = sqlite3_column_int (dbs_select, 7);
+ }
+
+ if (row.type == RollbackAction::TYPE_SET_NODE || row.nodeMeta)
+ {
+ row.x = sqlite3_column_int (dbs_select, 8);
+ row.y = sqlite3_column_int (dbs_select, 9);
+ row.z = sqlite3_column_int (dbs_select, 10);
+ }
+
+ if (row.type == RollbackAction::TYPE_SET_NODE)
+ {
+ text = sqlite3_column_text (dbs_select, 11);
+ size = sqlite3_column_bytes(dbs_select, 11);
+ row.oldNode = std::string(reinterpret_cast<const char*>(text), size);
+ row.oldParam1 = sqlite3_column_int (dbs_select, 12);
+ row.oldParam2 = sqlite3_column_int (dbs_select, 13);
+ text = sqlite3_column_text (dbs_select, 14);
+ size = sqlite3_column_bytes(dbs_select, 14);
+ row.oldMeta = std::string(reinterpret_cast<const char*>(text), size);
+ text = sqlite3_column_text (dbs_select, 15);
+ size = sqlite3_column_bytes(dbs_select, 15);
+ row.newNode = std::string(reinterpret_cast<const char*>(text), size);
+ row.newParam1 = sqlite3_column_int (dbs_select, 16);
+ row.newParam2 = sqlite3_column_int (dbs_select, 17);
+ text = sqlite3_column_text (dbs_select, 18);
+ size = sqlite3_column_bytes(dbs_select, 18);
+ row.newMeta = std::string(reinterpret_cast<const char*>(text), size);
+ row.guessed = sqlite3_column_int (dbs_select, 19);
+ }
+
+ row.location = row.nodeMeta? "nodemeta:": row.actor;
+
+ if (row.nodeMeta)
+ {
+ row.location.append(itos(row.x));
+ row.location.append(",");
+ row.location.append(itos(row.y));
+ row.location.append(",");
+ row.location.append(itos(row.z));
+ }
+
+ /*
+ std::cout << "=======SELECTED==========\n";
+ std::cout << "Actor: " << row.actor << "\n";
+ std::cout << "Timestamp: " << row.timestamp << "\n";
+
+ if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK)
+ {
+ std::cout << "list: " << row.list << "\n";
+ std::cout << "index: " << row.index << "\n";
+ std::cout << "add: " << row.add << "\n";
+ std::cout << "stack: " << row.stack << "\n";
+ if (row.nodeMeta)
+ {
+ std::cout << "X: " << row.x << "\n";
+ std::cout << "Y: " << row.y << "\n";
+ std::cout << "Z: " << row.z << "\n";
+ }
+ std::cout << "Location: " << row.location << "\n";
+ }
+ else
+ {
+ std::cout << "X: " << row.x << "\n";
+ std::cout << "Y: " << row.y << "\n";
+ std::cout << "Z: " << row.z << "\n";
+ std::cout << "oldNode: " << row.oldNode << "\n";
+ std::cout << "oldParam1: " << row.oldParam1 << "\n";
+ std::cout << "oldParam2: " << row.oldParam2 << "\n";
+ std::cout << "oldMeta: " << row.oldMeta << "\n";
+ std::cout << "newNode: " << row.newNode << "\n";
+ std::cout << "newParam1: " << row.newParam1 << "\n";
+ std::cout << "newParam2: " << row.newParam2 << "\n";
+ std::cout << "newMeta: " << row.newMeta << "\n";
+ std::cout << "guessed: " << row.guessed << "\n";
+ }
+ */
+
+ rows.push_back(row);
+ select = sqlite3_step(dbs_select);
+ }
+
+ return rows;
+}
+std::list<RollbackAction> SQL_getActionsSince (int firstTime, std::string actor = NULL)
+{
+ std::list<RollbackAction> actions;
+ std::list<ActionRow> rows = SQL_getRowsSince(firstTime, actor);
+
+ std::list<ActionRow>::const_iterator it;
+ for (it = rows.begin(); it != rows.end(); ++it)
+ {
+ RollbackAction action;
+ action.actor = it->actor;
+ action.unix_time = it->timestamp;
+ action.type = static_cast<RollbackAction::Type>(it->type);
+
+ switch (action.type)
+ {
+ case RollbackAction::TYPE_MODIFY_INVENTORY_STACK:
+
+ action.inventory_location = it->location.c_str();
+ action.inventory_list = it->list;
+ action.inventory_index = it->index;
+ action.inventory_add = it->add;
+ action.inventory_stack = it->stack;
+ break;
+
+ case RollbackAction::TYPE_SET_NODE:
+
+ action.p = v3s16(it->x, it->y, it->z);
+ action.n_old.name = it->oldNode;
+ action.n_old.param1 = it->oldParam1;
+ action.n_old.param2 = it->oldParam2;
+ action.n_old.meta = it->oldMeta;
+ action.n_new.name = it->newNode;
+ action.n_new.param1 = it->newParam1;
+ action.n_new.param2 = it->newParam2;
+ action.n_new.meta = it->newMeta;
+ break;
+
+ default:
+
+ throw("W T F");
+ break;
+ }
+
+ actions.push_back(action);
+ }
+ return actions;
+}
+
// Get nearness factor for subject's action for this action
// Return value: 0 = impossible, >0 = factor
static float getSuspectNearness(bool is_guess, v3s16 suspect_p, int suspect_t,
@@ -65,29 +533,36 @@ class RollbackManager: public IRollbackManager
void reportAction(const RollbackAction &action_)
{
// Ignore if not important
- if(!action_.isImportant(m_gamedef))
+ if (!action_.isImportant(m_gamedef))
return;
+
RollbackAction action = action_;
action.unix_time = time(0);
+
// Figure out actor
action.actor = m_current_actor;
action.actor_is_guess = m_current_actor_is_guess;
- // If actor is not known, find out suspect or cancel
- if(action.actor.empty()){
+
+ if (action.actor.empty()) // If actor is not known, find out suspect or cancel
+ {
v3s16 p;
- if(!action.getPosition(&p))
+ if (!action.getPosition(&p))
return;
+
action.actor = getSuspect(p, 83, 1);
- if(action.actor.empty())
+ if (action.actor.empty())
return;
+
action.actor_is_guess = true;
}
- infostream<<"RollbackManager::reportAction():"
- <<" time="<<action.unix_time
- <<" actor=\""<<action.actor<<"\""
- <<(action.actor_is_guess?" (guess)":"")
- <<" action="<<action.toString()
- <<std::endl;
+
+ infostream
+ << "RollbackManager::reportAction():"
+ << " time="<<action.unix_time
+ << " actor=\""<<action.actor<<"\""
+ << (action.actor_is_guess?" (guess)":"")
+ << " action="<<action.toString()
+ << std::endl;
addAction(action);
}
std::string getActor()
@@ -140,43 +615,253 @@ class RollbackManager: public IRollbackManager
}
void flush()
{
+
infostream<<"RollbackManager::flush()"<<std::endl;
+
+ /*
std::ofstream of(m_filepath.c_str(), std::ios::app);
if(!of.good()){
errorstream<<"RollbackManager::flush(): Could not open file "
<<"for appending: \""<<m_filepath<<"\""<<std::endl;
return;
}
- for(std::list<RollbackAction>::const_iterator
- i = m_action_todisk_buffer.begin();
- i != m_action_todisk_buffer.end(); i++)
+ */
+
+ sqlite3_exec(dbh, "BEGIN", NULL, NULL, NULL);
+
+ for
+ ( std::list<RollbackAction>::const_iterator i = m_action_todisk_buffer.begin()
+ ; i != m_action_todisk_buffer.end()
+ ; i++)
{
- // Do not save stuff that does not have an actor
- if(i->actor == "")
- continue;
- of<<i->unix_time;
- of<<" ";
- of<<serializeJsonString(i->actor);
- of<<" ";
- of<<i->toString();
- if(i->actor_is_guess){
- of<<" ";
- of<<"actor_is_guess";
+ if (i->actor == "") continue; // Do not save stuff that does not have an actor
+
+ /*
+ of << i->unix_time;
+ of << " ";
+ of << serializeJsonString(i->actor);
+ of << " ";
+ of << i->toString();
+ if (i->actor_is_guess)
+ {
+ of << " ";
+ of << "actor_is_guess";
}
- of<<std::endl;
+ of << std::endl;
+ */
+
+ ActionRow row;
+
+ row.id = 0;
+ row.actor = i->actor;
+ row.timestamp = i->unix_time;
+ row.type = i->type;
+
+ if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK)
+ {
+ row.location = i->inventory_location;
+ row.list = i->inventory_list;
+ row.index = i->inventory_index;
+ row.add = i->inventory_add;
+ row.stack = i->inventory_stack;
+ }
+ else
+ {
+ row.x = i->p.X;
+ row.y = i->p.Y;
+ row.z = i->p.Z;
+ row.oldNode = i->n_old.name;
+ row.oldParam1 = i->n_old.param1;
+ row.oldParam2 = i->n_old.param2;
+ row.oldMeta = i->n_old.meta;
+ row.newNode = i->n_new.name;
+ row.newParam1 = i->n_new.param1;
+ row.newParam2 = i->n_new.param2;
+ row.newMeta = i->n_new.meta;
+ row.guessed = i->actor_is_guess;
+ }
+ SQL_registerRow(row);
+
}
+ sqlite3_exec(dbh, "COMMIT", NULL, NULL, NULL);
m_action_todisk_buffer.clear();
}
// Other
+ void TXT_fileCheck (std::string filepath)
+ {
+ if (!fs::PathExists(filepath)) return;
+
+ std::cout << "Migrating from rollback.txt to rollback.sqlite" << std::endl;
+
+ SQL_databaseCheck();
+
+ std::ifstream fh (m_filepath.c_str(), std::ios::in | std::ios::ate);
+ if (!fh.good()) throw("DIE");
+
+ int filesize = fh.tellg();
+
+ if (filesize > 10)
+ {
+ fh.seekg(0);
+
+ using namespace std;
+
+ std::string bit;
+ int i = 0;
+ int id = 1;
+ int t = 0;
+ do
+ {
+ ActionRow row;
+
+ row.id = id;
+
+ // Get the timestamp
+ std::getline(fh, bit, ' '); bit = trim(bit); if (!atoi(trim(bit).c_str())) { std::getline(fh, bit); continue; }
+ row.timestamp = atoi(bit.c_str());
+
+ // Get the actor
+ row.actor = trim(deSerializeJsonString(fh));
+
+ // Get the action type
+ std::getline(fh, bit, '[');
+ std::getline(fh, bit, ' ');
+
+ if (bit == "modify_inventory_stack")
+ row.type = RollbackAction::TYPE_MODIFY_INVENTORY_STACK;
+
+ if (bit == "set_node")
+ row.type = RollbackAction::TYPE_SET_NODE;
+
+ if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK)
+ {
+ row.location = trim(deSerializeJsonString(fh));
+ std::getline(fh, bit, ' '); row.list = trim(deSerializeJsonString(fh));
+ std::getline(fh, bit, ' ');
+ std::getline(fh, bit, ' ');
+ row.index = atoi(trim(bit).c_str());
+ std::getline(fh, bit, ' '); row.add = (int) ( trim(bit) == "add" );
+ row.stack = trim(deSerializeJsonString(fh));
+ std::getline(fh, bit);
+
+ }
+ else
+ if (row.type == RollbackAction::TYPE_SET_NODE)
+ {
+ std::getline(fh, bit, '(');
+ std::getline(fh, bit, ','); row.x = atoi(trim(bit).c_str());
+ std::getline(fh, bit, ','); row.y = atoi(trim(bit).c_str());
+ std::getline(fh, bit, ')'); row.z = atoi(trim(bit).c_str());
+ std::getline(fh, bit, ' '); row.oldNode = trim(deSerializeJsonString(fh));
+ std::getline(fh, bit, ' ');
+ std::getline(fh, bit, ' '); row.oldParam1 = atoi(trim(bit).c_str());
+ std::getline(fh, bit, ' '); row.oldParam2 = atoi(trim(bit).c_str());
+ row.oldMeta = trim(deSerializeJsonString(fh));
+ std::getline(fh, bit, ' '); row.newNode = trim(deSerializeJsonString(fh));
+ std::getline(fh, bit, ' ');
+ std::getline(fh, bit, ' '); row.newParam1 = atoi(trim(bit).c_str());
+ std::getline(fh, bit, ' '); row.newParam2 = atoi(trim(bit).c_str());
+ row.newMeta = trim(deSerializeJsonString(fh));
+ std::getline(fh, bit, ' ');
+ std::getline(fh, bit, ' ');
+ std::getline(fh, bit); row.guessed = (int) ( trim(bit) == "actor_is_guess" );
+ }
+
+ /*
+ std::cout << "==========READ===========" << std::endl;
+ std::cout << "time: " << row.timestamp << std::endl;
+ std::cout << "actor: " << row.actor << std::endl;
+ std::cout << "type: " << row.type << std::endl;
+ if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK)
+ {
+ std::cout << "Location: " << row.location << std::endl;
+ std::cout << "List: " << row.list << std::endl;
+ std::cout << "Index: " << row.index << std::endl;
+ std::cout << "Add: " << row.add << std::endl;
+ std::cout << "Stack: " << row.stack << std::endl;
+ }
+ if (row.type == RollbackAction::TYPE_SET_NODE)
+ {
+ std::cout << "x: " << row.x << std::endl;
+ std::cout << "y: " << row.y << std::endl;
+ std::cout << "z: " << row.z << std::endl;
+ std::cout << "oldNode: " << row.oldNode << std::endl;
+ std::cout << "oldParam1: " << row.oldParam1 << std::endl;
+ std::cout << "oldParam2: " << row.oldParam2 << std::endl;
+ std::cout << "oldMeta: " << row.oldMeta << std::endl;
+ std::cout << "newNode: " << row.newNode << std::endl;
+ std::cout << "newParam1: " << row.newParam1 << std::endl;
+ std::cout << "newParam2: " << row.newParam2 << std::endl;
+ std::cout << "newMeta: " << row.newMeta << std::endl;
+ std::cout << "guessed: " << row.guessed << std::endl;
+ }
+ */
+
+ if (i == 0)
+ {
+ t = time(0);
+ sqlite3_exec(dbh, "BEGIN", NULL, NULL, NULL);
+ }
+
+ SQL_registerRow(row);
+
+ if (++i == 10000)
+ {
+ sqlite3_exec(dbh, "COMMIT", NULL, NULL, NULL);
+
+ t = time(0) - t;
+ std::cout
+ << " Done: " << (int)(((float) fh.tellg() / (float) filesize) * 100) << "%"
+ << "\tSpeed: " << 10000 / (t == 0? 1: t) << " actions per second"
+ << "\r"
+ ;
+ std::cout.flush();
+ i = 0;
+ }
+
+ ++id;
+ }
+ while (!fh.eof() && fh.good());
+ }
+
+ std::cout
+ << " Done: 100%" << std::endl
+ << " Deleting old rollback.txt...";
+
+ bool deleted = fs::DeleteSingleFileOrEmptyDirectory(filepath);
+
+ std::cout << (deleted? "OK": "FAIL") << std::endl;
+
+ if (!deleted)
+ std::cout << "Could not delete the old rollback.txt file, you will need to delete it manually." << std::endl;
+}
+
RollbackManager(const std::string &filepath, IGameDef *gamedef):
m_filepath(filepath),
m_gamedef(gamedef),
m_current_actor_is_guess(false)
{
- infostream<<"RollbackManager::RollbackManager("<<filepath<<")"
- <<std::endl;
+ infostream
+ << "RollbackManager::RollbackManager(" << filepath << ")"
+ << std::endl;
+
+ // Operate correctly in case of still being given rollback.txt as filepath
+ std::string directory = filepath.substr(0, filepath.rfind(DIR_DELIM) + 1); //std::cout << "Directory: " << directory << std::endl;
+ std::string filenameOld = filepath.substr(1+ filepath.rfind(DIR_DELIM)); //std::cout << "Filename: " << filenameOld << std::endl;
+ std::string filenameNew = (filenameOld == "rollback.txt")? "rollback.sqlite": filenameOld;
+ std::string checkfor = directory + "rollback.txt";
+
+ dbp = directory + filenameNew;
+ TXT_fileCheck(filepath);
+
+ /*
+ m_filepath = filepath.substr(0, filepath.rfind("/rollback.txt"));
+ m_filepath.append("/rollback.sqlite");
+ */
+
+ SQL_databaseCheck();
}
~RollbackManager()
{
@@ -190,7 +875,7 @@ class RollbackManager: public IRollbackManager
m_action_latest_buffer.push_back(action);
// Flush to disk sometimes
- if(m_action_todisk_buffer.size() >= 100)
+ if(m_action_todisk_buffer.size() >= 1000) // TEMP
flush();
}
@@ -259,9 +944,12 @@ class RollbackManager: public IRollbackManager
{
// Save all remaining stuff
flush();
+
// Load whole file to memory
bool good = readFile(action_buffer);
- if(!good){
+
+ if(!good)
+ {
errorstream<<"RollbackManager::getEntriesSince(): Failed to"
<<" open file; using data in memory."<<std::endl;
action_buffer = m_action_latest_buffer;
@@ -319,13 +1007,17 @@ class RollbackManager: public IRollbackManager
{
infostream<<"RollbackManager::getRevertActions("<<actor_filter
<<", "<<seconds<<")"<<std::endl;
+
// Figure out time
int cur_time = time(0);
int first_time = cur_time - seconds;
- std::list<RollbackAction> action_buffer = getEntriesSince(first_time);
+ flush();
- std::list<RollbackAction> result;
+ std::list<RollbackAction> result = SQL_getActionsSince(first_time, actor_filter);
+
+ return result;
+ /*
for(std::list<RollbackAction>::const_reverse_iterator
i = action_buffer.rbegin();
@@ -336,15 +1028,15 @@ class RollbackManager: public IRollbackManager
if(i->actor != actor_filter)
continue;
const RollbackAction &action = *i;
- /*infostream<<"RollbackManager::revertAction(): Should revert"
+ infostream<<"RollbackManager::revertAction(): Should revert"
<<" time="<<action.unix_time
<<" actor=\""<<action.actor<<"\""
<<" action="<<action.toString()
- <<std::endl;*/
+ <<std::endl;
result.push_back(action);
}
-
return result;
+ */
}
private:
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment