Skip to content
Permalink
Browse files

Move MapBlock (de)serializing code out of Database class

  • Loading branch information
sfan5 committed Jul 8, 2014
1 parent 3feece1 commit eec456be63f6fee8604f7a9c40aa41a1af3f1fac
Showing with 120 additions and 494 deletions.
  1. +7 −101 src/database-dummy.cpp
  2. +4 −4 src/database-dummy.h
  3. +9 −109 src/database-leveldb.cpp
  4. +4 −4 src/database-leveldb.h
  5. +12 −106 src/database-redis.cpp
  6. +2 −2 src/database-redis.h
  7. +23 −145 src/database-sqlite3.cpp
  8. +9 −9 src/database-sqlite3.h
  9. +3 −4 src/database.h
  10. +7 −4 src/main.cpp
  11. +38 −4 src/map.cpp
  12. +2 −2 src/map.h
@@ -45,112 +45,18 @@ int Database_Dummy::Initialized(void)
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)
@@ -33,10 +33,10 @@ class Database_Dummy : public Database
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;
@@ -58,129 +58,29 @@ int Database_LevelDB::Initialized(void)
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)
@@ -36,10 +36,10 @@ class Database_LevelDB : public Database
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;

0 comments on commit eec456b

Please sign in to comment.
You can’t perform that action at this time.