void Database_Dummy::beginSave() {}
void Database_Dummy::endSave() {}
-bool Database_Dummy::saveBlock(MapBlock *block)
+bool Database_Dummy::saveBlock(v3s16 blockpos, std::string &data)
{
- DSTACK(__FUNCTION_NAME);
- /*
- Dummy blocks are not written
- */
- if(block->isDummy())
- {
- v3s16 p = block->getPos();
- infostream<<"Database_Dummy::saveBlock(): WARNING: Not writing dummy block "
- <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;
- return true;
- }
-
- // Format used for writing
- u8 version = SER_FMT_VER_HIGHEST_WRITE;
- // Get destination
- v3s16 p3d = block->getPos();
-
- /*
- [0] u8 serialization version
- [1] data
- */
-
- std::ostringstream o(std::ios_base::binary);
- o.write((char*)&version, 1);
- // Write basic data
- block->serialize(o, version, true);
- // Write block to database
- std::string tmp = o.str();
-
- m_database[getBlockAsInteger(p3d)] = tmp;
- // We just wrote it to the disk so clear modified flag
- block->resetModified();
+ m_database[getBlockAsInteger(blockpos)] = data;
return true;
}
-MapBlock* Database_Dummy::loadBlock(v3s16 blockpos)
+std::string Database_Dummy::loadBlock(v3s16 blockpos)
{
- v2s16 p2d(blockpos.X, blockpos.Z);
-
- if(m_database.count(getBlockAsInteger(blockpos))) {
- /*
- Make sure sector is loaded
- */
- MapSector *sector = srvmap->createSector(p2d);
- /*
- Load block
- */
- std::string datastr = m_database[getBlockAsInteger(blockpos)];
-// srvmap->loadBlock(&datastr, blockpos, sector, false);
-
- try {
- std::istringstream is(datastr, std::ios_base::binary);
- u8 version = SER_FMT_VER_INVALID;
- is.read((char*)&version, 1);
-
- if(is.fail())
- throw SerializationError("ServerMap::loadBlock(): Failed"
- " to read MapBlock version");
-
- MapBlock *block = NULL;
- bool created_new = false;
- block = sector->getBlockNoCreateNoEx(blockpos.Y);
- if(block == NULL)
- {
- block = sector->createBlankBlockNoInsert(blockpos.Y);
- created_new = true;
- }
- // Read basic data
- block->deSerialize(is, version, true);
- // If it's a new block, insert it to the map
- if(created_new)
- sector->insertBlock(block);
- /*
- Save blocks loaded in old format in new format
- */
-
- //if(version < SER_FMT_VER_HIGHEST || save_after_load)
- // Only save if asked to; no need to update version
- //if(save_after_load)
- // saveBlock(block);
- // We just loaded it from, so it's up-to-date.
- block->resetModified();
-
- }
- catch(SerializationError &e)
- {
- errorstream<<"Invalid block data in database"
- <<" ("<<blockpos.X<<","<<blockpos.Y<<","<<blockpos.Z<<")"
- <<" (SerializationError): "<<e.what()<<std::endl;
- // TODO: Block should be marked as invalid in memory so that it is
- // not touched but the game can run
-
- if(g_settings->getBool("ignore_world_load_errors")){
- errorstream<<"Ignoring block load error. Duck and cover! "
- <<"(ignore_world_load_errors)"<<std::endl;
- } else {
- throw SerializationError("Invalid block data in database");
- //assert(0);
- }
- }
-
- return srvmap->getBlockNoCreateNoEx(blockpos); // should not be using this here
- }
- return(NULL);
+ if (m_database.count(getBlockAsInteger(blockpos)))
+ return m_database[getBlockAsInteger(blockpos)];
+ else
+ return "";
}
void Database_Dummy::listAllLoadableBlocks(std::list<v3s16> &dst)
Database_Dummy(ServerMap *map);
virtual void beginSave();
virtual void endSave();
- virtual bool saveBlock(MapBlock *block);
- virtual MapBlock *loadBlock(v3s16 blockpos);
- virtual void listAllLoadableBlocks(std::list<v3s16> &dst);
- virtual int Initialized(void);
+ virtual bool saveBlock(v3s16 blockpos, std::string &data);
+ virtual std::string loadBlock(v3s16 blockpos);
+ virtual void listAllLoadableBlocks(std::list<v3s16> &dst);
+ virtual int Initialized(void);
~Database_Dummy();
private:
ServerMap *srvmap;
void Database_LevelDB::beginSave() {}
void Database_LevelDB::endSave() {}
-bool Database_LevelDB::saveBlock(MapBlock *block)
+bool Database_LevelDB::saveBlock(v3s16 blockpos, std::string &data)
{
- DSTACK(__FUNCTION_NAME);
-
- v3s16 p3d = block->getPos();
-
- /*
- Dummy blocks are not written
- */
- if(block->isDummy())
- {
- errorstream << "WARNING: saveBlock: Not writing dummy block "
- << PP(p3d) << std::endl;
- return true;
- }
-
- // Format used for writing
- u8 version = SER_FMT_VER_HIGHEST_WRITE;
-
- /*
- [0] u8 serialization version
- [1] data
- */
- std::ostringstream o(std::ios_base::binary);
- o.write((char*)&version, 1);
- // Write basic data
- block->serialize(o, version, true);
- // Write block to database
- std::string tmp = o.str();
-
leveldb::Status status = m_database->Put(leveldb::WriteOptions(),
- i64tos(getBlockAsInteger(p3d)), tmp);
+ i64tos(getBlockAsInteger(blockpos)), data);
if (!status.ok()) {
errorstream << "WARNING: saveBlock: LevelDB error saving block "
- << PP(p3d) << ": " << status.ToString() << std::endl;
+ << PP(blockpos) << ": " << status.ToString() << std::endl;
return false;
}
- // We just wrote it to the disk so clear modified flag
- block->resetModified();
return true;
}
-MapBlock* Database_LevelDB::loadBlock(v3s16 blockpos)
+std::string Database_LevelDB::loadBlock(v3s16 blockpos)
{
- v2s16 p2d(blockpos.X, blockpos.Z);
-
std::string datastr;
leveldb::Status status = m_database->Get(leveldb::ReadOptions(),
i64tos(getBlockAsInteger(blockpos)), &datastr);
- if (datastr.length() == 0 && status.ok()) {
- errorstream << "Blank block data in database (datastr.length() == 0) ("
- << blockpos.X << "," << blockpos.Y << "," << blockpos.Z << ")" << std::endl;
-
- if (g_settings->getBool("ignore_world_load_errors")) {
- errorstream << "Ignoring block load error. Duck and cover! "
- << "(ignore_world_load_errors)" << std::endl;
- } else {
- throw SerializationError("Blank block data in database");
- }
- return NULL;
- }
- if (status.ok()) {
- /*
- Make sure sector is loaded
- */
- MapSector *sector = srvmap->createSector(p2d);
-
- try {
- std::istringstream is(datastr, std::ios_base::binary);
- u8 version = SER_FMT_VER_INVALID;
- is.read((char *)&version, 1);
-
- if (is.fail())
- throw SerializationError("ServerMap::loadBlock(): Failed"
- " to read MapBlock version");
-
- MapBlock *block = NULL;
- bool created_new = false;
- block = sector->getBlockNoCreateNoEx(blockpos.Y);
- if (block == NULL)
- {
- block = sector->createBlankBlockNoInsert(blockpos.Y);
- created_new = true;
- }
-
- // Read basic data
- block->deSerialize(is, version, true);
-
- // If it's a new block, insert it to the map
- if (created_new)
- sector->insertBlock(block);
-
- /*
- Save blocks loaded in old format in new format
- */
- //if(version < SER_FMT_VER_HIGHEST || save_after_load)
- // Only save if asked to; no need to update version
- //if(save_after_load)
- // saveBlock(block);
- // We just loaded it from, so it's up-to-date.
- block->resetModified();
- }
- catch (SerializationError &e)
- {
- errorstream << "Invalid block data in database"
- << " (" << blockpos.X << "," << blockpos.Y << "," << blockpos.Z
- << ") (SerializationError): " << e.what() << std::endl;
- // TODO: Block should be marked as invalid in memory so that it is
- // not touched but the game can run
-
- if (g_settings->getBool("ignore_world_load_errors")) {
- errorstream << "Ignoring block load error. Duck and cover! "
- << "(ignore_world_load_errors)" << std::endl;
- } else {
- throw SerializationError("Invalid block data in database");
- //assert(0);
- }
- }
-
- return srvmap->getBlockNoCreateNoEx(blockpos); // should not be using this here
- }
- return NULL;
+
+ if(status.ok())
+ return datastr;
+ else
+ return "";
}
void Database_LevelDB::listAllLoadableBlocks(std::list<v3s16> &dst)
Database_LevelDB(ServerMap *map, std::string savedir);
virtual void beginSave();
virtual void endSave();
- virtual bool saveBlock(MapBlock *block);
- virtual MapBlock *loadBlock(v3s16 blockpos);
- virtual void listAllLoadableBlocks(std::list<v3s16> &dst);
- virtual int Initialized(void);
+ virtual bool saveBlock(v3s16 blockpos, std::string &data);
+ virtual std::string loadBlock(v3s16 blockpos);
+ virtual void listAllLoadableBlocks(std::list<v3s16> &dst);
+ virtual int Initialized(void);
~Database_LevelDB();
private:
ServerMap *srvmap;
freeReplyObject(reply);
}
-bool Database_Redis::saveBlock(MapBlock *block)
+bool Database_Redis::saveBlock(v3s16 blockpos, std::string &data)
{
- DSTACK(__FUNCTION_NAME);
-
- v3s16 p3d = block->getPos();
-
- /*
- Dummy blocks are not written
- */
- if(block->isDummy())
- {
- errorstream << "WARNING: saveBlock: Not writing dummy block "
- << PP(p3d) << std::endl;
- return true;
- }
-
- // Format used for writing
- u8 version = SER_FMT_VER_HIGHEST_WRITE;
-
- /*
- [0] u8 serialization version
- [1] data
- */
-
- std::ostringstream o(std::ios_base::binary);
- o.write((char*)&version, 1);
- // Write basic data
- block->serialize(o, version, true);
- // Write block to database
- std::string tmp1 = o.str();
- std::string tmp2 = i64tos(getBlockAsInteger(p3d));
+ std::string tmp = i64tos(getBlockAsInteger(blockpos));
redisReply *reply = (redisReply *)redisCommand(ctx, "HSET %s %s %b",
- hash.c_str(), tmp2.c_str(), tmp1.c_str(), tmp1.size());
+ hash.c_str(), tmp.c_str(), data.c_str(), data.size());
if (!reply) {
errorstream << "WARNING: saveBlock: redis command 'HSET' failed on "
- "block " << PP(p3d) << ": " << ctx->errstr << std::endl;
+ "block " << PP(blockpos) << ": " << ctx->errstr << std::endl;
freeReplyObject(reply);
return false;
}
if (reply->type == REDIS_REPLY_ERROR) {
- errorstream << "WARNING: saveBlock: save block " << PP(p3d)
+ errorstream << "WARNING: saveBlock: saving block " << PP(blockpos)
<< "failed" << std::endl;
freeReplyObject(reply);
return false;
}
- // We just wrote it to the disk so clear modified flag
- block->resetModified();
freeReplyObject(reply);
return true;
}
-MapBlock* Database_Redis::loadBlock(v3s16 blockpos)
+std::string Database_Redis::loadBlock(v3s16 blockpos)
{
- v2s16 p2d(blockpos.X, blockpos.Z);
-
std::string tmp = i64tos(getBlockAsInteger(blockpos));
redisReply *reply;
reply = (redisReply*) redisCommand(ctx, "HGET %s %s", hash.c_str(), tmp.c_str());
+
if(!reply)
throw FileNotGoodException(std::string("redis command 'HGET %s %s' failed: ") + ctx->errstr);
+ if(reply->type != REDIS_REPLY_STRING)
+ return "";
- if (reply->type == REDIS_REPLY_STRING && reply->len == 0) {
- freeReplyObject(reply);
- errorstream << "Blank block data in database (reply->len == 0) ("
- << blockpos.X << "," << blockpos.Y << "," << blockpos.Z << ")" << std::endl;
-
- if (g_settings->getBool("ignore_world_load_errors")) {
- errorstream << "Ignoring block load error. Duck and cover! "
- << "(ignore_world_load_errors)" << std::endl;
- } else {
- throw SerializationError("Blank block data in database");
- }
- return NULL;
- }
-
- if (reply->type == REDIS_REPLY_STRING) {
- /*
- Make sure sector is loaded
- */
- MapSector *sector = srvmap->createSector(p2d);
-
- try {
- std::istringstream is(std::string(reply->str, reply->len), std::ios_base::binary);
- freeReplyObject(reply); // std::string copies the memory so we can already do this here
- u8 version = SER_FMT_VER_INVALID;
- is.read((char *)&version, 1);
-
- if (is.fail())
- throw SerializationError("ServerMap::loadBlock(): Failed"
- " to read MapBlock version");
-
- MapBlock *block = NULL;
- bool created_new = false;
- block = sector->getBlockNoCreateNoEx(blockpos.Y);
- if (block == NULL)
- {
- block = sector->createBlankBlockNoInsert(blockpos.Y);
- created_new = true;
- }
-
- // Read basic data
- block->deSerialize(is, version, true);
-
- // If it's a new block, insert it to the map
- if (created_new)
- sector->insertBlock(block);
-
- // We just loaded it from, so it's up-to-date.
- block->resetModified();
- }
- catch (SerializationError &e)
- {
- errorstream << "Invalid block data in database"
- << " (" << blockpos.X << "," << blockpos.Y << "," << blockpos.Z
- << ") (SerializationError): " << e.what() << std::endl;
- // TODO: Block should be marked as invalid in memory so that it is
- // not touched but the game can run
-
- if (g_settings->getBool("ignore_world_load_errors")) {
- errorstream << "Ignoring block load error. Duck and cover! "
- << "(ignore_world_load_errors)" << std::endl;
- } else {
- throw SerializationError("Invalid block data in database");
- }
- }
-
- return srvmap->getBlockNoCreateNoEx(blockpos); // should not be using this here
- }
- return NULL;
+ std::string str(reply->str, reply->len);
+ freeReplyObject(reply); // std::string copies the memory so this won't cause any problems
+ return str;
}
void Database_Redis::listAllLoadableBlocks(std::list<v3s16> &dst)
Database_Redis(ServerMap *map, std::string savedir);
virtual void beginSave();
virtual void endSave();
- virtual bool saveBlock(MapBlock *block);
- virtual MapBlock *loadBlock(v3s16 blockpos);
+ virtual bool saveBlock(v3s16 blockpos, std::string &data);
+ virtual std::string loadBlock(v3s16 blockpos);
virtual void listAllLoadableBlocks(std::list<v3s16> &dst);
virtual int Initialized(void);
~Database_Redis();
void Database_SQLite3::beginSave() {
verifyDatabase();
if(sqlite3_exec(m_database, "BEGIN;", NULL, NULL, NULL) != SQLITE_OK)
- infostream<<"WARNING: beginSave() failed, saving might be slow.";
+ errorstream<<"WARNING: beginSave() failed, saving might be slow.";
}
void Database_SQLite3::endSave() {
verifyDatabase();
if(sqlite3_exec(m_database, "COMMIT;", NULL, NULL, NULL) != SQLITE_OK)
- infostream<<"WARNING: endSave() failed, map might not have saved.";
+ errorstream<<"WARNING: endSave() failed, map might not have saved.";
}
void Database_SQLite3::createDirs(std::string path)
d = sqlite3_open_v2(dbp.c_str(), &m_database, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
if(d != SQLITE_OK) {
- infostream<<"WARNING: SQLite3 database failed to open: "<<sqlite3_errmsg(m_database)<<std::endl;
+ errorstream<<"SQLite3 database failed to open: "<<sqlite3_errmsg(m_database)<<std::endl;
throw FileNotGoodException("Cannot open database file");
}
+ itos(g_settings->getU16("sqlite_synchronous"));
d = sqlite3_exec(m_database, querystr.c_str(), NULL, NULL, NULL);
if(d != SQLITE_OK) {
- infostream<<"WARNING: Database pragma set failed: "
+ errorstream<<"Database pragma set failed: "
<<sqlite3_errmsg(m_database)<<std::endl;
throw FileNotGoodException("Cannot set pragma");
}
d = sqlite3_prepare(m_database, "SELECT `data` FROM `blocks` WHERE `pos`=? LIMIT 1", -1, &m_database_read, NULL);
if(d != SQLITE_OK) {
- infostream<<"WARNING: SQLite3 database read statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
+ errorstream<<"SQLite3 read statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
throw FileNotGoodException("Cannot prepare read statement");
}
d = sqlite3_prepare(m_database, "REPLACE INTO `blocks` VALUES(?, ?)", -1, &m_database_write, NULL);
if(d != SQLITE_OK) {
- infostream<<"WARNING: SQLite3 database write statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
+ errorstream<<"SQLite3 write statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
throw FileNotGoodException("Cannot prepare write statement");
}
d = sqlite3_prepare(m_database, "SELECT `pos` FROM `blocks`", -1, &m_database_list, NULL);
if(d != SQLITE_OK) {
- infostream<<"WARNING: SQLite3 database list statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
+ infostream<<"SQLite3 list statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
throw FileNotGoodException("Cannot prepare read statement");
}
infostream<<"ServerMap: SQLite3 database opened"<<std::endl;
}
-bool Database_SQLite3::saveBlock(MapBlock *block)
+bool Database_SQLite3::saveBlock(v3s16 blockpos, std::string &data)
{
- DSTACK(__FUNCTION_NAME);
-
- v3s16 p3d = block->getPos();
-
- /*
- Dummy blocks are not written, but is not a save failure
- */
- if(block->isDummy())
- {
- errorstream << "WARNING: saveBlock: Not writing dummy block "
- << PP(p3d) << std::endl;
- return true;
- }
-
- // Format used for writing
- u8 version = SER_FMT_VER_HIGHEST_WRITE;
-
-#if 0
- v2s16 p2d(p3d.X, p3d.Z);
- std::string sectordir = getSectorDir(p2d);
-
- createDirs(sectordir);
-
- std::string fullpath = sectordir+DIR_DELIM+getBlockFilename(p3d);
- std::ofstream o(fullpath.c_str(), std::ios_base::binary);
- if(o.good() == false)
- throw FileNotGoodException("Cannot open block data");
-#endif
- /*
- [0] u8 serialization version
- [1] data
- */
-
verifyDatabase();
- std::ostringstream o(std::ios_base::binary);
-
- o.write((char *)&version, 1);
-
- // Write basic data
- block->serialize(o, version, true);
-
- // Write block to database
- std::string tmp = o.str();
-
- if (sqlite3_bind_int64(m_database_write, 1, getBlockAsInteger(p3d)) != SQLITE_OK) {
+ if (sqlite3_bind_int64(m_database_write, 1, getBlockAsInteger(blockpos)) != SQLITE_OK) {
errorstream << "WARNING: saveBlock: Block position failed to bind: "
- << PP(p3d) << ": " << sqlite3_errmsg(m_database) << std::endl;
+ << PP(blockpos) << ": " << sqlite3_errmsg(m_database) << std::endl;
sqlite3_reset(m_database_write);
return false;
}
- if (sqlite3_bind_blob(m_database_write, 2, (void *)tmp.c_str(), tmp.size(), NULL) != SQLITE_OK) {
+ if (sqlite3_bind_blob(m_database_write, 2, (void *) data.c_str(), data.size(), NULL) != SQLITE_OK) {
errorstream << "WARNING: saveBlock: Block data failed to bind: "
- << PP(p3d) << ": " << sqlite3_errmsg(m_database) << std::endl;
+ << PP(blockpos) << ": " << sqlite3_errmsg(m_database) << std::endl;
sqlite3_reset(m_database_write);
return false;
}
if (sqlite3_step(m_database_write) != SQLITE_DONE) {
errorstream << "WARNING: saveBlock: Block failed to save "
- << PP(p3d) << ": " << sqlite3_errmsg(m_database) << std::endl;
+ << PP(blockpos) << ": " << sqlite3_errmsg(m_database) << std::endl;
sqlite3_reset(m_database_write);
return false;
}
- // We just wrote it to the disk so clear modified flag
- block->resetModified();
sqlite3_reset(m_database_write);
return true;
}
-MapBlock* Database_SQLite3::loadBlock(v3s16 blockpos)
+std::string Database_SQLite3::loadBlock(v3s16 blockpos)
{
- v2s16 p2d(blockpos.X, blockpos.Z);
verifyDatabase();
if (sqlite3_bind_int64(m_database_read, 1, getBlockAsInteger(blockpos)) != SQLITE_OK) {
- infostream << "WARNING: Could not bind block position for load: "
+ errorstream << "Could not bind block position for load: "
<< sqlite3_errmsg(m_database)<<std::endl;
}
if (sqlite3_step(m_database_read) == SQLITE_ROW) {
- /*
- Make sure sector is loaded
- */
- MapSector *sector = srvmap->createSector(p2d);
-
- /*
- Load block
- */
- const char *data = (const char *)sqlite3_column_blob(m_database_read, 0);
+ const char *data = (const char *) sqlite3_column_blob(m_database_read, 0);
size_t len = sqlite3_column_bytes(m_database_read, 0);
- if (data == NULL || len == 0) {
- errorstream << "Blank block data in database (data == NULL || len"
- " == 0) (" << blockpos.X << "," << blockpos.Y << ","
- << blockpos.Z << ")" << std::endl;
-
- if (g_settings->getBool("ignore_world_load_errors")) {
- errorstream << "Ignoring block load error. Duck and cover! "
- << "(ignore_world_load_errors)" << std::endl;
- } else {
- throw SerializationError("Blank block data in database");
- }
- return NULL;
- }
-
- std::string datastr(data, len);
-
- //srvmap->loadBlock(&datastr, blockpos, sector, false);
-
- try {
- std::istringstream is(datastr, std::ios_base::binary);
-
- u8 version = SER_FMT_VER_INVALID;
- is.read((char *)&version, 1);
-
- if (is.fail())
- throw SerializationError("ServerMap::loadBlock(): Failed"
- " to read MapBlock version");
-
- MapBlock *block = NULL;
- bool created_new = false;
- block = sector->getBlockNoCreateNoEx(blockpos.Y);
- if (block == NULL)
- {
- block = sector->createBlankBlockNoInsert(blockpos.Y);
- created_new = true;
- }
-
- // Read basic data
- block->deSerialize(is, version, true);
-
- // If it's a new block, insert it to the map
- if (created_new)
- sector->insertBlock(block);
-
- /*
- Save blocks loaded in old format in new format
- */
- //if(version < SER_FMT_VER_HIGHEST || save_after_load)
- // Only save if asked to; no need to update version
- //if(save_after_load)
- // saveBlock(block);
-
- // We just loaded it from, so it's up-to-date.
- block->resetModified();
- }
- catch (SerializationError &e)
- {
- errorstream << "Invalid block data in database"
- << " (" << blockpos.X << "," << blockpos.Y << "," << blockpos.Z << ")"
- << " (SerializationError): " << e.what() << std::endl;
-
- // TODO: Block should be marked as invalid in memory so that it is
- // not touched but the game can run
-
- if (g_settings->getBool("ignore_world_load_errors")) {
- errorstream << "Ignoring block load error. Duck and cover! "
- << "(ignore_world_load_errors)" << std::endl;
- } else {
- throw SerializationError("Invalid block data in database");
- //assert(0);
- }
- }
+
+ std::string s = "";
+ if(data)
+ s = std::string(data, len);
sqlite3_step(m_database_read);
// We should never get more than 1 row, so ok to reset
sqlite3_reset(m_database_read);
- return srvmap->getBlockNoCreateNoEx(blockpos); // should not be using this here
+ return s;
}
+
sqlite3_reset(m_database_read);
- return NULL;
+ return "";
}
void Database_SQLite3::createDatabase()
<< "Failed to close database: rc=" << rc << std::endl;
}
}
-
{
public:
Database_SQLite3(ServerMap *map, std::string savedir);
- virtual void beginSave();
- virtual void endSave();
+ virtual void beginSave();
+ virtual void endSave();
- virtual bool saveBlock(MapBlock *block);
- virtual MapBlock *loadBlock(v3s16 blockpos);
- virtual void listAllLoadableBlocks(std::list<v3s16> &dst);
- virtual int Initialized(void);
+ virtual bool saveBlock(v3s16 blockpos, std::string &data);
+ virtual std::string loadBlock(v3s16 blockpos);
+ virtual void listAllLoadableBlocks(std::list<v3s16> &dst);
+ virtual int Initialized(void);
~Database_SQLite3();
private:
ServerMap *srvmap;
// Create the database structure
void createDatabase();
- // Verify we can read/write to the database
- void verifyDatabase();
- void createDirs(std::string path);
+ // Verify we can read/write to the database
+ void verifyDatabase();
+ void createDirs(std::string path);
};
#endif
#define DATABASE_HEADER
#include <list>
+#include <string>
#include "irr_v3d.h"
#include "irrlichttypes.h"
#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
#endif
-class MapBlock;
-
class Database
{
public:
virtual void beginSave() = 0;
virtual void endSave() = 0;
- virtual bool saveBlock(MapBlock *block) = 0;
- virtual MapBlock *loadBlock(v3s16 blockpos) = 0;
+ virtual bool saveBlock(v3s16 blockpos, std::string &data) = 0;
+ virtual std::string loadBlock(v3s16 blockpos) = 0;
s64 getBlockAsInteger(const v3s16 pos) const;
v3s16 getIntegerAsBlock(s64 i) const;
virtual void listAllLoadableBlocks(std::list<v3s16> &dst) = 0;
new_db->beginSave();
for (std::list<v3s16>::iterator i = blocks.begin(); i != blocks.end(); i++) {
MapBlock *block = old_map.loadBlock(*i);
- new_db->saveBlock(block);
- MapSector *sector = old_map.getSectorNoGenerate(v2s16(i->X, i->Z));
- sector->deleteBlock(block);
+ if (!block) {
+ errorstream << "Failed to load block " << PP(*i) << ", skipping it.";
+ } else {
+ old_map.saveBlock(block, new_db);
+ MapSector *sector = old_map.getSectorNoGenerate(v2s16(i->X, i->Z));
+ sector->deleteBlock(block);
+ }
++count;
if (count % 500 == 0)
actionstream << "Migrated " << count << " blocks "
}
//END
-
bool ServerMap::saveBlock(MapBlock *block)
{
- return dbase->saveBlock(block);
+ return saveBlock(block, dbase);
+}
+
+bool ServerMap::saveBlock(MapBlock *block, Database *db)
+{
+ v3s16 p3d = block->getPos();
+
+ // Dummy blocks are not written
+ if (block->isDummy()) {
+ errorstream << "WARNING: saveBlock: Not writing dummy block "
+ << PP(p3d) << std::endl;
+ return true;
+ }
+
+ // Format used for writing
+ u8 version = SER_FMT_VER_HIGHEST_WRITE;
+
+ /*
+ [0] u8 serialization version
+ [1] data
+ */
+ std::ostringstream o(std::ios_base::binary);
+ o.write((char*) &version, 1);
+ block->serialize(o, version, true);
+
+ std::string data = o.str();
+ bool ret = db->saveBlock(p3d, data);
+ if(ret) {
+ // We just wrote it to the disk so clear modified flag
+ block->resetModified();
+ }
+ return ret;
}
void ServerMap::loadBlock(std::string sectordir, std::string blockfile,
DSTACK(__FUNCTION_NAME);
std::string fullpath = sectordir+DIR_DELIM+blockfile;
- try{
+ try {
std::ifstream is(fullpath.c_str(), std::ios_base::binary);
if(is.good() == false)
v2s16 p2d(blockpos.X, blockpos.Z);
- MapBlock *ret;
+ std::string ret;
ret = dbase->loadBlock(blockpos);
- if (ret) return (ret);
+ if (ret != "") {
+ loadBlock(&ret, blockpos, createSector(p2d), false);
+ return getBlockNoCreateNoEx(blockpos);
+ }
// Not found in database, try the files
// The directory layout we're going to load from.
// Server implements this.
// Client leaves it as no-op.
- virtual bool saveBlock(MapBlock *block){ return false; };
+ virtual bool saveBlock(MapBlock *block) { return false; };
/*
Updates usage timers and unloads unused blocks and sectors.
// Returns true if sector now resides in memory
//bool deFlushSector(v2s16 p2d);
+ bool saveBlock(MapBlock *block, Database *db);
bool saveBlock(MapBlock *block);
// This will generate a sector with getSector if not found.
void loadBlock(std::string sectordir, std::string blockfile, MapSector *sector, bool save_after_load=false);
};
#endif
-
projects / zefram / minetest / minetest_engine.git / commitdiff