diff --git a/src/gamedef.h b/src/gamedef.h
index b7830373b0ccd8c2e559dbfa673f394c4e4907f3..793d85b39df07eb0c57d807d319f295ab00bb0ee 100644
--- a/src/gamedef.h
+++ b/src/gamedef.h
@@ -30,7 +30,7 @@ class ITextureSource;
class ISoundManager;
class IShaderSource;
class MtEventManager;
-class IRollbackReportSink;
+class IRollbackManager;
namespace irr { namespace scene {
class IAnimatedMesh;
class ISceneManager;
@@ -68,7 +68,7 @@ class IGameDef
// Only usable on the server, and NOT thread-safe. It is usable from the
// environment thread.
- virtual IRollbackReportSink* getRollbackReportSink(){return NULL;}
+ virtual IRollbackManager* getRollbackManager(){return NULL;}
// Used on the client
virtual bool checkLocalPrivilege(const std::string &priv)
@@ -82,7 +82,7 @@ class IGameDef
ISoundManager* sound(){return getSoundManager();}
IShaderSource* shsrc(){return getShaderSource();}
MtEventManager* event(){return getEventManager();}
- IRollbackReportSink* rollback(){return getRollbackReportSink();}
+ IRollbackManager* rollback(){return getRollbackManager();}
};
#endif
diff --git a/src/inventory.cpp b/src/inventory.cpp
index cecef01a0c2dbe1b28fb88e0f4c68652cbb9a6c8..3fa31965c5bf65ae28c51b8eb4bc76da4cf61002 100644
--- a/src/inventory.cpp
+++ b/src/inventory.cpp
@@ -183,7 +183,8 @@ void ItemStack::deSerialize(std::istream &is, IItemDefManager *itemdef)
legacy_nimap.getName(material, name);
if(name == "")
name = "unknown_block";
- name = itemdef->getAlias(name);
+ if (itemdef)
+ name = itemdef->getAlias(name);
count = materialcount;
}
else if(name == "MaterialItem2")
@@ -202,7 +203,8 @@ void ItemStack::deSerialize(std::istream &is, IItemDefManager *itemdef)
legacy_nimap.getName(material, name);
if(name == "")
name = "unknown_block";
- name = itemdef->getAlias(name);
+ if (itemdef)
+ name = itemdef->getAlias(name);
count = materialcount;
}
else if(name == "node" || name == "NodeItem" || name == "MaterialItem3"
@@ -223,7 +225,8 @@ void ItemStack::deSerialize(std::istream &is, IItemDefManager *itemdef)
name = fnd.next(" ");
}
fnd.skip_over(" ");
- name = itemdef->getAlias(name);
+ if (itemdef)
+ name = itemdef->getAlias(name);
count = stoi(trim(fnd.next("")));
if(count == 0)
count = 1;
@@ -252,7 +255,8 @@ void ItemStack::deSerialize(std::istream &is, IItemDefManager *itemdef)
count = 1;
// Then read wear
fnd.skip_over(" ");
- name = itemdef->getAlias(name);
+ if (itemdef)
+ name = itemdef->getAlias(name);
wear = stoi(trim(fnd.next("")));
}
else
@@ -262,7 +266,8 @@ void ItemStack::deSerialize(std::istream &is, IItemDefManager *itemdef)
// The real thing
// Apply item aliases
- name = itemdef->getAlias(name);
+ if (itemdef)
+ name = itemdef->getAlias(name);
// Read the count
std::string count_str;
@@ -294,9 +299,9 @@ void ItemStack::deSerialize(std::istream &is, IItemDefManager *itemdef)
} while(false);
}
- if(name.empty() || count == 0)
+ if (name.empty() || count == 0)
clear();
- else if(itemdef->get(name).type == ITEM_TOOL)
+ else if (itemdef && itemdef->get(name).type == ITEM_TOOL)
count = 1;
}
@@ -308,12 +313,12 @@ void ItemStack::deSerialize(const std::string &str, IItemDefManager *itemdef)
std::string ItemStack::getItemString() const
{
- // Get item string
std::ostringstream os(std::ios::binary);
serialize(os);
return os.str();
}
+
ItemStack ItemStack::addItem(const ItemStack &newitem_,
IItemDefManager *itemdef)
{
diff --git a/src/inventory.h b/src/inventory.h
index d21a5dedab29cf09e2abcdb5280aa416bfad1fc0..e4a97e1d37353f79f98b7eb5481be60c93cd49ca 100644
--- a/src/inventory.h
+++ b/src/inventory.h
@@ -20,12 +20,13 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#ifndef INVENTORY_HEADER
#define INVENTORY_HEADER
-#include <iostream>
-#include <string>
-#include <vector>
-#include "irrlichttypes.h"
#include "debug.h"
#include "itemdef.h"
+#include "irrlichttypes.h"
+#include <istream>
+#include <ostream>
+#include <string>
+#include <vector>
struct ToolCapabilities;
@@ -39,8 +40,9 @@ struct ItemStack
// Serialization
void serialize(std::ostream &os) const;
- void deSerialize(std::istream &is, IItemDefManager *itemdef);
- void deSerialize(const std::string &s, IItemDefManager *itemdef);
+ // Deserialization. Pass itemdef unless you don't want aliases resolved.
+ void deSerialize(std::istream &is, IItemDefManager *itemdef = NULL);
+ void deSerialize(const std::string &s, IItemDefManager *itemdef = NULL);
// Returns the string used for inventory
std::string getItemString() const;
diff --git a/src/inventorymanager.cpp b/src/inventorymanager.cpp
index 1ffcc3460a1c77cba33a41666a02bcacd9e12ebd..7486cc419c2b6ed40e3a293184c97ec7dd864780 100644
--- a/src/inventorymanager.cpp
+++ b/src/inventorymanager.cpp
@@ -368,7 +368,7 @@ void IMoveAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
*/
if(!ignore_rollback && gamedef->rollback())
{
- IRollbackReportSink *rollback = gamedef->rollback();
+ IRollbackManager *rollback = gamedef->rollback();
// If source is not infinite, record item take
if(src_can_take_count != -1){
@@ -380,7 +380,7 @@ void IMoveAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
loc = os.str();
}
action.setModifyInventoryStack(loc, from_list, from_i, false,
- src_item.getItemString());
+ src_item);
rollback->reportAction(action);
}
// If destination is not infinite, record item put
@@ -393,7 +393,7 @@ void IMoveAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
loc = os.str();
}
action.setModifyInventoryStack(loc, to_list, to_i, true,
- src_item.getItemString());
+ src_item);
rollback->reportAction(action);
}
}
@@ -632,7 +632,7 @@ void IDropAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
*/
if(!ignore_src_rollback && gamedef->rollback())
{
- IRollbackReportSink *rollback = gamedef->rollback();
+ IRollbackManager *rollback = gamedef->rollback();
// If source is not infinite, record item take
if(src_can_take_count != -1){
@@ -644,7 +644,7 @@ void IDropAction::apply(InventoryManager *mgr, ServerActiveObject *player, IGame
loc = os.str();
}
action.setModifyInventoryStack(loc, from_list, from_i,
- false, src_item.getItemString());
+ false, src_item);
rollback->reportAction(action);
}
}
diff --git a/src/map.h b/src/map.h
index 4df9a556294c05b1aeb879b0fed924402c1cb1ff..c650e51b65090c7defd7febfccf12ad491b6c0cd 100644
--- a/src/map.h
+++ b/src/map.h
@@ -41,7 +41,7 @@ class ServerMapSector;
class MapBlock;
class NodeMetadata;
class IGameDef;
-class IRollbackReportSink;
+class IRollbackManager;
class EmergeManager;
class ServerEnvironment;
struct BlockMakeData;
diff --git a/src/rollback.cpp b/src/rollback.cpp
index 0af7aa4f7b980c890dcda383d4b804ed9002e8f0..7267a50f6e4234ba425948e7817d8bedc560f41b 100644
--- a/src/rollback.cpp
+++ b/src/rollback.cpp
@@ -32,547 +32,457 @@ 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)
-static std::string dbp;
-static sqlite3* dbh = NULL;
-static sqlite3_stmt* dbs_insert = NULL;
-static sqlite3_stmt* dbs_replace = NULL;
-static sqlite3_stmt* dbs_select = NULL;
-static sqlite3_stmt* dbs_select_range = NULL;
-static sqlite3_stmt* dbs_select_withActor = NULL;
-static sqlite3_stmt* dbs_knownActor_select = NULL;
-static sqlite3_stmt* dbs_knownActor_insert = NULL;
-static sqlite3_stmt* dbs_knownNode_select = NULL;
-static sqlite3_stmt* dbs_knownNode_insert = NULL;
-
-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)
+
+
+class ItemStackRow : public ItemStack {
+public:
+ ItemStackRow & operator = (const ItemStack & other)
+ {
+ *static_cast<ItemStack *>(this) = other;
+ return *this;
+ }
+
+ int id;
};
+
struct ActionRow {
- int id;
- int actor;
- time_t 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;
+ 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;
};
-typedef std::vector<Entity> Entities;
-Entities KnownActors;
-Entities KnownNodes;
-void registerNewActor(int id, std::string name)
+RollbackManager::RollbackManager(const std::string & world_path,
+ IGameDef * gamedef_) :
+ gamedef(gamedef_),
+ current_actor_is_guess(false)
{
- 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);
+ initDatabase();
- //std::cout << "New actor registered: " << id << " | " << name << std::endl;
+ if (fs::PathExists(txt_filename) && (fs::PathExists(migrating_flag) ||
+ !fs::PathExists(database_path))) {
+ 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;
+RollbackManager::~RollbackManager()
+{
+ SQLOK(sqlite3_finalize(stmt_insert));
+ SQLOK(sqlite3_finalize(stmt_replace));
+ SQLOK(sqlite3_finalize(stmt_select));
+ SQLOK(sqlite3_finalize(stmt_select_range));
+ SQLOK(sqlite3_finalize(stmt_select_withActor));
+ SQLOK(sqlite3_finalize(stmt_knownActor_select));
+ SQLOK(sqlite3_finalize(stmt_knownActor_insert));
+ SQLOK(sqlite3_finalize(stmt_knownNode_select));
+ SQLOK(sqlite3_finalize(stmt_knownNode_insert));
+
+ SQLOK(sqlite3_close(db));
+}
- KnownNodes.push_back(newNode);
- //std::cout << "New node registered: " << id << " | " << name << std::endl;
+void RollbackManager::registerNewActor(const int id, const std::string &name)
+{
+ Entity actor = {id, name};
+ knownActors.push_back(actor);
}
-int getActorId(std::string name)
+
+void RollbackManager::registerNewNode(const int id, const std::string &name)
{
- Entities::const_iterator iter;
+ Entity node = {id, name};
+ knownNodes.push_back(node);
+}
- for (iter = KnownActors.begin(); iter != KnownActors.end(); ++iter)
+
+int RollbackManager::getActorId(const std::string &name)
+{
+ for (std::vector<Entity>::const_iterator 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;
+ 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)
+int RollbackManager::getNodeId(const std::string &name)
+{
+ for (std::vector<Entity>::const_iterator 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);
+ 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)
+const char * RollbackManager::getActorName(const int id)
+{
+ for (std::vector<Entity>::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)
+const char * RollbackManager::getNodeName(const int id)
+{
+ for (std::vector<Entity>::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` TIMESTAMP 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 `actionActor` ON `action`(`actor`);\n"
+ "CREATE INDEX IF NOT EXISTS `actionTimestamp` ON `action`(`timestamp`);\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);
+void 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 needsCreate = !fs::PathExists(database_path);
+ SQLOK(sqlite3_open_v2(database_path.c_str(), &db,
+ SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL));
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 ("
- " ?, ?, ?,"
- " ?, ?, ?, ?, ?, ?,"
- " ?, ?, ?,"
- " ?, ?, ?, ?,"
- " ?, ?, ?, ?,"
+ createTables();
+ }
+
+ 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, &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, &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, &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` - ?) <= ?"
- " AND ABS(`y` - ?) <= ?"
- " AND ABS(`z` - ?) <= ?"
- " ORDER BY `timestamp` DESC, `id` DESC"
- " LIMIT 0,?",
- -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` = ?"
+ -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, &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)))
+ -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<const char *>(sqlite3_column_text(dbs_knownActor_select, 1))
+ sqlite3_column_int(stmt_knownActor_select, 0),
+ reinterpret_cast<const char *>(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<const char *>(sqlite3_column_text(dbs_knownNode_select, 1))
+ sqlite3_column_int(stmt_knownNode_select, 0),
+ reinterpret_cast<const char *>(sqlite3_column_text(stmt_knownNode_select, 1))
);
-
- return;
+ }
+ SQLOK(sqlite3_reset(stmt_knownNode_select));
}
-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 [22], ii = 0;
bool nodeMeta = false;
- bind[ii++] = sqlite3_bind_int(dbs_do, 1, row.actor);
- bind[ii++] = sqlite3_bind_int64(dbs_do, 2, row.timestamp);
- bind[ii++] = sqlite3_bind_int(dbs_do, 3, row.type);
+ 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) {
- std::string loc = row.location;
- std::string locType = loc.substr(0, loc.find(":"));
- nodeMeta = (locType == "nodemeta");
+ const std::string & loc = row.location;
+ nodeMeta = (loc.substr(0, 9) == "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);
+ 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 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()));
+ 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);
+ 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);
+ 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) {
- bind[ii++] = sqlite3_bind_null(dbs_do, 10);
- bind[ii++] = sqlite3_bind_null(dbs_do, 11);
- bind[ii++] = sqlite3_bind_null(dbs_do, 12);
+ 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);
+ SQLOK(sqlite3_bind_int(stmt_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(stmt_do);
- int written = sqlite3_step(dbs_do);
+ SQLOK(sqlite3_reset(stmt_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> actionRowsFromSelect(sqlite3_stmt* stmt)
+
+
+const std::list<ActionRow> RollbackManager::actionRowsFromSelect(sqlite3_stmt* stmt)
{
std::list<ActionRow> 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.actor = sqlite3_column_int (stmt, 0);
row.timestamp = sqlite3_column_int64(stmt, 1);
- row.type = sqlite3_column_int(stmt, 2);
+ 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<const char*>(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);
+ text = sqlite3_column_text (stmt, 3);
+ size = sqlite3_column_bytes(stmt, 3);
+ row.list = std::string(reinterpret_cast<const char*>(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) {
@@ -582,74 +492,42 @@ std::list<ActionRow> actionRowsFromSelect(sqlite3_stmt* stmt)
}
if (row.type == RollbackAction::TYPE_SET_NODE) {
- row.oldNode = sqlite3_column_int(stmt, 12);
+ 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);
+ text = sqlite3_column_text (stmt, 15);
+ size = sqlite3_column_bytes(stmt, 15);
row.oldMeta = std::string(reinterpret_cast<const char*>(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);
+ text = sqlite3_column_text(stmt, 19);
+ size = sqlite3_column_bytes(stmt, 19);
row.newMeta = std::string(reinterpret_cast<const char*>(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));
+ 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);
}
- /*
- 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);
}
+ SQLOK(sqlite3_reset(stmt));
+
return rows;
}
-ActionRow actionRowFromRollbackAction(RollbackAction action)
+
+
+ActionRow RollbackManager::actionRowFromRollbackAction(const RollbackAction & action)
{
ActionRow row;
@@ -663,7 +541,8 @@ ActionRow actionRowFromRollbackAction(RollbackAction action)
row.list = action.inventory_list;
row.index = action.inventory_index;
row.add = action.inventory_add;
- row.stack = getStackFromString(action.inventory_stack);
+ row.stack = action.inventory_stack;
+ row.stack.id = getNodeId(row.stack.name);
} else {
row.x = action.p.X;
row.y = action.p.Y;
@@ -681,12 +560,15 @@ ActionRow actionRowFromRollbackAction(RollbackAction action)
return row;
}
-std::list<RollbackAction> rollbackActionsFromActionRows(std::list<ActionRow> rows)
+
+
+const std::list<RollbackAction> RollbackManager::rollbackActionsFromActionRows(
+ const std::list<ActionRow> & rows)
{
std::list<RollbackAction> actions;
- std::list<ActionRow>::const_iterator it;
- for (it = rows.begin(); it != rows.end(); ++it) {
+ for (std::list<ActionRow>::const_iterator it = rows.begin();
+ it != rows.end(); ++it) {
RollbackAction action;
action.actor = (it->actor) ? getActorName(it->actor) : "";
action.unix_time = it->timestamp;
@@ -694,16 +576,17 @@ std::list<RollbackAction> rollbackActionsFromActionRows(std::list<ActionRow> row
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);
+ action.inventory_stack = it->stack;
+ if (action.inventory_stack.name.empty()) {
+ action.inventory_stack.name = getNodeName(it->stack.id);
+ }
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;
@@ -716,7 +599,6 @@ std::list<RollbackAction> rollbackActionsFromActionRows(std::list<ActionRow> row
break;
default:
-
throw ("W.T.F.");
break;
}
@@ -727,202 +609,173 @@ std::list<RollbackAction> rollbackActionsFromActionRows(std::list<ActionRow> row
return actions;
}
-std::list<ActionRow> SQL_getRowsSince(time_t firstTime, std::string actor = "")
+
+const std::list<ActionRow> RollbackManager::getRowsSince(time_t firstTime, const std::string & actor)
{
- sqlite3_stmt *dbs_stmt = (!actor.length()) ? dbs_select : dbs_select_withActor;
- sqlite3_reset(dbs_stmt);
- sqlite3_bind_int64(dbs_stmt, 1, firstTime);
+ sqlite3_stmt *stmt_stmt = actor.empty() ? stmt_select : stmt_select_withActor;
+ sqlite3_bind_int64(stmt_stmt, 1, firstTime);
- if (actor.length()) {
- sqlite3_bind_int(dbs_stmt, 2, getActorId(actor));
+ if (!actor.empty()) {
+ sqlite3_bind_int(stmt_stmt, 2, getActorId(actor));
}
- return actionRowsFromSelect(dbs_stmt);
+ const std::list<ActionRow> & rows = actionRowsFromSelect(stmt_stmt);
+ sqlite3_reset(stmt_stmt);
+
+ return rows;
}
-std::list<ActionRow> SQL_getRowsSince_range(time_t firstTime, v3s16 p, int range,
- int limit)
+
+const std::list<ActionRow> RollbackManager::getRowsSince_range(
+ time_t start_time, v3s16 p, int range, int limit)
{
- sqlite3_stmt *stmt = dbs_select_range;
- sqlite3_reset(stmt);
-
- sqlite3_bind_int64(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);
- sqlite3_bind_int(stmt, 8, limit);
-
- return actionRowsFromSelect(stmt);
+
+ sqlite3_bind_int64(stmt_select_range, 1, start_time);
+ sqlite3_bind_int (stmt_select_range, 2, static_cast<int>(p.X - range));
+ sqlite3_bind_int (stmt_select_range, 3, static_cast<int>(p.X + range));
+ sqlite3_bind_int (stmt_select_range, 4, static_cast<int>(p.Y - range));
+ sqlite3_bind_int (stmt_select_range, 5, static_cast<int>(p.Y + range));
+ sqlite3_bind_int (stmt_select_range, 6, static_cast<int>(p.Z - range));
+ sqlite3_bind_int (stmt_select_range, 7, static_cast<int>(p.Z + range));
+ sqlite3_bind_int (stmt_select_range, 8, limit);
+
+ const std::list<ActionRow> & rows = actionRowsFromSelect(stmt_select_range);
+ sqlite3_reset(stmt_select_range);
+
+ return rows;
}
-std::list<RollbackAction> SQL_getActionsSince_range(time_t firstTime, v3s16 p, int range,
- int limit)
-{
- std::list<ActionRow> rows = SQL_getRowsSince_range(firstTime, p, range, limit);
- return rollbackActionsFromActionRows(rows);
+const std::list<RollbackAction> RollbackManager::getActionsSince_range(
+ time_t start_time, v3s16 p, int range, int limit)
+{
+ return rollbackActionsFromActionRows(getRowsSince_range(start_time, p, range, limit));
}
-std::list<RollbackAction> SQL_getActionsSince(time_t firstTime, std::string actor = "")
+
+const std::list<RollbackAction> RollbackManager::getActionsSince(
+ time_t start_time, const std::string & actor)
{
- std::list<ActionRow> rows = SQL_getRowsSince(firstTime, actor);
- return rollbackActionsFromActionRows(rows);
+ return rollbackActionsFromActionRows(getRowsSince(start_time, actor));
}
-void TXT_migrate(std::string filepath)
+
+void RollbackManager::migrate(const std::string & file_path)
{
- std::cout << "Migrating from rollback.txt to rollback.sqlite" << std::endl;
- SQL_databaseCheck();
+ std::cout << "Migrating from rollback.txt to rollback.sqlite." << std::endl;
- std::ifstream fh(filepath.c_str(), std::ios::in | std::ios::ate);
+ std::ifstream fh(file_path.c_str(), std::ios::in | std::ios::ate);
if (!fh.good()) {
- throw ("DIE");
+ throw FileNotGoodException("Unable to open rollback.txt");
}
- std::streampos filesize = fh.tellg();
-
- if (filesize > 10) {
- fh.seekg(0);
+ std::streampos file_size = fh.tellg();
- std::string bit;
- int i = 0;
- int id = 1;
- time_t 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)));
+ 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;
- }
+ std::string bit;
+ int i = 0;
+ int id = 1;
+ time_t start = time(0);
+ time_t t = start;
+ sqlite3_exec(db, "BEGIN", NULL, NULL, NULL);
+ do {
+ ActionRow row;
- if (bit == "set_node") {
- row.type = RollbackAction::TYPE_SET_NODE;
- }
+ row.id = id;
- 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");
- }
+ // 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());
- /*
- 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;
- }
- */
+ // Get the actor
+ row.actor = getActorId(deSerializeJsonString(fh));
- if (i == 0) {
- t = time(0);
- sqlite3_exec(dbh, "BEGIN", NULL, NULL, NULL);
- }
+ // Get the action type
+ std::getline(fh, bit, '[');
+ std::getline(fh, bit, ' ');
- SQL_registerRow(row);
- ++i;
+ 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;
+ }
- 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) << "%"
- << " Speed: " << i / t << "/second \r" << std::flush;
- i = 0;
- }
+ registerRow(row);
+ ++i;
- ++id;
- } while (!fh.eof() && fh.good());
- } else {
- errorstream << "Empty rollback log" << std::endl;
- }
+ if (time(0) - t >= 1) {
+ sqlite3_exec(db, "COMMIT", NULL, NULL, NULL);
+ t = time(0);
+ std::cout
+ << " Done: " << static_cast<int>((static_cast<float>(fh.tellg()) / static_cast<float>(file_size)) * 100) << "%"
+ << " Speed: " << i / (t - start) << "/second \r" << std::flush;
+ sqlite3_exec(db, "BEGIN", NULL, NULL, NULL);
+ }
+ } while (fh.good());
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, time_t suspect_t,
- v3s16 action_p, time_t 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) {
@@ -944,245 +797,154 @@ static float getSuspectNearness(bool is_guess, v3s16 suspect_p, time_t suspect_t
}
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);
- }
+ action.actor = getSuspect(p, 83, 1);
+ if (action.actor.empty()) {
+ return;
+ }
- std::string getActor() {
- return m_current_actor;
+ action.actor_is_guess = true;
}
- bool isActorGuess() {
- return m_current_actor_is_guess;
- }
+ addAction(action);
+}
- void setActor(const std::string &actor, bool is_guess) {
- m_current_actor = actor;
- m_current_actor_is_guess = is_guess;
- }
+std::string RollbackManager::getActor()
+{
+ return current_actor;
+}
+
+bool RollbackManager::isActorGuess()
+{
+ return current_actor_is_guess;
+}
- std::string getSuspect(v3s16 p, float nearness_shortcut, float min_nearness) {
- if (m_current_actor != "") {
- return m_current_actor;
+void RollbackManager::setActor(const std::string & actor, bool is_guess)
+{
+ current_actor = actor;
+ current_actor_is_guess = is_guess;
+}
+
+std::string RollbackManager::getSuspect(v3s16 p, float nearness_shortcut,
+ float min_nearness)
+{
+ if (current_actor != "") {
+ return current_actor;
+ }
+ 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<RollbackAction>::const_reverse_iterator
+ i = action_latest_buffer.rbegin();
+ i != action_latest_buffer.rend(); i++) {
+ if (i->unix_time < first_time) {
+ break;
}
- 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<RollbackAction>::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;
- }
- }
+ if (i->actor == "") {
+ continue;
}
- // No likely suspect was found
- if (likely_suspect_nearness == 0) {
- return "";
+ // Find position of suspect or continue
+ v3s16 suspect_p;
+ if (!i->getPosition(&suspect_p)) {
+ continue;
}
- // Likely suspect was found
- return likely_suspect.actor;
- }
-
- void flush() {
- infostream << "RollbackManager::flush()" << std::endl;
-
- sqlite3_exec(dbh, "BEGIN", NULL, NULL, NULL);
-
- std::list<RollbackAction>::const_iterator iter;
-
- for (iter = m_action_todisk_buffer.begin();
- iter != m_action_todisk_buffer.end();
- iter++) {
- if (iter->actor == "") {
- 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_registerRow(actionRowFromRollbackAction(*iter));
}
-
- sqlite3_exec(dbh, "COMMIT", NULL, NULL, NULL);
- m_action_todisk_buffer.clear();
}
-
- 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(filepath.rfind(DIR_DELIM) + 1);
- std::string filenameNew = (filenameOld == "rollback.txt") ? "rollback.sqlite" :
- filenameOld;
- std::string filenameTXT = directory + "rollback.txt";
- std::string migratingFlag = filepath + ".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);
- }
-
- SQL_databaseCheck();
+ // No likely suspect was found
+ if (likely_suspect_nearness == 0) {
+ return "";
}
-#define FINALIZE_STATEMENT(statement) \
- if ( statement ) \
- rc = sqlite3_finalize(statement); \
- statement = NULL; \
- if ( rc != SQLITE_OK ) \
- errorstream << "RollbackManager::~RollbackManager():" \
- << "Failed to finalize: " << #statement << ": rc=" << rc << std::endl;
-
- ~RollbackManager() {
- infostream << "RollbackManager::~RollbackManager()" << std::endl;
- flush();
-
- int rc = SQLITE_OK;
+ // Likely suspect was found
+ return likely_suspect.actor;
+}
- FINALIZE_STATEMENT(dbs_insert)
- FINALIZE_STATEMENT(dbs_replace)
- FINALIZE_STATEMENT(dbs_select)
- FINALIZE_STATEMENT(dbs_select_range)
- FINALIZE_STATEMENT(dbs_select_withActor)
- FINALIZE_STATEMENT(dbs_knownActor_select)
- FINALIZE_STATEMENT(dbs_knownActor_insert)
- FINALIZE_STATEMENT(dbs_knownNode_select)
- FINALIZE_STATEMENT(dbs_knownNode_insert)
- if(dbh)
- rc = sqlite3_close(dbh);
+void RollbackManager::flush()
+{
+ sqlite3_exec(db, "BEGIN", NULL, NULL, NULL);
- dbh = NULL;
+ std::list<RollbackAction>::const_iterator iter;
- if (rc != SQLITE_OK) {
- errorstream << "RollbackManager::~RollbackManager(): "
- << "Failed to close database: rc=" << rc << std::endl;
+ for (iter = action_todisk_buffer.begin();
+ iter != action_todisk_buffer.end();
+ iter++) {
+ if (iter->actor == "") {
+ continue;
}
- }
-
- void addAction(const RollbackAction &action) {
- m_action_todisk_buffer.push_back(action);
- m_action_latest_buffer.push_back(action);
- // Flush to disk sometimes
- if (m_action_todisk_buffer.size() >= 500) {
- flush();
- }
+ registerRow(actionRowFromRollbackAction(*iter));
}
- std::list<RollbackAction> getEntriesSince(time_t first_time) {
- infostream
- << "RollbackManager::getEntriesSince(" << first_time << ")"
- << std::endl;
-
- flush();
+ sqlite3_exec(db, "COMMIT", NULL, NULL, NULL);
+ action_todisk_buffer.clear();
+}
- std::list<RollbackAction> result = SQL_getActionsSince(first_time);
- return result;
- }
-
- std::list<RollbackAction> getNodeActors(v3s16 pos, int range, time_t seconds, int limit) {
- time_t cur_time = time(0);
- time_t first_time = cur_time - seconds;
+void RollbackManager::addAction(const RollbackAction & action)
+{
+ action_todisk_buffer.push_back(action);
+ action_latest_buffer.push_back(action);
- return SQL_getActionsSince_range(first_time, pos, range, limit);
+ // Flush to disk sometimes
+ if (action_todisk_buffer.size() >= 500) {
+ flush();
}
+}
- std::list<RollbackAction> getRevertActions(const std::string &actor_filter,
- time_t seconds) {
- infostream
- << "RollbackManager::getRevertActions(" << actor_filter
- << ", " << seconds << ")"
- << std::endl;
+std::list<RollbackAction> RollbackManager::getEntriesSince(time_t first_time)
+{
+ flush();
+ return getActionsSince(first_time);
+}
- // Figure out time
- time_t cur_time = time(0);
- time_t first_time = cur_time - seconds;
+std::list<RollbackAction> RollbackManager::getNodeActors(v3s16 pos, int range,
+ time_t seconds, int limit)
+{
+ time_t cur_time = time(0);
+ time_t first_time = cur_time - seconds;
- flush();
+ return getActionsSince_range(first_time, pos, range, limit);
+}
- std::list<RollbackAction> result = SQL_getActionsSince(first_time, actor_filter);
+std::list<RollbackAction> RollbackManager::getRevertActions(
+ const std::string &actor_filter,
+ time_t seconds)
+{
+ time_t cur_time = time(0);
+ time_t first_time = cur_time - seconds;
- return result;
- }
-private:
- std::string m_filepath;
- IGameDef *m_gamedef;
- std::string m_current_actor;
- bool m_current_actor_is_guess;
- std::list<RollbackAction> m_action_todisk_buffer;
- std::list<RollbackAction> m_action_latest_buffer;
-};
+ flush();
-IRollbackManager *createRollbackManager(const std::string &filepath, IGameDef *gamedef)
-{
- return new RollbackManager(filepath, gamedef);
+ return getActionsSince(first_time, actor_filter);
}
diff --git a/src/rollback.h b/src/rollback.h
index eea7c59f2ec5287ef2df3037f621ebb14bad44d6..2e6955c8d40bc1fd049b558ede0feb3f653a52d0 100644
--- a/src/rollback.h
+++ b/src/rollback.h
@@ -24,31 +24,84 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "irr_v3d.h"
#include "rollback_interface.h"
#include <list>
+#include <vector>
+#include "sqlite3.h"
class IGameDef;
-class IRollbackManager: public IRollbackReportSink
+class ActionRow;
+class Entity;
+
+class RollbackManager: public IRollbackManager
{
public:
- // IRollbackReportManager
- virtual void reportAction(const RollbackAction &action) = 0;
- virtual std::string getActor() = 0;
- virtual bool isActorGuess() = 0;
- virtual void setActor(const std::string &actor, bool is_guess) = 0;
- virtual std::string getSuspect(v3s16 p, float nearness_shortcut,
- float min_nearness) = 0;
-
- virtual ~IRollbackManager() {}
- virtual void flush() = 0;
- // Get all actors that did something to position p, but not further than
- // <seconds> in history
- virtual std::list<RollbackAction> getNodeActors(v3s16 pos, int range,
- time_t seconds, int limit) = 0;
- // Get actions to revert <seconds> of history made by <actor>
- virtual std::list<RollbackAction> getRevertActions(const std::string &actor,
- time_t seconds) = 0;
-};
+ RollbackManager(const std::string & world_path, IGameDef * gamedef);
+ ~RollbackManager();
+
+ void reportAction(const RollbackAction & action_);
+ std::string getActor();
+ bool isActorGuess();
+ void setActor(const std::string & actor, bool is_guess);
+ std::string getSuspect(v3s16 p, float nearness_shortcut,
+ float min_nearness);
+ void flush();
+
+ void addAction(const RollbackAction & action);
+ std::list<RollbackAction> getEntriesSince(time_t first_time);
+ std::list<RollbackAction> getNodeActors(v3s16 pos, int range,
+ time_t seconds, int limit);
+ std::list<RollbackAction> getRevertActions(
+ const std::string & actor_filter, time_t seconds);
+
+private:
+ void registerNewActor(const int id, const std::string & name);
+ void registerNewNode(const int id, const std::string & name);
+ int getActorId(const std::string & name);
+ int getNodeId(const std::string & name);
+ const char * getActorName(const int id);
+ const char * getNodeName(const int id);
+ bool createTables();
+ void initDatabase();
+ bool registerRow(const ActionRow & row);
+ const std::list<ActionRow> actionRowsFromSelect(sqlite3_stmt * stmt);
+ ActionRow actionRowFromRollbackAction(const RollbackAction & action);
+ const std::list<RollbackAction> rollbackActionsFromActionRows(
+ const std::list<ActionRow> & rows);
+ const std::list<ActionRow> getRowsSince(time_t firstTime,
+ const std::string & actor);
+ const std::list<ActionRow> getRowsSince_range(time_t firstTime, v3s16 p,
+ int range, int limit);
+ const std::list<RollbackAction> getActionsSince_range(time_t firstTime, v3s16 p,
+ int range, int limit);
+ const std::list<RollbackAction> getActionsSince(time_t firstTime,
+ const std::string & actor = "");
+ void migrate(const std::string & filepath);
+ static float getSuspectNearness(bool is_guess, v3s16 suspect_p,
+ time_t suspect_t, v3s16 action_p, time_t action_t);
+
-IRollbackManager *createRollbackManager(const std::string &filepath, IGameDef *gamedef);
+ IGameDef * gamedef;
+
+ std::string current_actor;
+ bool current_actor_is_guess;
+
+ std::list<RollbackAction> action_todisk_buffer;
+ std::list<RollbackAction> action_latest_buffer;
+
+ std::string database_path;
+ sqlite3 * db;
+ sqlite3_stmt * stmt_insert;
+ sqlite3_stmt * stmt_replace;
+ sqlite3_stmt * stmt_select;
+ sqlite3_stmt * stmt_select_range;
+ sqlite3_stmt * stmt_select_withActor;
+ sqlite3_stmt * stmt_knownActor_select;
+ sqlite3_stmt * stmt_knownActor_insert;
+ sqlite3_stmt * stmt_knownNode_select;
+ sqlite3_stmt * stmt_knownNode_insert;
+
+ std::vector<Entity> knownActors;
+ std::vector<Entity> knownNodes;
+};
#endif
diff --git a/src/rollback_interface.cpp b/src/rollback_interface.cpp
index 808b07fed9545a7b5032d54e6898a6ca29e2a6df..c35ad57811b0687b914098104010b385ad493ee4 100644
--- a/src/rollback_interface.cpp
+++ b/src/rollback_interface.cpp
@@ -34,6 +34,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
+
RollbackNode::RollbackNode(Map *map, v3s16 p, IGameDef *gamedef)
{
INodeDefManager *ndef = gamedef->ndef();
@@ -42,275 +43,89 @@ RollbackNode::RollbackNode(Map *map, v3s16 p, IGameDef *gamedef)
param1 = n.param1;
param2 = n.param2;
NodeMetadata *metap = map->getNodeMetadata(p);
- if(metap){
+ if (metap) {
std::ostringstream os(std::ios::binary);
metap->serialize(os);
meta = os.str();
}
}
+
std::string RollbackAction::toString() const
{
- switch(type){
- case TYPE_SET_NODE: {
- std::ostringstream os(std::ios::binary);
- os<<"[set_node";
- os<<" ";
- os<<"("<<itos(p.X)<<","<<itos(p.Y)<<","<<itos(p.Z)<<")";
- os<<" ";
- os<<serializeJsonString(n_old.name);
- os<<" ";
- os<<itos(n_old.param1);
- os<<" ";
- os<<itos(n_old.param2);
- os<<" ";
- os<<serializeJsonString(n_old.meta);
- os<<" ";
- os<<serializeJsonString(n_new.name);
- os<<" ";
- os<<itos(n_new.param1);
- os<<" ";
- os<<itos(n_new.param2);
- os<<" ";
- os<<serializeJsonString(n_new.meta);
- os<<"]";
- return os.str(); }
- case TYPE_MODIFY_INVENTORY_STACK: {
- std::ostringstream os(std::ios::binary);
- os<<"[modify_inventory_stack";
- os<<" ";
- os<<serializeJsonString(inventory_location);
- os<<" ";
- os<<serializeJsonString(inventory_list);
- os<<" ";
- os<<inventory_index;
- os<<" ";
- os<<(inventory_add?"add":"remove");
- os<<" ";
- os<<serializeJsonString(inventory_stack);
- os<<"]";
- return os.str(); }
+ std::ostringstream os(std::ios::binary);
+ switch (type) {
+ case TYPE_SET_NODE:
+ os << "set_node " << PP(p);
+ os << ": (" << serializeJsonString(n_old.name);
+ os << ", " << itos(n_old.param1);
+ os << ", " << itos(n_old.param2);
+ os << ", " << serializeJsonString(n_old.meta);
+ os << ") -> (" << serializeJsonString(n_new.name);
+ os << ", " << itos(n_new.param1);
+ os << ", " << itos(n_new.param2);
+ os << ", " << serializeJsonString(n_new.meta);
+ os << ')';
+ case TYPE_MODIFY_INVENTORY_STACK:
+ os << "modify_inventory_stack (";
+ os << serializeJsonString(inventory_location);
+ os << ", " << serializeJsonString(inventory_list);
+ os << ", " << inventory_index;
+ os << ", " << (inventory_add ? "add" : "remove");
+ os << ", " << serializeJsonString(inventory_stack.getItemString());
+ os << ')';
default:
- return "none";
+ return "<unknown action>";
}
+ return os.str();
}
-void RollbackAction::fromStream(std::istream &is) throw(SerializationError)
-{
- int c = is.get();
- if(c != '['){
- is.putback(c);
- throw SerializationError("RollbackAction: starting [ not found");
- }
-
- std::string id;
- std::getline(is, id, ' ');
-
- if(id == "set_node")
- {
- c = is.get();
- if(c != '('){
- is.putback(c);
- throw SerializationError("RollbackAction: starting ( not found");
- }
- // Position
- std::string px_raw;
- std::string py_raw;
- std::string pz_raw;
- std::getline(is, px_raw, ',');
- std::getline(is, py_raw, ',');
- std::getline(is, pz_raw, ')');
- c = is.get();
- if(c != ' '){
- is.putback(c);
- throw SerializationError("RollbackAction: after-p ' ' not found");
- }
- v3s16 loaded_p(stoi(px_raw), stoi(py_raw), stoi(pz_raw));
- // Old node
- std::string old_name;
- try{
- old_name = deSerializeJsonString(is);
- }catch(SerializationError &e){
- errorstream<<"Serialization error in RollbackAction::fromStream(): "
- <<"old_name: "<<e.what()<<std::endl;
- throw e;
- }
- c = is.get();
- if(c != ' '){
- is.putback(c);
- throw SerializationError("RollbackAction: after-old_name ' ' not found");
- }
- std::string old_p1_raw;
- std::string old_p2_raw;
- std::getline(is, old_p1_raw, ' ');
- std::getline(is, old_p2_raw, ' ');
- int old_p1 = stoi(old_p1_raw);
- int old_p2 = stoi(old_p2_raw);
- std::string old_meta;
- try{
- old_meta = deSerializeJsonString(is);
- }catch(SerializationError &e){
- errorstream<<"Serialization error in RollbackAction::fromStream(): "
- <<"old_meta: "<<e.what()<<std::endl;
- throw e;
- }
- c = is.get();
- if(c != ' '){
- is.putback(c);
- throw SerializationError("RollbackAction: after-old_meta ' ' not found");
- }
- // New node
- std::string new_name;
- try{
- new_name = deSerializeJsonString(is);
- }catch(SerializationError &e){
- errorstream<<"Serialization error in RollbackAction::fromStream(): "
- <<"new_name: "<<e.what()<<std::endl;
- throw e;
- }
- c = is.get();
- if(c != ' '){
- is.putback(c);
- throw SerializationError("RollbackAction: after-new_name ' ' not found");
- }
- std::string new_p1_raw;
- std::string new_p2_raw;
- std::getline(is, new_p1_raw, ' ');
- std::getline(is, new_p2_raw, ' ');
- int new_p1 = stoi(new_p1_raw);
- int new_p2 = stoi(new_p2_raw);
- std::string new_meta;
- try{
- new_meta = deSerializeJsonString(is);
- }catch(SerializationError &e){
- errorstream<<"Serialization error in RollbackAction::fromStream(): "
- <<"new_meta: "<<e.what()<<std::endl;
- throw e;
- }
- c = is.get();
- if(c != ']'){
- is.putback(c);
- throw SerializationError("RollbackAction: after-new_meta ] not found");
- }
- // Set values
- type = TYPE_SET_NODE;
- p = loaded_p;
- n_old.name = old_name;
- n_old.param1 = old_p1;
- n_old.param2 = old_p2;
- n_old.meta = old_meta;
- n_new.name = new_name;
- n_new.param1 = new_p1;
- n_new.param2 = new_p2;
- n_new.meta = new_meta;
- }
- else if(id == "modify_inventory_stack")
- {
- // Location
- std::string location;
- try{
- location = deSerializeJsonString(is);
- }catch(SerializationError &e){
- errorstream<<"Serialization error in RollbackAction::fromStream(): "
- <<"location: "<<e.what()<<std::endl;
- throw e;
- }
- c = is.get();
- if(c != ' '){
- is.putback(c);
- throw SerializationError("RollbackAction: after-loc ' ' not found");
- }
- // List
- std::string listname;
- try{
- listname = deSerializeJsonString(is);
- }catch(SerializationError &e){
- errorstream<<"Serialization error in RollbackAction::fromStream(): "
- <<"listname: "<<e.what()<<std::endl;
- throw e;
- }
- c = is.get();
- if(c != ' '){
- is.putback(c);
- throw SerializationError("RollbackAction: after-list ' ' not found");
- }
- // Index
- std::string index_raw;
- std::getline(is, index_raw, ' ');
- // add/remove
- std::string addremove;
- std::getline(is, addremove, ' ');
- if(addremove != "add" && addremove != "remove"){
- throw SerializationError("RollbackAction: addremove is not add or remove");
- }
- // Itemstring
- std::string stack;
- try{
- stack = deSerializeJsonString(is);
- }catch(SerializationError &e){
- errorstream<<"Serialization error in RollbackAction::fromStream(): "
- <<"stack: "<<e.what()<<std::endl;
- throw e;
- }
- // Set values
- type = TYPE_MODIFY_INVENTORY_STACK;
- inventory_location = location;
- inventory_list = listname;
- inventory_index = stoi(index_raw);
- inventory_add = (addremove == "add");
- inventory_stack = stack;
- }
- else
- {
- throw SerializationError("RollbackAction: Unknown id");
- }
-}
bool RollbackAction::isImportant(IGameDef *gamedef) const
{
- switch(type){
- case TYPE_SET_NODE: {
- // If names differ, action is always important
- if(n_old.name != n_new.name)
- return true;
- // If metadata differs, action is always important
- if(n_old.meta != n_new.meta)
- return true;
- INodeDefManager *ndef = gamedef->ndef();
- // Both are of the same name, so a single definition is needed
- const ContentFeatures &def = ndef->get(n_old.name);
- // If the type is flowing liquid, action is not important
- if(def.liquid_type == LIQUID_FLOWING)
- return false;
- // Otherwise action is important
- return true; }
- default:
+ if (type != TYPE_SET_NODE)
return true;
- }
+ // If names differ, action is always important
+ if(n_old.name != n_new.name)
+ return true;
+ // If metadata differs, action is always important
+ if(n_old.meta != n_new.meta)
+ return true;
+ INodeDefManager *ndef = gamedef->ndef();
+ // Both are of the same name, so a single definition is needed
+ const ContentFeatures &def = ndef->get(n_old.name);
+ // If the type is flowing liquid, action is not important
+ if (def.liquid_type == LIQUID_FLOWING)
+ return false;
+ // Otherwise action is important
+ return true;
}
+
bool RollbackAction::getPosition(v3s16 *dst) const
{
- switch(type){
- case RollbackAction::TYPE_SET_NODE:
- if(dst) *dst = p;
+ switch (type) {
+ case TYPE_SET_NODE:
+ if (dst) *dst = p;
return true;
- case RollbackAction::TYPE_MODIFY_INVENTORY_STACK: {
+ case TYPE_MODIFY_INVENTORY_STACK: {
InventoryLocation loc;
loc.deSerialize(inventory_location);
- if(loc.type != InventoryLocation::NODEMETA)
+ if (loc.type != InventoryLocation::NODEMETA) {
return false;
- if(dst) *dst = loc.p;
+ }
+ if (dst) *dst = loc.p;
return true; }
default:
return false;
}
}
+
bool RollbackAction::applyRevert(Map *map, InventoryManager *imgr, IGameDef *gamedef) const
{
- try{
- switch(type){
+ try {
+ switch (type) {
case TYPE_NOTHING:
return true;
case TYPE_SET_NODE: {
@@ -321,40 +136,39 @@ bool RollbackAction::applyRevert(Map *map, InventoryManager *imgr, IGameDef *gam
MapNode current_node = map->getNodeNoEx(p);
std::string current_name = ndef->get(current_node).name;
// If current node not the new node, it's bad
- if(current_name != n_new.name)
+ if (current_name != n_new.name) {
return false;
- /*// If current node not the new node and not ignore, it's bad
- if(current_name != n_new.name && current_name != "ignore")
- return false;*/
+ }
// Create rollback node
MapNode n(ndef, n_old.name, n_old.param1, n_old.param2);
// Set rollback node
- try{
- if(!map->addNodeWithEvent(p, n)){
- infostream<<"RollbackAction::applyRevert(): "
- <<"AddNodeWithEvent failed at "
- <<PP(p)<<" for "<<n_old.name<<std::endl;
+ try {
+ if (!map->addNodeWithEvent(p, n)) {
+ infostream << "RollbackAction::applyRevert(): "
+ << "AddNodeWithEvent failed at "
+ << PP(p) << " for " << n_old.name
+ << std::endl;
return false;
}
- NodeMetadata *meta = map->getNodeMetadata(p);
- if(n_old.meta != ""){
- if(!meta){
+ if (n_old.meta.empty()) {
+ map->removeNodeMetadata(p);
+ } else {
+ NodeMetadata *meta = map->getNodeMetadata(p);
+ if (!meta) {
meta = new NodeMetadata(gamedef);
- if(!map->setNodeMetadata(p, meta)){
+ if (!map->setNodeMetadata(p, meta)) {
delete meta;
- infostream<<"RollbackAction::applyRevert(): "
- <<"setNodeMetadata failed at "
- <<PP(p)<<" for "<<n_old.name<<std::endl;
+ infostream << "RollbackAction::applyRevert(): "
+ << "setNodeMetadata failed at "
+ << PP(p) << " for " << n_old.name
+ << std::endl;
return false;
}
}
std::istringstream is(n_old.meta, std::ios::binary);
meta->deSerialize(is);
- } else {
- map->removeNodeMetadata(p);
}
- // NOTE: This same code is in scriptapi.cpp
- // Inform other things that the metadata has changed
+ // Inform other things that the meta data has changed
v3s16 blockpos = getContainerPos(p, MAP_BLOCKSIZE);
MapEditEvent event;
event.type = MEET_BLOCK_NODE_METADATA_CHANGED;
@@ -362,12 +176,14 @@ bool RollbackAction::applyRevert(Map *map, InventoryManager *imgr, IGameDef *gam
map->dispatchEvent(&event);
// Set the block to be saved
MapBlock *block = map->getBlockNoCreateNoEx(blockpos);
- if(block)
+ if (block) {
block->raiseModified(MOD_STATE_WRITE_NEEDED,
- "NodeMetaRef::reportMetadataChange");
- }catch(InvalidPositionException &e){
- infostream<<"RollbackAction::applyRevert(): "
- <<"InvalidPositionException: "<<e.what()<<std::endl;
+ "NodeMetaRef::reportMetadataChange");
+ }
+ } catch (InvalidPositionException &e) {
+ infostream << "RollbackAction::applyRevert(): "
+ << "InvalidPositionException: " << e.what()
+ << std::endl;
return false;
}
// Success
@@ -375,47 +191,46 @@ bool RollbackAction::applyRevert(Map *map, InventoryManager *imgr, IGameDef *gam
case TYPE_MODIFY_INVENTORY_STACK: {
InventoryLocation loc;
loc.deSerialize(inventory_location);
- ItemStack stack;
- stack.deSerialize(inventory_stack, gamedef->idef());
+ std::string real_name = gamedef->idef()->getAlias(inventory_stack.name);
Inventory *inv = imgr->getInventory(loc);
- if(!inv){
- infostream<<"RollbackAction::applyRevert(): Could not get "
- "inventory at "<<inventory_location<<std::endl;
+ if (!inv) {
+ infostream << "RollbackAction::applyRevert(): Could not get "
+ "inventory at " << inventory_location << std::endl;
return false;
}
InventoryList *list = inv->getList(inventory_list);
- if(!list){
- infostream<<"RollbackAction::applyRevert(): Could not get "
- "inventory list \""<<inventory_list<<"\" in "
- <<inventory_location<<std::endl;
+ if (!list) {
+ infostream << "RollbackAction::applyRevert(): Could not get "
+ "inventory list \"" << inventory_list << "\" in "
+ << inventory_location << std::endl;
return false;
}
- if(list->getSize() <= inventory_index){
- infostream<<"RollbackAction::applyRevert(): List index "
- <<inventory_index<<" too large in "
- <<"inventory list \""<<inventory_list<<"\" in "
- <<inventory_location<<std::endl;
+ if (list->getSize() <= inventory_index) {
+ infostream << "RollbackAction::applyRevert(): List index "
+ << inventory_index << " too large in "
+ << "inventory list \"" << inventory_list << "\" in "
+ << inventory_location << std::endl;
}
// If item was added, take away item, otherwise add removed item
- if(inventory_add){
+ if (inventory_add) {
// Silently ignore different current item
- if(list->getItem(inventory_index).name != stack.name)
+ if (list->getItem(inventory_index).name != real_name)
return false;
- list->takeItem(inventory_index, stack.count);
+ list->takeItem(inventory_index, inventory_stack.count);
} else {
- list->addItem(inventory_index, stack);
+ list->addItem(inventory_index, inventory_stack);
}
// Inventory was modified; send to clients
imgr->setInventoryModified(loc);
return true; }
default:
- errorstream<<"RollbackAction::applyRevert(): type not handled"
- <<std::endl;
+ errorstream << "RollbackAction::applyRevert(): type not handled"
+ << std::endl;
return false;
}
- }catch(SerializationError &e){
- errorstream<<"RollbackAction::applyRevert(): n_old.name="<<n_old.name
- <<", SerializationError: "<<e.what()<<std::endl;
+ } catch(SerializationError &e) {
+ errorstream << "RollbackAction::applyRevert(): n_old.name=" << n_old.name
+ << ", SerializationError: " << e.what() << std::endl;
}
return false;
}
diff --git a/src/rollback_interface.h b/src/rollback_interface.h
index f16f82b4028f910cf76e82eaf0d6ed80ccf961b8..92fab9b9cd02da79a4a3dca67f24eed3af48d071 100644
--- a/src/rollback_interface.h
+++ b/src/rollback_interface.h
@@ -23,7 +23,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "irr_v3d.h"
#include <string>
#include <iostream>
+#include <list>
#include "exceptions.h"
+#include "inventory.h"
class Map;
class IGameDef;
@@ -37,15 +39,12 @@ struct RollbackNode
int param2;
std::string meta;
- bool operator==(const RollbackNode &other)
+ bool operator == (const RollbackNode &other)
{
return (name == other.name && param1 == other.param1 &&
param2 == other.param2 && meta == other.meta);
}
- bool operator!=(const RollbackNode &other)
- {
- return !(*this == other);
- }
+ bool operator != (const RollbackNode &other) { return !(*this == other); }
RollbackNode():
param1(0),
@@ -55,6 +54,7 @@ struct RollbackNode
RollbackNode(Map *map, v3s16 p, IGameDef *gamedef);
};
+
struct RollbackAction
{
enum Type{
@@ -75,7 +75,7 @@ struct RollbackAction
std::string inventory_list;
u32 inventory_index;
bool inventory_add;
- std::string inventory_stack;
+ ItemStack inventory_stack;
RollbackAction():
type(TYPE_NOTHING),
@@ -94,7 +94,7 @@ struct RollbackAction
void setModifyInventoryStack(const std::string &inventory_location_,
const std::string &inventory_list_, int index_,
- bool add_, const std::string &inventory_stack_)
+ bool add_, const ItemStack &inventory_stack_)
{
type = TYPE_MODIFY_INVENTORY_STACK;
inventory_location = inventory_location_;
@@ -106,7 +106,6 @@ struct RollbackAction
// String should not contain newlines or nulls
std::string toString() const;
- void fromStream(std::istream &is) throw(SerializationError);
// Eg. flowing water level changes are not important
bool isImportant(IGameDef *gamedef) const;
@@ -116,41 +115,53 @@ struct RollbackAction
bool applyRevert(Map *map, InventoryManager *imgr, IGameDef *gamedef) const;
};
-class IRollbackReportSink
+
+class IRollbackManager
{
public:
- virtual ~IRollbackReportSink(){}
virtual void reportAction(const RollbackAction &action) = 0;
virtual std::string getActor() = 0;
virtual bool isActorGuess() = 0;
virtual void setActor(const std::string &actor, bool is_guess) = 0;
virtual std::string getSuspect(v3s16 p, float nearness_shortcut,
- float min_nearness) = 0;
+ float min_nearness) = 0;
+
+ virtual ~IRollbackManager() {};
+ virtual void flush() = 0;
+ // Get all actors that did something to position p, but not further than
+ // <seconds> in history
+ virtual std::list<RollbackAction> getNodeActors(v3s16 pos, int range,
+ time_t seconds, int limit) = 0;
+ // Get actions to revert <seconds> of history made by <actor>
+ virtual std::list<RollbackAction> getRevertActions(const std::string &actor,
+ time_t seconds) = 0;
};
+
class RollbackScopeActor
{
public:
- RollbackScopeActor(IRollbackReportSink *sink, const std::string &actor,
- bool is_guess=false):
- m_sink(sink)
+ RollbackScopeActor(IRollbackManager * rollback_,
+ const std::string & actor, bool is_guess = false) :
+ rollback(rollback_)
{
- if(m_sink){
- m_actor_was = m_sink->getActor();
- m_actor_was_guess = m_sink->isActorGuess();
- m_sink->setActor(actor, is_guess);
+ if (rollback) {
+ old_actor = rollback->getActor();
+ old_actor_guess = rollback->isActorGuess();
+ rollback->setActor(actor, is_guess);
}
}
~RollbackScopeActor()
{
- if(m_sink){
- m_sink->setActor(m_actor_was, m_actor_was_guess);
+ if (rollback) {
+ rollback->setActor(old_actor, old_actor_guess);
}
}
+
private:
- IRollbackReportSink *m_sink;
- std::string m_actor_was;
- bool m_actor_was_guess;
+ IRollbackManager * rollback;
+ std::string old_actor;
+ bool old_actor_guess;
};
#endif
diff --git a/src/script/lua_api/l_rollback.cpp b/src/script/lua_api/l_rollback.cpp
index b3685c8d1d2c6d7b2324666c081fff593838b272..f55a72d1b77bd00aa55edbede55d46724b65e36f 100644
--- a/src/script/lua_api/l_rollback.cpp
+++ b/src/script/lua_api/l_rollback.cpp
@@ -21,7 +21,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "lua_api/l_internal.h"
#include "common/c_converter.h"
#include "server.h"
-#include "rollback.h"
+#include "rollback_interface.h"
void push_RollbackNode(lua_State *L, RollbackNode &node)
diff --git a/src/server.cpp b/src/server.cpp
index d1f3997e92d794eafe029da271e6c3cc060503dd..857114d0f0fc12461fd5a9c4840aa1c141d813d6 100644
--- a/src/server.cpp
+++ b/src/server.cpp
@@ -181,7 +181,6 @@ Server::Server(
this),
m_banmanager(NULL),
m_rollback(NULL),
- m_rollback_sink_enabled(true),
m_enable_rollback_recording(false),
m_emerge(NULL),
m_script(NULL),
@@ -241,12 +240,11 @@ Server::Server(
throw ServerError("Failed to initialize world");
// Create ban manager
- std::string ban_path = m_path_world+DIR_DELIM+"ipban.txt";
+ std::string ban_path = m_path_world + DIR_DELIM "ipban.txt";
m_banmanager = new BanManager(ban_path);
// Create rollback manager
- std::string rollback_path = m_path_world+DIR_DELIM+"rollback.txt";
- m_rollback = createRollbackManager(rollback_path, this);
+ m_rollback = new RollbackManager(m_path_world, this);
ModConfiguration modconf(m_path_world);
m_mods = modconf.getMods();
@@ -4834,8 +4832,6 @@ bool Server::rollbackRevertActions(const std::list<RollbackAction> &actions,
{
infostream<<"Server::rollbackRevertActions(len="<<actions.size()<<")"<<std::endl;
ServerMap *map = (ServerMap*)(&m_env->getMap());
- // Disable rollback report sink while reverting
- BoolScopeSet rollback_scope_disable(&m_rollback_sink_enabled, false);
// Fail if no actions to handle
if(actions.empty()){
@@ -4915,14 +4911,6 @@ MtEventManager* Server::getEventManager()
{
return m_event;
}
-IRollbackReportSink* Server::getRollbackReportSink()
-{
- if(!m_enable_rollback_recording)
- return NULL;
- if(!m_rollback_sink_enabled)
- return NULL;
- return m_rollback;
-}
IWritableItemDefManager* Server::getWritableItemDefManager()
{
diff --git a/src/server.h b/src/server.h
index 7233ffbe84894041e01cde081301253192795a56..4292892c507b149c4e32c041c70ee8ea696207df 100644
--- a/src/server.h
+++ b/src/server.h
@@ -29,7 +29,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "mods.h"
#include "inventorymanager.h"
#include "subgame.h"
-#include "rollback_interface.h" // Needed for rollbackRevertActions()
#include "util/numeric.h"
#include "util/thread.h"
#include "environment.h"
@@ -50,6 +49,7 @@ class Inventory;
class Player;
class PlayerSAO;
class IRollbackManager;
+class RollbackAction;
class EmergeManager;
class GameScripting;
class ServerEnvironment;
@@ -268,9 +268,6 @@ class Server : public con::PeerHandler, public MapEventReceiver,
// Envlock and conlock should be locked when using scriptapi
GameScripting *getScriptIface(){ return m_script; }
- // Envlock should be locked when using the rollback manager
- IRollbackManager *getRollbackManager(){ return m_rollback; }
-
//TODO: determine what (if anything) should be locked to access EmergeManager
EmergeManager *getEmergeManager(){ return m_emerge; }
@@ -289,9 +286,10 @@ class Server : public con::PeerHandler, public MapEventReceiver,
virtual u16 allocateUnknownNodeId(const std::string &name);
virtual ISoundManager* getSoundManager();
virtual MtEventManager* getEventManager();
- virtual IRollbackReportSink* getRollbackReportSink();
virtual scene::ISceneManager* getSceneManager();
-
+ virtual IRollbackManager *getRollbackManager() { return m_rollback; }
+
+
IWritableItemDefManager* getWritableItemDefManager();
IWritableNodeDefManager* getWritableNodeDefManager();
IWritableCraftDefManager* getWritableCraftDefManager();
@@ -488,7 +486,6 @@ class Server : public con::PeerHandler, public MapEventReceiver,
// Rollback manager (behind m_env_mutex)
IRollbackManager *m_rollback;
- bool m_rollback_sink_enabled;
bool m_enable_rollback_recording; // Updated once in a while
// Emerge manager