From 1fd9a11e302566d207c046bd5145e4e05a3c58ea Mon Sep 17 00:00:00 2001 From: Mario Barrera Date: Sun, 13 Oct 2013 13:35:10 -0300 Subject: SQLite rollback --- src/rollback.cpp | 1134 +++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 960 insertions(+), 174 deletions(-) (limited to 'src') diff --git a/src/rollback.cpp b/src/rollback.cpp index e11006826..b95cc7bf3 100644 --- a/src/rollback.cpp +++ b/src/rollback.cpp @@ -29,11 +29,876 @@ with this program; if not, write to the Free Software Foundation, Inc., #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; +sqlite3_stmt* dbs_select_range; +sqlite3_stmt* dbs_select_withActor; +sqlite3_stmt* dbs_knownActor_select; +sqlite3_stmt* dbs_knownActor_insert; +sqlite3_stmt* dbs_knownNode_select; +sqlite3_stmt* dbs_knownNode_insert; + +struct Stack +{ + int node; + int quantity; +}; +struct ActionRow +{ + int id; + int actor; + int timestamp; + int type; + std::string location, list; + int index, add; + Stack stack; + int nodeMeta; + int x, y, z; + int oldNode; + int oldParam1, oldParam2; + std::string oldMeta; + int newNode; + int newParam1, newParam2; + std::string newMeta; + int guessed; +}; +struct Entity +{ + int id; + std::string name; +}; +typedef std::vector Entities; + +Entities KnownActors; +Entities KnownNodes; + +void registerNewActor (int id, std::string name) +{ + Entity newActor; + + newActor.id = id; + newActor.name = name; + + KnownActors.push_back(newActor); + + //std::cout << "New actor registered: " << id << " | " << name << std::endl; +} +void registerNewNode (int id, std::string name) +{ + Entity newNode; + + newNode.id = id; + newNode.name = name; + + KnownNodes.push_back(newNode); + + //std::cout << "New node registered: " << id << " | " << name << std::endl; +} +int getActorId (std::string name) +{ + Entities::const_iterator iter; + + for (iter = KnownActors.begin(); iter != KnownActors.end(); ++iter) + if (iter->name == name) + return iter->id; + + sqlite3_reset (dbs_knownActor_insert); + sqlite3_bind_text (dbs_knownActor_insert, 1, name.c_str(), -1, NULL); + sqlite3_step (dbs_knownActor_insert); + + int id = sqlite3_last_insert_rowid(dbh); + + //std::cout << "Actor ID insert returns " << insert << std::endl; + + registerNewActor(id, name); + + return id; +} +int getNodeId (std::string name) +{ + Entities::const_iterator iter; + + for (iter = KnownNodes.begin(); iter != KnownNodes.end(); ++iter) + if (iter->name == name) + return iter->id; + + sqlite3_reset (dbs_knownNode_insert); + sqlite3_bind_text (dbs_knownNode_insert, 1, name.c_str(), -1, NULL); + sqlite3_step (dbs_knownNode_insert); + + int id = sqlite3_last_insert_rowid(dbh); + + registerNewNode(id, name); + + return id; +} +const char * getActorName (int id) +{ + Entities::const_iterator iter; + + //std::cout << "getActorName of id " << id << std::endl; + + for (iter = KnownActors.begin(); iter != KnownActors.end(); ++iter) + if (iter->id == id) + return iter->name.c_str(); + + return ""; +} +const char * getNodeName (int id) +{ + Entities::const_iterator iter; + + //std::cout << "getNodeName of id " << id << std::endl; + + for (iter = KnownNodes.begin(); iter != KnownNodes.end(); ++iter) + if (iter->id == id) + return iter->name.c_str(); + + return ""; +} +Stack getStackFromString (std::string text) +{ + Stack stack; + + size_t off = text.find_last_of(" "); + + stack.node = getNodeId(text.substr(0, off)); + stack.quantity = atoi(text.substr(off + 1).c_str()); + + return stack; +} +std::string getStringFromStack (Stack stack) +{ + std::string text; + + text.append(getNodeName(stack.node)); + text.append(" "); + text.append(itos(stack.quantity)); + + return text; +} +bool SQL_createDatabase (void) +{ + infostream << "CreateDB:" << dbp << std::endl; + + int dbs = sqlite3_exec( + dbh + , "CREATE TABLE IF NOT EXISTS `actor` (" + "`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL," + "`name` TEXT NOT NULL);" + "CREATE TABLE IF NOT EXISTS `node` (" + "`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL," + "`name` TEXT NOT NULL);" + "CREATE TABLE IF NOT EXISTS `action` (" + "`id` INTEGER PRIMARY KEY AUTOINCREMENT," + "`actor` INTEGER NOT NULL," + "`timestamp` INTEGER NOT NULL," + "`type` INTEGER NOT NULL," + "`list` TEXT," + "`index` INTEGER," + "`add` INTEGER," + "`stackNode` INTEGER," + "`stackQuantity` INTEGER," + "`nodeMeta` INTEGER," + "`x` INT," + "`y` INT," + "`z` INT," + "`oldNode` INTEGER," + "`oldParam1` INTEGER," + "`oldParam2` INTEGER," + "`oldMeta` TEXT," + "`newNode` INTEGER," + "`newParam1` INTEGER," + "`newParam2` INTEGER," + "`newMeta` TEXT," + "`guessedActor` INTEGER," + "FOREIGN KEY (`actor`) REFERENCES `actor`(`id`)," + "FOREIGN KEY (`oldNode`) REFERENCES `node`(`id`)," + "FOREIGN KEY (`newNode`) REFERENCES `node`(`id`));" + "CREATE INDEX IF NOT EXISTS `actionActor` ON `action`(`actor`);" + "CREATE INDEX IF NOT EXISTS `actionTimestamp` ON `action`(`timestamp`);" + , 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 + infostream << "SQL Rollback: SQLite3 database structure was created" << std::endl; + + return true; +} +void SQL_databaseCheck (void) +{ + if (dbh) return; + + infostream << "Database connection setup" << 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) + { + infostream + << "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`, `stackNode`, `stackQuantity`, `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`, `stackNode`, `stackQuantity`, `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`, `stackNode`, `stackQuantity`, `nodemeta`" + " , `x`, `y`, `z`" + " , `oldNode`, `oldParam1`, `oldParam2`, `oldMeta`" + " , `newNode`, `newParam1`, `newParam2`, `newMeta`" + " , `guessedActor`" + " FROM `action`" + " WHERE `timestamp` >= ?" + " ORDER BY `timestamp` DESC, `id` DESC" + , -1, &dbs_select, NULL + ); + if (dbr != SQLITE_OK) + throw FileNotGoodException(itos(dbr).c_str()); + + dbr = sqlite3_prepare_v2(dbh + , "SELECT " + " `actor`, `timestamp`, `type`" + " , `list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodemeta`" + " , `x`, `y`, `z`" + " , `oldNode`, `oldParam1`, `oldParam2`, `oldMeta`" + " , `newNode`, `newParam1`, `newParam2`, `newMeta`" + " , `guessedActor`" + " FROM `action`" + " WHERE `timestamp` >= ?" + " AND `x` IS NOT NULL" + " AND `y` IS NOT NULL" + " AND `z` IS NOT NULL" + " AND (ABS(`x`) - ABS(?)) <= ?" + " AND (ABS(`y`) - ABS(?)) <= ?" + " AND (ABS(`z`) - ABS(?)) <= ?" + " ORDER BY `timestamp` DESC, `id` DESC" + " LIMIT 0,5" + , -1, &dbs_select_range, NULL + ); + if (dbr != SQLITE_OK) + throw FileNotGoodException(itos(dbr).c_str()); + + dbr = sqlite3_prepare_v2(dbh + , "SELECT " + " `actor`, `timestamp`, `type`" + " , `list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodemeta`" + " , `x`, `y`, `z`" + " , `oldNode`, `oldParam1`, `oldParam2`, `oldMeta`" + " , `newNode`, `newParam1`, `newParam2`, `newMeta`" + " , `guessedActor`" + " FROM `action`" + " WHERE `timestamp` >= ?" + " AND `actor` = ?" + " ORDER BY `timestamp` DESC, `id` DESC" + , -1, &dbs_select_withActor, NULL + ); + if (dbr != SQLITE_OK) + throw FileNotGoodException(itos(dbr).c_str()); + + dbr = sqlite3_prepare_v2(dbh, "SELECT `id`, `name` FROM `actor`", -1, &dbs_knownActor_select, NULL); + if (dbr != SQLITE_OK) + throw FileNotGoodException(itos(dbr).c_str()); + + dbr = sqlite3_prepare_v2(dbh, "INSERT INTO `actor` (`name`) VALUES (?)", -1, &dbs_knownActor_insert, NULL); + if (dbr != SQLITE_OK) + throw FileNotGoodException(itos(dbr).c_str()); + + dbr = sqlite3_prepare_v2(dbh, "SELECT `id`, `name` FROM `node`", -1, &dbs_knownNode_select, NULL); + if (dbr != SQLITE_OK) + throw FileNotGoodException(itos(dbr).c_str()); + + dbr = sqlite3_prepare_v2(dbh, "INSERT INTO `node` (`name`) VALUES (?)", -1, &dbs_knownNode_insert, NULL); + if (dbr != SQLITE_OK) + throw FileNotGoodException(itos(dbr).c_str()); + + infostream << "SQL prepared statements setup correctly" << std::endl; + + int select; + + sqlite3_reset(dbs_knownActor_select); + while (SQLITE_ROW == (select = sqlite3_step(dbs_knownActor_select))) + registerNewActor( + sqlite3_column_int (dbs_knownActor_select, 0), + reinterpret_cast(sqlite3_column_text (dbs_knownActor_select, 1)) + ); + + sqlite3_reset(dbs_knownNode_select); + while (SQLITE_ROW == (select = sqlite3_step(dbs_knownNode_select))) + registerNewNode( + sqlite3_column_int (dbs_knownNode_select, 0), + reinterpret_cast(sqlite3_column_text (dbs_knownNode_select, 1)) + ); + + return; +} +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_int (dbs_do, 1, row.actor); + 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_int (dbs_do, 7, row.stack.node); + bind[ii++] = sqlite3_bind_int (dbs_do, 8, row.stack.quantity); + bind[ii++] = sqlite3_bind_int (dbs_do, 9, (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, 10, atoi(x.c_str())); + bind[ii++] = sqlite3_bind_int (dbs_do, 11, atoi(y.c_str())); + bind[ii++] = sqlite3_bind_int (dbs_do, 12, 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); + bind[ii++] = sqlite3_bind_null (dbs_do, 9); + } + + if (row.type == RollbackAction::TYPE_SET_NODE) + { + bind[ii++] = sqlite3_bind_int (dbs_do, 10, row.x); + bind[ii++] = sqlite3_bind_int (dbs_do, 11, row.y); + bind[ii++] = sqlite3_bind_int (dbs_do, 12, row.z); + bind[ii++] = sqlite3_bind_int (dbs_do, 13, row.oldNode); + bind[ii++] = sqlite3_bind_int (dbs_do, 14, row.oldParam1); + bind[ii++] = sqlite3_bind_int (dbs_do, 15, row.oldParam2); + bind[ii++] = sqlite3_bind_text (dbs_do, 16, row.oldMeta.c_str(), row.oldMeta.size(), NULL); + bind[ii++] = sqlite3_bind_int (dbs_do, 17, row.newNode); + bind[ii++] = sqlite3_bind_int (dbs_do, 18, row.newParam1); + bind[ii++] = sqlite3_bind_int (dbs_do, 19, row.newParam2); + bind[ii++] = sqlite3_bind_text (dbs_do, 20, row.newMeta.c_str(), row.newMeta.size(), NULL); + bind[ii++] = sqlite3_bind_int (dbs_do, 21, row.guessed? 1: 0); + } + else + { + if (!nodeMeta) + { + 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); + bind[ii++] = sqlite3_bind_null (dbs_do, 21); + } + + if (row.id) + bind[ii++] = sqlite3_bind_int (dbs_do, 22, row.id); + + for (ii = 0; ii < 20; ++ii) + if (bind[ii] != SQLITE_OK) + infostream + << "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 actionRowsFromSelect (sqlite3_stmt* stmt) +{ + std::list rows; + const unsigned char * text; + size_t size; + + while (SQLITE_ROW == sqlite3_step(stmt)) + { + ActionRow row; + + row.actor = sqlite3_column_int (stmt, 0); + row.timestamp = sqlite3_column_int (stmt, 1); + row.type = sqlite3_column_int (stmt, 2); + + if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK) + { + text = sqlite3_column_text (stmt, 3); + size = sqlite3_column_bytes(stmt, 3); + row.list = std::string(reinterpret_cast(text), size); + row.index = sqlite3_column_int (stmt, 4); + row.add = sqlite3_column_int (stmt, 5); + row.stack.node = sqlite3_column_int (stmt, 6); + row.stack.quantity = sqlite3_column_int (stmt, 7); + row.nodeMeta = sqlite3_column_int (stmt, 8); + } + + if (row.type == RollbackAction::TYPE_SET_NODE || row.nodeMeta) + { + row.x = sqlite3_column_int (stmt, 9); + row.y = sqlite3_column_int (stmt, 10); + row.z = sqlite3_column_int (stmt, 11); + } + + if (row.type == RollbackAction::TYPE_SET_NODE) + { + row.oldNode = sqlite3_column_int (stmt, 12); + row.oldParam1 = sqlite3_column_int (stmt, 13); + row.oldParam2 = sqlite3_column_int (stmt, 14); + text = sqlite3_column_text (stmt, 15); + size = sqlite3_column_bytes(stmt, 15); + row.oldMeta = std::string(reinterpret_cast(text), size); + row.newNode = sqlite3_column_int (stmt, 16); + row.newParam1 = sqlite3_column_int (stmt, 17); + row.newParam2 = sqlite3_column_int (stmt, 18); + text = sqlite3_column_text (stmt, 19); + size = sqlite3_column_bytes(stmt, 19); + row.newMeta = std::string(reinterpret_cast(text), size); + row.guessed = sqlite3_column_int (stmt, 20); + } + + row.location = row.nodeMeta? "nodemeta:": getActorName(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 << "stackNode: " << row.stack.node << "\n"; + std::cout << "stackQuantity: " << row.stack.quantity << "\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); + } + + return rows; +} +ActionRow actionRowFromRollbackAction (RollbackAction action) +{ + ActionRow row; + + row.id = 0; + row.actor = getActorId(action.actor); + row.timestamp = action.unix_time; + row.type = action.type; + + if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK) + { + row.location = action.inventory_location; + row.list = action.inventory_list; + row.index = action.inventory_index; + row.add = action.inventory_add; + row.stack = getStackFromString(action.inventory_stack); + } + else + { + row.x = action.p.X; + row.y = action.p.Y; + row.z = action.p.Z; + row.oldNode = getNodeId(action.n_old.name); + row.oldParam1 = action.n_old.param1; + row.oldParam2 = action.n_old.param2; + row.oldMeta = action.n_old.meta; + row.newNode = getNodeId(action.n_new.name); + row.newParam1 = action.n_new.param1; + row.newParam2 = action.n_new.param2; + row.newMeta = action.n_new.meta; + row.guessed = action.actor_is_guess; + } + + return row; +} +std::list rollbackActionsFromActionRows (std::list rows) +{ + std::list actions; + std::list::const_iterator it; + + for (it = rows.begin(); it != rows.end(); ++it) + { + RollbackAction action; + action.actor = (it->actor)? getActorName(it->actor): ""; + action.unix_time = it->timestamp; + action.type = static_cast(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 = getStringFromStack(it->stack); + break; + + case RollbackAction::TYPE_SET_NODE: + + action.p = v3s16(it->x, it->y, it->z); + action.n_old.name = getNodeName(it->oldNode); + action.n_old.param1 = it->oldParam1; + action.n_old.param2 = it->oldParam2; + action.n_old.meta = it->oldMeta; + action.n_new.name = getNodeName(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; +} +std::list SQL_getRowsSince (int firstTime, std::string actor = "") +{ + sqlite3_stmt * dbs_stmt = (!actor.length())? dbs_select: dbs_select_withActor; + sqlite3_reset (dbs_stmt); + sqlite3_bind_int (dbs_stmt, 1, firstTime); + + if (actor.length()) + sqlite3_bind_int (dbs_stmt, 2, getActorId(actor)); + + return actionRowsFromSelect(dbs_stmt); +} +std::list SQL_getRowsSince_range (int firstTime, v3s16 p, int range) +{ + sqlite3_stmt * stmt = dbs_select_range; + sqlite3_reset(stmt); + + sqlite3_bind_int(stmt, 1, firstTime); + sqlite3_bind_int(stmt, 2, (int) p.X); + sqlite3_bind_int(stmt, 3, range); + sqlite3_bind_int(stmt, 4, (int) p.Y); + sqlite3_bind_int(stmt, 5, range); + sqlite3_bind_int(stmt, 6, (int) p.Z); + sqlite3_bind_int(stmt, 7, range); + + return actionRowsFromSelect(stmt); +} +std::list SQL_getActionsSince_range (int firstTime, v3s16 p, int range) +{ + std::list rows = SQL_getRowsSince_range(firstTime, p, range); + + return rollbackActionsFromActionRows(rows); +} +std::list SQL_getActionsSince (int firstTime, std::string actor = "") +{ + std::list rows = SQL_getRowsSince(firstTime, actor); + return rollbackActionsFromActionRows(rows); +} +void TXT_migrate (std::string filepath) +{ + std::cout << "Migrating from rollback.txt to rollback.sqlite" << std::endl; + SQL_databaseCheck(); + + std::ifstream fh (filepath.c_str(), std::ios::in | std::ios::ate); + if (!fh.good()) throw("DIE"); + + int filesize = fh.tellg(); + + if (filesize > 10) + { + fh.seekg(0); + + 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 = getActorId(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 = getStackFromString(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 = getNodeId(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 = getNodeId(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); ++i; + + if (time(0) - t) + { + sqlite3_exec(dbh, "COMMIT", NULL, NULL, NULL); + t = time(0) - t; + std::cout + << " Done: " << (int)(((float) fh.tellg() / (float) filesize) * 100) << "%" + << "\tSpeed: " << i / t << " actions inserted per second " + << "\r"; + std::cout.flush(); + i = 0; + } + + ++id; + } + while (!fh.eof() && fh.good()); + } + + std::cout + << " Done: 100%" << std::endl + << " Now you can delete the old rollback.txt file." << std::endl; +} // 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, @@ -56,38 +921,43 @@ static float getSuspectNearness(bool is_guess, v3s16 suspect_p, int suspect_t, f = 0; return f; } - class RollbackManager: public IRollbackManager { public: // IRollbackManager interface - 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="<::const_iterator - i = m_action_todisk_buffer.begin(); - i != m_action_todisk_buffer.end(); i++) + infostream << "RollbackManager::flush()" << std::endl; + + sqlite3_exec(dbh, "BEGIN", NULL, NULL, NULL); + + std::list::const_iterator iter; + + for (iter = m_action_todisk_buffer.begin(); + iter != m_action_todisk_buffer.end(); + iter++) { - // Do not save stuff that does not have an actor - if(i->actor == "") + if (iter->actor == "") continue; - of<unix_time; - of<<" "; - of<actor); - of<<" "; - of<toString(); - if(i->actor_is_guess){ - of<<" "; - of<<"actor_is_guess"; - } - of<= 100) + if(m_action_todisk_buffer.size() >= 500) flush(); } - - bool readFile(std::list &dst) - { - // Load whole file to memory - std::ifstream f(m_filepath.c_str(), std::ios::in); - if(!f.good()){ - errorstream<<"RollbackManager::readFile(): Could not open " - <<"file for reading: \""< getEntriesSince(int first_time) { - infostream<<"RollbackManager::getEntriesSince("< action_buffer; - // Use the latest buffer if it is long enough - if(!m_action_latest_buffer.empty() && - m_action_latest_buffer.begin()->unix_time <= first_time){ - action_buffer = m_action_latest_buffer; - } - else - { - // Save all remaining stuff - flush(); - // Load whole file to memory - bool good = readFile(action_buffer); - if(!good){ - errorstream<<"RollbackManager::getEntriesSince(): Failed to" - <<" open file; using data in memory."< result = SQL_getActionsSince(first_time); + + return result; } - - std::string getLastNodeActor(v3s16 p, int range, int seconds, - v3s16 *act_p, int *act_seconds) + std::string getLastNodeActor(v3s16 p, int range, int seconds, v3s16 *act_p, int *act_seconds) { - infostream<<"RollbackManager::getLastNodeActor("< action_buffer = getEntriesSince(first_time); - - std::list result; + std::list action_buffer = SQL_getActionsSince_range(first_time, p, range); + std::list::const_reverse_iterator iter; - for(std::list::const_reverse_iterator - i = action_buffer.rbegin(); - i != action_buffer.rend(); i++) + for (iter = action_buffer.rbegin(); + iter != action_buffer.rend(); + iter++) { - if(i->unix_time < first_time) - break; - - // Find position of action or continue v3s16 action_p; - if(!i->getPosition(&action_p)) - continue; - if(range == 0){ - if(action_p != p) - continue; - } else { - if(abs(action_p.X - p.X) > range || - abs(action_p.Y - p.Y) > range || - abs(action_p.Z - p.Z) > range) - continue; - } + action_p.X = iter->p.X; + action_p.Y = iter->p.Y; + action_p.Z = iter->p.Z; - if(act_p) + if (act_p) *act_p = action_p; - if(act_seconds) - *act_seconds = cur_time - i->unix_time; - return i->actor; + + if (act_seconds) + *act_seconds = cur_time - iter->unix_time; + + return iter->actor; } + return ""; } - - std::list getRevertActions(const std::string &actor_filter, - int seconds) + std::list getRevertActions(const std::string &actor_filter, int seconds) { - infostream<<"RollbackManager::getRevertActions("< action_buffer = getEntriesSince(first_time); + flush(); - std::list result; - - for(std::list::const_reverse_iterator - i = action_buffer.rbegin(); - i != action_buffer.rend(); i++) - { - if(i->unix_time < first_time) - break; - if(i->actor != actor_filter) - continue; - const RollbackAction &action = *i; - /*infostream<<"RollbackManager::revertAction(): Should revert" - <<" time="<