X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Frollback.cpp;h=3cd9c7ce7c63c2e4ca748480dc7a2191924a1d99;hb=4be46aeeb17c42718ecea14934e24d77772b4126;hp=b95cc7bf3fce02b00db434fd3967a2b617c45500;hpb=1fd9a11e302566d207c046bd5145e4e05a3c58ea;p=dragonfireclient.git diff --git a/src/rollback.cpp b/src/rollback.cpp index b95cc7bf3..3cd9c7ce7 100644 --- a/src/rollback.cpp +++ b/src/rollback.cpp @@ -32,639 +32,528 @@ with this program; if not, write to the Free Software Foundation, Inc., #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; +#define SQLRES(f, good) \ + if ((f) != (good)) {\ + throw FileNotGoodException(std::string("RollbackManager: " \ + "SQLite3 error (" __FILE__ ":" TOSTRING(__LINE__) \ + "): ") + sqlite3_errmsg(db)); \ + } +#define SQLOK(f) SQLRES(f, SQLITE_OK) + +#define SQLOK_ERRSTREAM(s, m) \ + if ((s) != SQLITE_OK) { \ + errorstream << "RollbackManager: " << (m) << ": " \ + << sqlite3_errmsg(db) << std::endl; \ + } + +#define FINALIZE_STATEMENT(statement) \ + SQLOK_ERRSTREAM(sqlite3_finalize(statement), "Failed to finalize " #statement) + +class ItemStackRow : public ItemStack { +public: + ItemStackRow & operator = (const ItemStack & other) + { + *static_cast(this) = other; + return *this; + } + + int id; }; -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 ActionRow { + int id; + int actor; + time_t timestamp; + int type; + std::string location, list; + int index, add; + ItemStackRow 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; + + +struct Entity { + int id; + std::string name; }; -typedef std::vector Entities; -Entities KnownActors; -Entities KnownNodes; -void registerNewActor (int id, std::string name) + +RollbackManager::RollbackManager(const std::string & world_path, + IGameDef * gamedef_) : + gamedef(gamedef_) { - Entity newActor; + verbosestream << "RollbackManager::RollbackManager(" << world_path + << ")" << std::endl; - newActor.id = id; - newActor.name = name; + std::string txt_filename = world_path + DIR_DELIM "rollback.txt"; + std::string migrating_flag = txt_filename + ".migrating"; + database_path = world_path + DIR_DELIM "rollback.sqlite"; - KnownActors.push_back(newActor); + bool created = initDatabase(); - //std::cout << "New actor registered: " << id << " | " << name << std::endl; + if (fs::PathExists(txt_filename) && (created || + fs::PathExists(migrating_flag))) { + std::ofstream of(migrating_flag.c_str()); + of.close(); + migrate(txt_filename); + fs::DeleteSingleFileOrEmptyDirectory(migrating_flag); + } } -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; +RollbackManager::~RollbackManager() +{ + flush(); + + FINALIZE_STATEMENT(stmt_insert); + FINALIZE_STATEMENT(stmt_replace); + FINALIZE_STATEMENT(stmt_select); + FINALIZE_STATEMENT(stmt_select_range); + FINALIZE_STATEMENT(stmt_select_withActor); + FINALIZE_STATEMENT(stmt_knownActor_select); + FINALIZE_STATEMENT(stmt_knownActor_insert); + FINALIZE_STATEMENT(stmt_knownNode_select); + FINALIZE_STATEMENT(stmt_knownNode_insert); + + SQLOK_ERRSTREAM(sqlite3_close(db), "Could not close db"); } -int getActorId (std::string name) + + +void RollbackManager::registerNewActor(const int id, const std::string &name) { - Entities::const_iterator iter; + Entity actor = {id, name}; + knownActors.push_back(actor); +} - 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); +void RollbackManager::registerNewNode(const int id, const std::string &name) +{ + Entity node = {id, name}; + knownNodes.push_back(node); +} - int id = sqlite3_last_insert_rowid(dbh); - //std::cout << "Actor ID insert returns " << insert << std::endl; +int RollbackManager::getActorId(const std::string &name) +{ + for (std::vector::const_iterator iter = knownActors.begin(); + iter != knownActors.end(); ++iter) { + if (iter->name == name) { + return iter->id; + } + } + + SQLOK(sqlite3_bind_text(stmt_knownActor_insert, 1, name.c_str(), name.size(), NULL)); + SQLRES(sqlite3_step(stmt_knownActor_insert), SQLITE_DONE); + SQLOK(sqlite3_reset(stmt_knownActor_insert)); + int id = sqlite3_last_insert_rowid(db); 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 RollbackManager::getNodeId(const std::string &name) +{ + for (std::vector::const_iterator iter = knownNodes.begin(); + iter != knownNodes.end(); ++iter) { + if (iter->name == name) { + return iter->id; + } + } - int id = sqlite3_last_insert_rowid(dbh); + SQLOK(sqlite3_bind_text(stmt_knownNode_insert, 1, name.c_str(), name.size(), NULL)); + SQLRES(sqlite3_step(stmt_knownNode_insert), SQLITE_DONE); + SQLOK(sqlite3_reset(stmt_knownNode_insert)); + int id = sqlite3_last_insert_rowid(db); 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) +const char * RollbackManager::getActorName(const int id) +{ + for (std::vector::const_iterator 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) +const char * RollbackManager::getNodeName(const int id) +{ + for (std::vector::const_iterator 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) +bool RollbackManager::createTables() { - 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; + SQLOK(sqlite3_exec(db, + "CREATE TABLE IF NOT EXISTS `actor` (\n" + " `id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,\n" + " `name` TEXT NOT NULL\n" + ");\n" + "CREATE TABLE IF NOT EXISTS `node` (\n" + " `id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,\n" + " `name` TEXT NOT NULL\n" + ");\n" + "CREATE TABLE IF NOT EXISTS `action` (\n" + " `id` INTEGER PRIMARY KEY AUTOINCREMENT,\n" + " `actor` INTEGER NOT NULL,\n" + " `timestamp` TIMESTAMP NOT NULL,\n" + " `type` INTEGER NOT NULL,\n" + " `list` TEXT,\n" + " `index` INTEGER,\n" + " `add` INTEGER,\n" + " `stackNode` INTEGER,\n" + " `stackQuantity` INTEGER,\n" + " `nodeMeta` INTEGER,\n" + " `x` INT,\n" + " `y` INT,\n" + " `z` INT,\n" + " `oldNode` INTEGER,\n" + " `oldParam1` INTEGER,\n" + " `oldParam2` INTEGER,\n" + " `oldMeta` TEXT,\n" + " `newNode` INTEGER,\n" + " `newParam1` INTEGER,\n" + " `newParam2` INTEGER,\n" + " `newMeta` TEXT,\n" + " `guessedActor` INTEGER,\n" + " FOREIGN KEY (`actor`) REFERENCES `actor`(`id`),\n" + " FOREIGN KEY (`stackNode`) REFERENCES `node`(`id`),\n" + " FOREIGN KEY (`oldNode`) REFERENCES `node`(`id`),\n" + " FOREIGN KEY (`newNode`) REFERENCES `node`(`id`)\n" + ");\n" + "CREATE INDEX IF NOT EXISTS `actionIndex` ON `action`(`x`,`y`,`z`,`timestamp`,`actor`);\n", + NULL, NULL, NULL)); + verbosestream << "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); +bool RollbackManager::initDatabase() +{ + verbosestream << "RollbackManager: Database connection setup" << std::endl; - if (dbo != SQLITE_OK) - { - infostream - << "SQLROLLBACK: SQLite3 database failed to open: " - << sqlite3_errmsg(dbh) - << std::endl; - throw FileNotGoodException("Cannot open database file"); + bool needs_create = !fs::PathExists(database_path); + SQLOK(sqlite3_open_v2(database_path.c_str(), &db, + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL)); + + if (needs_create) { + createTables(); } - 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))) + SQLOK(sqlite3_prepare_v2(db, + "INSERT INTO `action` (\n" + " `actor`, `timestamp`, `type`,\n" + " `list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodeMeta`,\n" + " `x`, `y`, `z`,\n" + " `oldNode`, `oldParam1`, `oldParam2`, `oldMeta`,\n" + " `newNode`, `newParam1`, `newParam2`, `newMeta`,\n" + " `guessedActor`\n" + ") VALUES (\n" + " ?, ?, ?,\n" + " ?, ?, ?, ?, ?, ?,\n" + " ?, ?, ?,\n" + " ?, ?, ?, ?,\n" + " ?, ?, ?, ?,\n" + " ?" + ");", + -1, &stmt_insert, NULL)); + + SQLOK(sqlite3_prepare_v2(db, + "REPLACE INTO `action` (\n" + " `actor`, `timestamp`, `type`,\n" + " `list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodeMeta`,\n" + " `x`, `y`, `z`,\n" + " `oldNode`, `oldParam1`, `oldParam2`, `oldMeta`,\n" + " `newNode`, `newParam1`, `newParam2`, `newMeta`,\n" + " `guessedActor`, `id`\n" + ") VALUES (\n" + " ?, ?, ?,\n" + " ?, ?, ?, ?, ?, ?,\n" + " ?, ?, ?,\n" + " ?, ?, ?, ?,\n" + " ?, ?, ?, ?,\n" + " ?, ?\n" + ");", + -1, &stmt_replace, NULL)); + + SQLOK(sqlite3_prepare_v2(db, + "SELECT\n" + " `actor`, `timestamp`, `type`,\n" + " `list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodemeta`,\n" + " `x`, `y`, `z`,\n" + " `oldNode`, `oldParam1`, `oldParam2`, `oldMeta`,\n" + " `newNode`, `newParam1`, `newParam2`, `newMeta`,\n" + " `guessedActor`\n" + " FROM `action`\n" + " WHERE `timestamp` >= ?\n" + " ORDER BY `timestamp` DESC, `id` DESC", + -1, &stmt_select, NULL)); + + SQLOK(sqlite3_prepare_v2(db, + "SELECT\n" + " `actor`, `timestamp`, `type`,\n" + " `list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodemeta`,\n" + " `x`, `y`, `z`,\n" + " `oldNode`, `oldParam1`, `oldParam2`, `oldMeta`,\n" + " `newNode`, `newParam1`, `newParam2`, `newMeta`,\n" + " `guessedActor`\n" + "FROM `action`\n" + "WHERE `timestamp` >= ?\n" + " AND `x` IS NOT NULL\n" + " AND `y` IS NOT NULL\n" + " AND `z` IS NOT NULL\n" + " AND `x` BETWEEN ? AND ?\n" + " AND `y` BETWEEN ? AND ?\n" + " AND `z` BETWEEN ? AND ?\n" + "ORDER BY `timestamp` DESC, `id` DESC\n" + "LIMIT 0,?", + -1, &stmt_select_range, NULL)); + + SQLOK(sqlite3_prepare_v2(db, + "SELECT\n" + " `actor`, `timestamp`, `type`,\n" + " `list`, `index`, `add`, `stackNode`, `stackQuantity`, `nodemeta`,\n" + " `x`, `y`, `z`,\n" + " `oldNode`, `oldParam1`, `oldParam2`, `oldMeta`,\n" + " `newNode`, `newParam1`, `newParam2`, `newMeta`,\n" + " `guessedActor`\n" + "FROM `action`\n" + "WHERE `timestamp` >= ?\n" + " AND `actor` = ?\n" + "ORDER BY `timestamp` DESC, `id` DESC\n", + -1, &stmt_select_withActor, NULL)); + + SQLOK(sqlite3_prepare_v2(db, "SELECT `id`, `name` FROM `actor`", + -1, &stmt_knownActor_select, NULL)); + + SQLOK(sqlite3_prepare_v2(db, "INSERT INTO `actor` (`name`) VALUES (?)", + -1, &stmt_knownActor_insert, NULL)); + + SQLOK(sqlite3_prepare_v2(db, "SELECT `id`, `name` FROM `node`", + -1, &stmt_knownNode_select, NULL)); + + SQLOK(sqlite3_prepare_v2(db, "INSERT INTO `node` (`name`) VALUES (?)", + -1, &stmt_knownNode_insert, NULL)); + + verbosestream << "SQL prepared statements setup correctly" << std::endl; + + while (sqlite3_step(stmt_knownActor_select) == SQLITE_ROW) { registerNewActor( - sqlite3_column_int (dbs_knownActor_select, 0), - reinterpret_cast(sqlite3_column_text (dbs_knownActor_select, 1)) + sqlite3_column_int(stmt_knownActor_select, 0), + reinterpret_cast(sqlite3_column_text(stmt_knownActor_select, 1)) ); + } + SQLOK(sqlite3_reset(stmt_knownActor_select)); - sqlite3_reset(dbs_knownNode_select); - while (SQLITE_ROW == (select = sqlite3_step(dbs_knownNode_select))) + while (sqlite3_step(stmt_knownNode_select) == SQLITE_ROW) { registerNewNode( - sqlite3_column_int (dbs_knownNode_select, 0), - reinterpret_cast(sqlite3_column_text (dbs_knownNode_select, 1)) + sqlite3_column_int(stmt_knownNode_select, 0), + reinterpret_cast(sqlite3_column_text(stmt_knownNode_select, 1)) ); + } + SQLOK(sqlite3_reset(stmt_knownNode_select)); - return; + return needs_create; } -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); +bool RollbackManager::registerRow(const ActionRow & row) +{ + sqlite3_stmt * stmt_do = (row.id) ? stmt_replace : stmt_insert; - 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())); + SQLOK(sqlite3_bind_int (stmt_do, 1, row.actor)); + SQLOK(sqlite3_bind_int64(stmt_do, 2, row.timestamp)); + SQLOK(sqlite3_bind_int (stmt_do, 3, row.type)); + + if (row.type == RollbackAction::TYPE_MODIFY_INVENTORY_STACK) { + const std::string & loc = row.location; + nodeMeta = (loc.substr(0, 9) == "nodemeta:"); + + SQLOK(sqlite3_bind_text(stmt_do, 4, row.list.c_str(), row.list.size(), NULL)); + SQLOK(sqlite3_bind_int (stmt_do, 5, row.index)); + SQLOK(sqlite3_bind_int (stmt_do, 6, row.add)); + SQLOK(sqlite3_bind_int (stmt_do, 7, row.stack.id)); + SQLOK(sqlite3_bind_int (stmt_do, 8, row.stack.count)); + SQLOK(sqlite3_bind_int (stmt_do, 9, (int) nodeMeta)); + + if (nodeMeta) { + std::string::size_type p1, p2; + p1 = loc.find(':') + 1; + p2 = loc.find(','); + std::string x = loc.substr(p1, p2 - p1); + p1 = p2 + 1; + p2 = loc.find(',', p1); + std::string y = loc.substr(p1, p2 - p1); + std::string z = loc.substr(p2 + 1); + SQLOK(sqlite3_bind_int(stmt_do, 10, atoi(x.c_str()))); + SQLOK(sqlite3_bind_int(stmt_do, 11, atoi(y.c_str()))); + SQLOK(sqlite3_bind_int(stmt_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); + } else { + SQLOK(sqlite3_bind_null(stmt_do, 4)); + SQLOK(sqlite3_bind_null(stmt_do, 5)); + SQLOK(sqlite3_bind_null(stmt_do, 6)); + SQLOK(sqlite3_bind_null(stmt_do, 7)); + SQLOK(sqlite3_bind_null(stmt_do, 8)); + SQLOK(sqlite3_bind_null(stmt_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); + if (row.type == RollbackAction::TYPE_SET_NODE) { + SQLOK(sqlite3_bind_int (stmt_do, 10, row.x)); + SQLOK(sqlite3_bind_int (stmt_do, 11, row.y)); + SQLOK(sqlite3_bind_int (stmt_do, 12, row.z)); + SQLOK(sqlite3_bind_int (stmt_do, 13, row.oldNode)); + SQLOK(sqlite3_bind_int (stmt_do, 14, row.oldParam1)); + SQLOK(sqlite3_bind_int (stmt_do, 15, row.oldParam2)); + SQLOK(sqlite3_bind_text(stmt_do, 16, row.oldMeta.c_str(), row.oldMeta.size(), NULL)); + SQLOK(sqlite3_bind_int (stmt_do, 17, row.newNode)); + SQLOK(sqlite3_bind_int (stmt_do, 18, row.newParam1)); + SQLOK(sqlite3_bind_int (stmt_do, 19, row.newParam2)); + SQLOK(sqlite3_bind_text(stmt_do, 20, row.newMeta.c_str(), row.newMeta.size(), NULL)); + SQLOK(sqlite3_bind_int (stmt_do, 21, row.guessed ? 1 : 0)); + } else { + if (!nodeMeta) { + SQLOK(sqlite3_bind_null(stmt_do, 10)); + SQLOK(sqlite3_bind_null(stmt_do, 11)); + SQLOK(sqlite3_bind_null(stmt_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); + SQLOK(sqlite3_bind_null(stmt_do, 13)); + SQLOK(sqlite3_bind_null(stmt_do, 14)); + SQLOK(sqlite3_bind_null(stmt_do, 15)); + SQLOK(sqlite3_bind_null(stmt_do, 16)); + SQLOK(sqlite3_bind_null(stmt_do, 17)); + SQLOK(sqlite3_bind_null(stmt_do, 18)); + SQLOK(sqlite3_bind_null(stmt_do, 19)); + SQLOK(sqlite3_bind_null(stmt_do, 20)); + SQLOK(sqlite3_bind_null(stmt_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; + if (row.id) { + SQLOK(sqlite3_bind_int(stmt_do, 22, row.id)); } - */ - int written = sqlite3_step(dbs_do); + int written = sqlite3_step(stmt_do); - return written == SQLITE_DONE; + SQLOK(sqlite3_reset(stmt_do)); - //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; + return written == SQLITE_DONE; } -std::list actionRowsFromSelect (sqlite3_stmt* stmt) + + +const std::list RollbackManager::actionRowsFromSelect(sqlite3_stmt* stmt) { std::list rows; const unsigned char * text; size_t size; - while (SQLITE_ROW == sqlite3_step(stmt)) - { + while (sqlite3_step(stmt) == SQLITE_ROW) { 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); + row.actor = sqlite3_column_int (stmt, 0); + row.timestamp = sqlite3_column_int64(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.id = sqlite3_column_int(stmt, 6); + row.stack.count = 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); + 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); } - 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)); + 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); } - /* - 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"; + if (row.nodeMeta) { + row.location = "nodemeta:"; + row.location += itos(row.x); + row.location += ','; + row.location += itos(row.y); + row.location += ','; + row.location += itos(row.z); + } else { + row.location = getActorName(row.actor); } - */ rows.push_back(row); } + SQLOK(sqlite3_reset(stmt)); + return rows; } -ActionRow actionRowFromRollbackAction (RollbackAction action) + + +ActionRow RollbackManager::actionRowFromRollbackAction(const RollbackAction & action) { ActionRow row; - row.id = 0; - row.actor = getActorId(action.actor); - row.timestamp = action.unix_time; - row.type = action.type; + 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) - { + 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.stack = action.inventory_stack; + row.stack.id = getNodeId(row.stack.name); + } else { row.x = action.p.X; row.y = action.p.Y; row.z = action.p.Z; @@ -681,46 +570,46 @@ ActionRow actionRowFromRollbackAction (RollbackAction action) return row; } -std::list rollbackActionsFromActionRows (std::list rows) + + +const std::list RollbackManager::rollbackActionsFromActionRows( + const std::list & rows) { std::list actions; - std::list::const_iterator it; - for (it = rows.begin(); it != rows.end(); ++it) - { + for (const ActionRow &row : rows) { 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; + action.actor = (row.actor) ? getActorName(row.actor) : ""; + action.unix_time = row.timestamp; + action.type = static_cast(row.type); + + switch (action.type) { + case RollbackAction::TYPE_MODIFY_INVENTORY_STACK: + action.inventory_location = row.location; + action.inventory_list = row.list; + action.inventory_index = row.index; + action.inventory_add = row.add; + action.inventory_stack = row.stack; + if (action.inventory_stack.name.empty()) { + action.inventory_stack.name = getNodeName(row.stack.id); + } + break; + + case RollbackAction::TYPE_SET_NODE: + action.p = v3s16(row.x, row.y, row.z); + action.n_old.name = getNodeName(row.oldNode); + action.n_old.param1 = row.oldParam1; + action.n_old.param2 = row.oldParam2; + action.n_old.meta = row.oldMeta; + action.n_new.name = getNodeName(row.newNode); + action.n_new.param1 = row.newParam1; + action.n_new.param2 = row.newParam2; + action.n_new.meta = row.newMeta; + break; + + default: + throw ("W.T.F."); + break; } actions.push_back(action); @@ -728,185 +617,190 @@ std::list rollbackActionsFromActionRows (std::list ro 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) +const std::list RollbackManager::getRowsSince(time_t firstTime, const std::string & actor) { - 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); + sqlite3_stmt *stmt_stmt = actor.empty() ? stmt_select : stmt_select_withActor; + sqlite3_bind_int64(stmt_stmt, 1, firstTime); + + if (!actor.empty()) { + sqlite3_bind_int(stmt_stmt, 2, getActorId(actor)); + } + + const std::list & rows = actionRowsFromSelect(stmt_stmt); + sqlite3_reset(stmt_stmt); + + return rows; } -std::list SQL_getActionsSince_range (int firstTime, v3s16 p, int range) + + +const std::list RollbackManager::getRowsSince_range( + time_t start_time, v3s16 p, int range, int limit) { - std::list rows = SQL_getRowsSince_range(firstTime, p, range); - return rollbackActionsFromActionRows(rows); + sqlite3_bind_int64(stmt_select_range, 1, start_time); + sqlite3_bind_int (stmt_select_range, 2, static_cast(p.X - range)); + sqlite3_bind_int (stmt_select_range, 3, static_cast(p.X + range)); + sqlite3_bind_int (stmt_select_range, 4, static_cast(p.Y - range)); + sqlite3_bind_int (stmt_select_range, 5, static_cast(p.Y + range)); + sqlite3_bind_int (stmt_select_range, 6, static_cast(p.Z - range)); + sqlite3_bind_int (stmt_select_range, 7, static_cast(p.Z + range)); + sqlite3_bind_int (stmt_select_range, 8, limit); + + const std::list & rows = actionRowsFromSelect(stmt_select_range); + sqlite3_reset(stmt_select_range); + + return rows; } -std::list SQL_getActionsSince (int firstTime, std::string actor = "") + + +const std::list RollbackManager::getActionsSince_range( + time_t start_time, v3s16 p, int range, int limit) { - std::list rows = SQL_getRowsSince(firstTime, actor); - return rollbackActionsFromActionRows(rows); + return rollbackActionsFromActionRows(getRowsSince_range(start_time, p, range, limit)); } -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(); +const std::list RollbackManager::getActionsSince( + time_t start_time, const std::string & actor) +{ + return rollbackActionsFromActionRows(getRowsSince(start_time, actor)); +} - if (filesize > 10) - { - fh.seekg(0); - std::string bit; - int i = 0; - int id = 1; - int t = 0; - do - { - ActionRow row; +void RollbackManager::migrate(const std::string & file_path) +{ + std::cout << "Migrating from rollback.txt to rollback.sqlite." << std::endl; - row.id = id; + std::ifstream fh(file_path.c_str(), std::ios::in | std::ios::ate); + if (!fh.good()) { + throw FileNotGoodException("Unable to open rollback.txt"); + } - // 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()); + std::streampos file_size = fh.tellg(); - // Get the actor - row.actor = getActorId(trim(deSerializeJsonString(fh))); + if (file_size < 10) { + errorstream << "Empty rollback log." << std::endl; + return; + } - // Get the action type - std::getline(fh, bit, '['); - std::getline(fh, bit, ' '); + fh.seekg(0); - 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" ); - } + sqlite3_stmt *stmt_begin; + sqlite3_stmt *stmt_commit; + SQLOK(sqlite3_prepare_v2(db, "BEGIN", -1, &stmt_begin, NULL)); + SQLOK(sqlite3_prepare_v2(db, "COMMIT", -1, &stmt_commit, NULL)); - /* - 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; - } - */ + std::string bit; + int i = 0; + time_t start = time(0); + time_t t = start; + SQLRES(sqlite3_step(stmt_begin), SQLITE_DONE); + sqlite3_reset(stmt_begin); + do { + ActionRow row; + row.id = 0; + + // Get the timestamp + std::getline(fh, bit, ' '); + bit = trim(bit); + if (!atoi(bit.c_str())) { + std::getline(fh, bit); + continue; + } + row.timestamp = atoi(bit.c_str()); - if (i == 0) - { - t = time(0); - sqlite3_exec(dbh, "BEGIN", NULL, NULL, NULL); - } + // Get the actor + row.actor = getActorId(deSerializeJsonString(fh)); - 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; - } + // Get the action type + std::getline(fh, bit, '['); + std::getline(fh, bit, ' '); + + if (bit == "modify_inventory_stack") { + 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.deSerialize(deSerializeJsonString(fh)); + row.stack.id = getNodeId(row.stack.name); + std::getline(fh, bit); + } else if (bit == "set_node") { + 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"); + } else { + errorstream << "Unrecognized rollback action type \"" + << bit << "\"!" << std::endl; + continue; + } - ++id; + registerRow(row); + ++i; + + if (time(0) - t >= 1) { + SQLRES(sqlite3_step(stmt_commit), SQLITE_DONE); + sqlite3_reset(stmt_commit); + t = time(0); + std::cout + << " Done: " << static_cast((static_cast(fh.tellg()) / static_cast(file_size)) * 100) << "%" + << " Speed: " << i / (t - start) << "/second \r" << std::flush; + SQLRES(sqlite3_step(stmt_begin), SQLITE_DONE); + sqlite3_reset(stmt_begin); } - while (!fh.eof() && fh.good()); - } + } while (fh.good()); + SQLRES(sqlite3_step(stmt_commit), SQLITE_DONE); + sqlite3_reset(stmt_commit); + + SQLOK(sqlite3_finalize(stmt_begin)); + SQLOK(sqlite3_finalize(stmt_commit)); std::cout - << " Done: 100%" << std::endl - << " Now you can delete the old rollback.txt file." << std::endl; + << " 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, - v3s16 action_p, int action_t) +float RollbackManager::getSuspectNearness(bool is_guess, v3s16 suspect_p, + time_t suspect_t, v3s16 action_p, time_t action_t) { // Suspect cannot cause things in the past - if(action_t < suspect_t) - return 0; // 0 = cannot be + if (action_t < suspect_t) { + return 0; // 0 = cannot be + } // Start from 100 int f = 100; // Distance (1 node = -x points) @@ -914,237 +808,164 @@ static float getSuspectNearness(bool is_guess, v3s16 suspect_p, int suspect_t, // Time (1 second = -x points) f -= 1 * (action_t - suspect_t); // If is a guess, halve the points - if(is_guess) + if (is_guess) { f *= 0.5; + } // Limit to 0 - if(f < 0) + if (f < 0) { 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)) - 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; +void RollbackManager::reportAction(const RollbackAction &action_) +{ + // Ignore if not important + if (!action_.isImportant(gamedef)) { + return; + } - if (action.actor.empty()) // If actor is not known, find out suspect or cancel - { - v3s16 p; - if (!action.getPosition(&p)) - return; + RollbackAction action = action_; + action.unix_time = time(0); - action.actor = getSuspect(p, 83, 1); - if (action.actor.empty()) - return; + // Figure out actor + action.actor = current_actor; + action.actor_is_guess = current_actor_is_guess; - action.actor_is_guess = true; + if (action.actor.empty()) { // If actor is not known, find out suspect or cancel + v3s16 p; + if (!action.getPosition(&p)) { + return; } - 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() - { - return m_current_actor; - } - bool isActorGuess() - { - return m_current_actor_is_guess; - } - void setActor(const std::string &actor, bool is_guess) - { - m_current_actor = actor; - m_current_actor_is_guess = is_guess; - } - std::string getSuspect(v3s16 p, float nearness_shortcut, float min_nearness) - { - if(m_current_actor != "") - return m_current_actor; - int cur_time = time(0); - int first_time = cur_time - (100-min_nearness); - RollbackAction likely_suspect; - float likely_suspect_nearness = 0; - for(std::list::const_reverse_iterator - i = m_action_latest_buffer.rbegin(); - i != m_action_latest_buffer.rend(); i++) - { - if(i->unix_time < first_time) - break; - if(i->actor == "") - continue; - // Find position of suspect or continue - v3s16 suspect_p; - if(!i->getPosition(&suspect_p)) - continue; - float f = getSuspectNearness(i->actor_is_guess, suspect_p, - i->unix_time, p, cur_time); - if(f >= min_nearness && f > likely_suspect_nearness){ - likely_suspect_nearness = f; - likely_suspect = *i; - if(likely_suspect_nearness >= nearness_shortcut) - break; - } + action.actor = getSuspect(p, 83, 1); + if (action.actor.empty()) { + return; } - // No likely suspect was found - if(likely_suspect_nearness == 0) - return ""; - // Likely suspect was found - return likely_suspect.actor; + + action.actor_is_guess = true; } - void flush() - { - infostream << "RollbackManager::flush()" << std::endl; - sqlite3_exec(dbh, "BEGIN", NULL, NULL, NULL); + addAction(action); +} - std::list::const_iterator iter; +std::string RollbackManager::getActor() +{ + return current_actor; +} - for (iter = m_action_todisk_buffer.begin(); - iter != m_action_todisk_buffer.end(); - iter++) - { - if (iter->actor == "") - continue; +bool RollbackManager::isActorGuess() +{ + return current_actor_is_guess; +} - SQL_registerRow(actionRowFromRollbackAction(*iter)); - } +void RollbackManager::setActor(const std::string & actor, bool is_guess) +{ + current_actor = actor; + current_actor_is_guess = is_guess; +} - sqlite3_exec(dbh, "COMMIT", NULL, NULL, NULL); - m_action_todisk_buffer.clear(); +std::string RollbackManager::getSuspect(v3s16 p, float nearness_shortcut, + float min_nearness) +{ + if (!current_actor.empty()) { + return current_actor; } - 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; - - // Operate correctly in case of still being given rollback.txt as filepath - std::string directory = filepath.substr(0, filepath.rfind(DIR_DELIM) + 1); - std::string filenameOld = filepath.substr(1+ filepath.rfind(DIR_DELIM)); - std::string filenameNew = (filenameOld == "rollback.txt")? "rollback.sqlite": filenameOld; - std::string filenameTXT = directory + "rollback.txt"; - std::string migratingFlag = filepath; - migratingFlag.append(".migrating"); - - infostream << "Directory: " << directory << std::endl; - infostream << "CheckFor: " << filenameTXT << std::endl; - infostream << "FileOld: " << filenameOld << std::endl; - infostream << "FileNew: " << filenameNew << std::endl; - - dbp = directory + filenameNew; - - if ((fs::PathExists(filenameTXT) && fs::PathExists(migratingFlag)) - || (fs::PathExists(filenameTXT) && !fs::PathExists(dbp))) - { - std::ofstream of(migratingFlag.c_str()); - TXT_migrate(filenameTXT); - fs::DeleteSingleFileOrEmptyDirectory(migratingFlag); + int cur_time = time(0); + time_t first_time = cur_time - (100 - min_nearness); + RollbackAction likely_suspect; + float likely_suspect_nearness = 0; + for (std::list::const_reverse_iterator + i = action_latest_buffer.rbegin(); + i != action_latest_buffer.rend(); ++i) { + if (i->unix_time < first_time) { + break; + } + if (i->actor.empty()) { + continue; + } + // Find position of suspect or continue + v3s16 suspect_p; + if (!i->getPosition(&suspect_p)) { + continue; + } + float f = getSuspectNearness(i->actor_is_guess, suspect_p, + i->unix_time, p, cur_time); + if (f >= min_nearness && f > likely_suspect_nearness) { + likely_suspect_nearness = f; + likely_suspect = *i; + if (likely_suspect_nearness >= nearness_shortcut) { + break; + } } - - SQL_databaseCheck(); } - ~RollbackManager() - { - infostream << "RollbackManager::~RollbackManager()" << std::endl; - flush(); + // No likely suspect was found + if (likely_suspect_nearness == 0) { + return ""; } - void addAction(const RollbackAction &action) - { - m_action_todisk_buffer.push_back(action); - m_action_latest_buffer.push_back(action); + // Likely suspect was found + return likely_suspect.actor; +} - // Flush to disk sometimes - if(m_action_todisk_buffer.size() >= 500) - flush(); - } - std::list getEntriesSince(int first_time) - { - infostream - << "RollbackManager::getEntriesSince(" << first_time << ")" - << std::endl; - flush(); - - std::list result = SQL_getActionsSince(first_time); +void RollbackManager::flush() +{ + sqlite3_exec(db, "BEGIN", NULL, NULL, NULL); - return result; - } - std::string getLastNodeActor(v3s16 p, int range, int seconds, v3s16 *act_p, int *act_seconds) - { - int cur_time = time(0); - int first_time = cur_time - seconds; + std::list::const_iterator iter; - std::list action_buffer = SQL_getActionsSince_range(first_time, p, range); - std::list::const_reverse_iterator iter; + for (iter = action_todisk_buffer.begin(); + iter != action_todisk_buffer.end(); + ++iter) { + if (iter->actor.empty()) { + continue; + } - for (iter = action_buffer.rbegin(); - iter != action_buffer.rend(); - iter++) - { - v3s16 action_p; + registerRow(actionRowFromRollbackAction(*iter)); + } - action_p.X = iter->p.X; - action_p.Y = iter->p.Y; - action_p.Z = iter->p.Z; - - if (act_p) - *act_p = action_p; + sqlite3_exec(db, "COMMIT", NULL, NULL, NULL); + action_todisk_buffer.clear(); +} - if (act_seconds) - *act_seconds = cur_time - iter->unix_time; - return iter->actor; - } +void RollbackManager::addAction(const RollbackAction & action) +{ + action_todisk_buffer.push_back(action); + action_latest_buffer.push_back(action); - return ""; - } - std::list getRevertActions(const std::string &actor_filter, int seconds) - { - infostream - << "RollbackManager::getRevertActions(" << actor_filter - << ", " << seconds << ")" - << std::endl; - - // Figure out time - int cur_time = time(0); - int first_time = cur_time - seconds; - + // Flush to disk sometimes + if (action_todisk_buffer.size() >= 500) { flush(); - - std::list result = SQL_getActionsSince(first_time, actor_filter); - - return result; } -private: - std::string m_filepath; - IGameDef *m_gamedef; - std::string m_current_actor; - bool m_current_actor_is_guess; - std::list m_action_todisk_buffer; - std::list m_action_latest_buffer; -}; +} -IRollbackManager *createRollbackManager(const std::string &filepath, IGameDef *gamedef) +std::list RollbackManager::getEntriesSince(time_t first_time) { - return new RollbackManager(filepath, gamedef); + flush(); + return getActionsSince(first_time); +} + +std::list RollbackManager::getNodeActors(v3s16 pos, int range, + time_t seconds, int limit) +{ + flush(); + time_t cur_time = time(0); + time_t first_time = cur_time - seconds; + + return getActionsSince_range(first_time, pos, range, limit); } + +std::list RollbackManager::getRevertActions( + const std::string &actor_filter, + time_t seconds) +{ + time_t cur_time = time(0); + time_t first_time = cur_time - seconds; + + flush(); + + return getActionsSince(first_time, actor_filter); +} +