CachedObjectMgr Class Reference

#include "CachedObjectMgr.h"

Collaboration diagram for CachedObjectMgr:

Classes
class	CacheRecord

Public Member Functions
	~CachedObjectMgr ()
bool	HaveCached (const std::string &objectID) const
bool	HaveCached (const PyRep *objectID) const
bool	IsCacheUpToDate (const PyRep *objectID, uint32 version, int64 timestamp)
void	InvalidateCache (const PyRep *objectID)
void	UpdateCacheFromSS (const std::string &objectID, PySubStream **in_cached_data)
void	UpdateCache (const std::string &objectID, PyRep **in_cached_data)
void	UpdateCache (const PyRep *objectID, PyRep **in_cached_data)
PyObject *	MakeCacheHint (const PyRep *objectID)
PyObject *	MakeCacheHint (const std::string &objectID)
PyObject *	GetCachedObject (const PyRep *objectID)
PyObject *	GetCachedObject (const std::string &objectID)
PySubStream *	LoadCachedFile (const char *obj_name)
PySubStream *	LoadCachedFile (PyRep *key, const char *oname)
PySubStream *	LoadCachedFile (const char *filename, const char *oname)
PyCachedObjectDecoder *	LoadCachedObject (const char *filename, const char *oname)
PyCachedCall *	LoadCachedCall (const char *filename, const char *oname)
bool	LoadCachedFromFile (const std::string &cacheDir, const std::string &objectID)
bool	LoadCachedFromFile (const std::string &cacheDir, const PyRep *objectID)
bool	SaveCachedToFile (const std::string &cacheDir, const std::string &objectID) const
bool	SaveCachedToFile (const std::string &cacheDir, const PyRep *objectID) const

Static Public Member Functions
static std::string	OIDToString (const PyRep *objectID)

Protected Types
typedef std::map< std::string, CacheRecord * >	CachedObjMap
typedef CachedObjMap::iterator	CachedObjMapItr
typedef CachedObjMap::const_iterator	CachedObjMapConstItr

Protected Member Functions
void	GetCacheFileName (PyRep *key, std::string &into)
void	_UpdateCache (const PyRep *objectID, PyBuffer **buffer)

Protected Attributes
CachedObjMap	m_cachedObjects

Detailed Description

Definition at line 58 of file CachedObjectMgr.h.

Member Typedef Documentation

typedef std::map<std::string, CacheRecord *> CachedObjectMgr::CachedObjMap

protected

Definition at line 117 of file CachedObjectMgr.h.

typedef CachedObjMap::const_iterator CachedObjectMgr::CachedObjMapConstItr

protected

Definition at line 119 of file CachedObjectMgr.h.

typedef CachedObjMap::iterator CachedObjectMgr::CachedObjMapItr

protected

Definition at line 118 of file CachedObjectMgr.h.

Constructor & Destructor Documentation

CachedObjectMgr::~CachedObjectMgr

(

)

Definition at line 91 of file CachedObjectMgr.cpp.

References m_cachedObjects, and SafeDelete().

{
    CachedObjMapItr cur, end;
    cur = m_cachedObjects.begin();
    end = m_cachedObjects.end();

    for(; cur != end; cur++) {
        SafeDelete( cur->second );
    }
}

Here is the call graph for this function:

Member Function Documentation

void CachedObjectMgr::_UpdateCache ( const PyRep *  objectID, PyBuffer **  buffer  )

protected

Definition at line 227 of file CachedObjectMgr.cpp.

References CachedObjectMgr::CacheRecord::cache, PyRep::Clone(), PyBuffer::content(), CRC32::Generate(), GetFileTimeNow(), m_cachedObjects, CachedObjectMgr::CacheRecord::objectID, OIDToString(), SafeDelete(), Buffer::size(), sLog, CachedObjectMgr::CacheRecord::timestamp, and CachedObjectMgr::CacheRecord::version.

Referenced by UpdateCache(), and UpdateCacheFromSS().

{
    //this is the hard one..
    CacheRecord *r = new CacheRecord();
    r->timestamp = GetFileTimeNow();
    r->objectID = objectID->Clone();

    // retake ownership
    r->cache = *pbuf;
    *pbuf = nullptr;

    r->version = CRC32::Generate( &r->cache->content()[0], r->cache->content().size() );

    const std::string str = OIDToString(objectID);

    //find and destroy any older version of this object.
    CachedObjMapItr res = m_cachedObjects.find(str);

    if (res != m_cachedObjects.end()) {

        sLog.Debug("CachedObjMgr","Destroying old cached object with ID '%s' of length %u with checksum 0x%x", str.c_str(), res->second->cache->content().size(), res->second->version);
        SafeDelete( res->second );
    }

    sLog.Debug("CachedObjMgr","Registering new cached object with ID '%s' of length %u with checksum 0x%x", str.c_str(), r->cache->content().size(), r->version);

    m_cachedObjects[str] = r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject * CachedObjectMgr::GetCachedObject

(

const PyRep *

objectID

)

Definition at line 285 of file CachedObjectMgr.cpp.

References PyCachedObject::cache, PyRep::Clone(), PyCachedObject::compressed, PyCachedObject::Encode(), HackCacheNodeID, m_cachedObjects, MarshalHeaderByte, PyCachedObject::nodeID, PyCachedObject::objectID, OIDToString(), PyCachedObject::shared, sLog, PyCachedObject::timestamp, and PyCachedObject::version.

Referenced by GetCachedObject().

{
    const std::string str = OIDToString(objectID);

    CachedObjMapItr res = m_cachedObjects.find(str);
    if (res == m_cachedObjects.end())
        return nullptr;

    PyCachedObject co;
    co.timestamp = res->second->timestamp;
    co.version = res->second->version;
    co.nodeID = HackCacheNodeID;    //hack, doesn't matter until we have multi-node networks.
    co.shared = true;
    co.objectID = res->second->objectID->Clone();
    co.cache = res->second->cache;

    if (res->second->cache->content().size() == 0 || res->second->cache->content()[0] == MarshalHeaderByte)
        co.compressed = false;
    else
        co.compressed = true;

    sLog.Debug("CachedObjMgr","Returning cached object '%s' with checksum 0x%x", str.c_str(), co.version);

    PyObject* result = co.Encode();
    co.cache = nullptr;    //avoid a copy

    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject * CachedObjectMgr::GetCachedObject

(

const std::string &

objectID

)

Definition at line 276 of file CachedObjectMgr.cpp.

References GetCachedObject(), and PyDecRef.

{
    //this is sub-optimal, but it keeps things more consistent (in case StringCollapseVisitor ever gets more complicated)
    PyString* str = new PyString( objectID );
    PyObject* obj(GetCachedObject(str));
    PyDecRef(str);
    return obj;
}

Here is the call graph for this function:

void CachedObjectMgr::GetCacheFileName ( PyRep *  key, std::string &  into  )

protected

Definition at line 543 of file CachedObjectMgr.cpp.

References Base64::encode(), Marshal(), and Buffer::size().

Referenced by LoadCachedFile().

{
    Buffer data;
    Marshal( key, data );

    Base64::encode( &data[0], data.size(), into, false );

    std::string::size_type epos = into.find('=');
    if (epos != std::string::npos)
        into.resize(epos);

    into += ".cache";
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool CachedObjectMgr::HaveCached

(

const std::string &

objectID

)

const

Definition at line 151 of file CachedObjectMgr.cpp.

References PyDecRef.

Referenced by ObjCacheService::_LoadCachableObject(), and ObjCacheService::IsCacheLoaded().

{
    //this is very sub-optimal, but it keeps things more consistent (in case StringCollapseVisitor ever gets more complicated)
    PyString *str = new PyString( objectID );
    bool ret = HaveCached(str);
    PyDecRef(str);
    return ret;
}

Here is the caller graph for this function:

bool CachedObjectMgr::HaveCached

(

const PyRep *

objectID

)

const

Definition at line 160 of file CachedObjectMgr.cpp.

References m_cachedObjects, OIDToString(), and PyIncRef.

{
    PyIncRef(objectID);
    const std::string str = OIDToString(objectID);

    return (m_cachedObjects.find(str) != m_cachedObjects.end());
}

Here is the call graph for this function:

void CachedObjectMgr::InvalidateCache

(

const PyRep *

objectID

)

Definition at line 168 of file CachedObjectMgr.cpp.

References m_cachedObjects, OIDToString(), PyIncRef, and SafeDelete().

Referenced by ObjCacheService::InvalidateCache().

{
    PyIncRef(objectID);
    const std::string str = OIDToString(objectID);
    CachedObjMapItr res = m_cachedObjects.find(str);

    if (res != m_cachedObjects.end()) {
        SafeDelete( res->second );
        m_cachedObjects.erase(res);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool CachedObjectMgr::IsCacheUpToDate	(	const PyRep *	objectID,
		uint32	version,
		int64	timestamp
	)

Definition at line 314 of file CachedObjectMgr.cpp.

References m_cachedObjects, and OIDToString().

{
    const std::string str = OIDToString(objectID);

    CachedObjMapItr res = m_cachedObjects.find(str);
    if (res == m_cachedObjects.end())
        return false;

    //for now, only support exact matches...
    return (   res->second->version == version
            && res->second->timestamp == timestamp);
}

Here is the call graph for this function:

PyCachedCall * CachedObjectMgr::LoadCachedCall	(	const char *	filename,
		const char *	oname
	)

Definition at line 526 of file CachedObjectMgr.cpp.

References PyCachedCall::Decode(), LoadCachedFile(), and SafeDelete().

{
    PySubStream* ss = LoadCachedFile(filename, oname);
    if ( ss == nullptr )
        return nullptr;

    PyCachedCall *obj = new PyCachedCall();
    if (!obj->Decode(&ss)) {   //ss is consumed.
        SafeDelete( obj );
        return nullptr;
    }

    return obj;
}

Here is the call graph for this function:

PySubStream * CachedObjectMgr::LoadCachedFile

(

const char *

obj_name

)

Definition at line 457 of file CachedObjectMgr.cpp.

References PyDecRef.

Referenced by ObjCacheService::_LoadCachableObject(), LoadCachedCall(), ObjCacheService::LoadCachedFile(), LoadCachedFile(), and LoadCachedObject().

{
    PyString* str = new PyString(obj_name);
    PySubStream* ret = LoadCachedFile(str, obj_name);
    PyDecRef(str);
    return ret;
}

Here is the caller graph for this function:

PySubStream * CachedObjectMgr::LoadCachedFile	(	PyRep *	key,
		const char *	oname
	)

Definition at line 465 of file CachedObjectMgr.cpp.

References GetCacheFileName(), and LoadCachedFile().

{
    std::string fname;
    GetCacheFileName(key, fname);

    std::string abs_fname = "../data/cache/";
    abs_fname += fname;

    return LoadCachedFile(abs_fname.c_str(), oname);
}

Here is the call graph for this function:

PySubStream * CachedObjectMgr::LoadCachedFile	(	const char *	filename,
		const char *	oname
	)

Todo:

Mem leak. new PyBuffer() never freed

Definition at line 476 of file CachedObjectMgr.cpp.

References filesize(), SafeDelete(), and sLog.

{
    FILE* f = fopen( abs_fname, "rb" );

    if ( f == nullptr ) {
        sLog.Error("CachedObjMgr","Unable to open cache file '%s' for oname '%s': %s", abs_fname, oname, strerror( errno ) );
        return 0;
    }

    int64 file_length = filesize( f );
    if ( file_length == 0 )
    {
        sLog.Error("CachedObjMgr","Unable to stat cache file '%s' for oname '%s'", abs_fname, oname );
        fclose( f );
        return 0;
    }

    Buffer* buf = new Buffer(static_cast<size_t>(file_length));

    if ( file_length != fread( &( *buf )[0], sizeof( uint8 ), static_cast<size_t>(file_length), f ) ) {
        sLog.Error("CachedObjMgr","Unable to read cache file '%s' for oname '%s%': %s", abs_fname, oname, strerror( errno ) );
        SafeDelete( buf );
        fclose( f );
        return 0;
    }

    fclose( f );
    sLog.Debug("CachedObjMgr","Loaded cache file for '%s': length %u", oname, file_length );

    PySubStream* res = new PySubStream( new PyBuffer( &buf ) );
    SafeDelete( buf );
    return res;
}

Here is the call graph for this function:

bool CachedObjectMgr::LoadCachedFromFile	(	const std::string &	cacheDir,
		const std::string &	objectID
	)

Definition at line 327 of file CachedObjectMgr.cpp.

References PyDecRef.

Referenced by ObjCacheService::_LoadCachableObject().

{
    //this is sub-optimal, but it keeps things more consistent (in case StringCollapseVisitor ever gets more complicated)
    PyString* str = new PyString(objectID);
    bool ret = LoadCachedFromFile(cacheDir, str);
    PyDecRef(str);
    return ret;
}

Here is the caller graph for this function:

bool CachedObjectMgr::LoadCachedFromFile	(	const std::string &	cacheDir,
		const PyRep *	objectID
	)

LoadCachedFromFile

Load a cached object from file.

Definition at line 341 of file CachedObjectMgr.cpp.

References CachedObjectMgr::CacheRecord::cache, CacheFileMagic, PyRep::Clone(), CacheFileHeader::length, m_cachedObjects, CacheFileHeader::magic, CachedObjectMgr::CacheRecord::objectID, OIDToString(), SafeDelete(), CacheFileHeader::timestamp, CachedObjectMgr::CacheRecord::timestamp, CacheFileHeader::version, and CachedObjectMgr::CacheRecord::version.

{
    const std::string str = OIDToString(objectID);

    std::string filename(cacheDir);
    filename += "/" + str + ".cache";

    FILE *f = fopen(filename.c_str(), "rb");

    if (f == nullptr)
        return false;

    CacheFileHeader header;
    if (fread(&header, sizeof(header), 1, f) != 1) {
        fclose(f);
        return false;
    }

    /* check if its a valid cache file */
    if (header.magic != CacheFileMagic) {
        fclose(f);
        return false;
    }

    Buffer* buf = new Buffer( header.length );

    if ( fread( &(*buf)[0], sizeof( uint8 ), header.length, f ) != header.length ) {
        SafeDelete( buf );
        fclose( f );
        return false;
    }

    fclose( f );

    CachedObjMapItr res = m_cachedObjects.find( str );

    if ( res != m_cachedObjects.end() )
        SafeDelete( res->second );

    CacheRecord* cache = m_cachedObjects[ str ] = new CacheRecord;
    cache->objectID = objectID->Clone();
    cache->cache = new PyBuffer( &buf );
    cache->timestamp = header.timestamp;
    cache->version = header.version;

    m_cachedObjects[ str ] = cache;

    SafeDelete( buf );
    return true;
}

Here is the call graph for this function:

PyCachedObjectDecoder * CachedObjectMgr::LoadCachedObject	(	const char *	filename,
		const char *	oname
	)

Definition at line 511 of file CachedObjectMgr.cpp.

References PyCachedObjectDecoder::Decode(), LoadCachedFile(), and SafeDelete().

Referenced by ObjectToSQL().

{
    PySubStream* ss = LoadCachedFile(filename, oname);
    if ( ss == nullptr )
        return nullptr;

    PyCachedObjectDecoder *obj = new PyCachedObjectDecoder();
    if (!obj->Decode(&ss)) {   //ss is consumed.
        SafeDelete( obj );
        return nullptr;
    }

    return obj;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject * CachedObjectMgr::MakeCacheHint

(

const PyRep *

objectID

)

Definition at line 265 of file CachedObjectMgr.cpp.

References m_cachedObjects, and OIDToString().

Referenced by ObjCacheService::GetCacheHint(), MakeCacheHint(), ObjCacheService::MakeObjectCachedMethodCallResult(), and ObjCacheService::MakeObjectCachedSessionMethodCallResult().

{
    const std::string str = OIDToString(objectID);

    CachedObjMapItr res = m_cachedObjects.find(str);
    if (res == m_cachedObjects.end())
        return nullptr;

    return res->second->EncodeHint();
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject * CachedObjectMgr::MakeCacheHint

(

const std::string &

objectID

)

Definition at line 256 of file CachedObjectMgr.cpp.

References MakeCacheHint(), and PyDecRef.

{
    //this is sub-optimal, but it keeps things more consistent (in case StringCollapseVisitor ever gets more complicated)
    PyString* str = new PyString( objectID );
    PyObject* obj(MakeCacheHint(str));
    PyDecRef(str);
    return obj;
}

Here is the call graph for this function:

std::string CachedObjectMgr::OIDToString ( const PyRep *  objectID )

static

Definition at line 139 of file CachedObjectMgr.cpp.

References PyRep::Dump(), StringCollapseVisitor::result, sLog, and PyRep::visit().

Referenced by ObjCacheService::_LoadCachableObject(), _UpdateCache(), GetCachedObject(), ObjCacheService::GetCacheHint(), HaveCached(), InvalidateCache(), IsCacheUpToDate(), LoadCachedFromFile(), MakeCacheHint(), and SaveCachedToFile().

{
    StringCollapseVisitor v;
    if ( !objectID->visit( v ) ) {
        sLog.Error("Cached Obj Mgr", "Failed to convert cache hind object ID into collapsed string:");
        objectID->Dump(CACHE__DUMP, "    ");
        assert(false);
        return "";
    }
    return v.result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool CachedObjectMgr::SaveCachedToFile	(	const std::string &	cacheDir,
		const std::string &	objectID
	)		const

Definition at line 393 of file CachedObjectMgr.cpp.

References PyDecRef.

Referenced by ObjCacheService::_LoadCachableObject().

{
    PyString* str = new PyString(objectID);
    bool ret = SaveCachedToFile(cacheDir, str);
    PyDecRef(str);
    return ret;
}

Here is the caller graph for this function:

bool CachedObjectMgr::SaveCachedToFile	(	const std::string &	cacheDir,
		const PyRep *	objectID
	)		const

Definition at line 401 of file CachedObjectMgr.cpp.

References CacheFileMagic, CacheFileHeader::length, m_cachedObjects, CacheFileHeader::magic, OIDToString(), CacheFileHeader::timestamp, and CacheFileHeader::version.

{
    const std::string str = OIDToString(objectID);
    CachedObjMapConstItr res = m_cachedObjects.find(str);

    /* make sure we don't try to save a object we don't have */
    if (res == m_cachedObjects.end())
        return false;

    std::string filename(cacheDir);
    filename += "/";
    filename += str;
    filename += ".cache";

    FILE *f = fopen(filename.c_str(), "wb");

    if (f == nullptr)
        return false;

    CacheFileHeader header;
    header.timestamp = res->second->timestamp;
    header.version = res->second->version;
    header.magic = CacheFileMagic;
    header.length = res->second->cache->content().size();

    if (fwrite(&header, sizeof(header), 1, f) != 1) {
        fclose(f);
        return false;
    }

    if (fwrite(&res->second->cache->content()[0], sizeof(uint8), header.length, f) != header.length) {
        assert(false);
        fclose(f);
        return false;
    }
    fclose(f);
    return true;
}

Here is the call graph for this function:

void CachedObjectMgr::UpdateCache	(	const std::string &	objectID,
		PyRep **	in_cached_data
	)

Definition at line 197 of file CachedObjectMgr.cpp.

References PyDecRef.

Referenced by ObjCacheService::_LoadCachableObject(), and ObjCacheService::GiveCache().

{
    PyString *str = new PyString( objectID );
    UpdateCache(str, in_cached_data);
    PyDecRef(str);
}

Here is the caller graph for this function:

void CachedObjectMgr::UpdateCache	(	const PyRep *	objectID,
		PyRep **	in_cached_data
	)

Definition at line 204 of file CachedObjectMgr.cpp.

References _UpdateCache(), MarshalDeflate(), SafeDelete(), and sLog.

{
    PyRep* cached_data(*in_cached_data);
    *in_cached_data = nullptr;

    //if (is_log_enabled(CACHE__DUMP)) {
    //  PyLogsysDump dumper(CACHE__DUMP, CACHE__DUMP, false, true);
        //cached_data->visit(&dumper, 0);
    //}

    Buffer* buf = new Buffer();
    bool res = MarshalDeflate( cached_data, *buf );

    if ( res ) {
        PyBuffer* pbuf = new PyBuffer( &buf );
        _UpdateCache( objectID, &pbuf );
    } else {
        sLog.Error( "Cached Obj Mgr", "Failed to marshal or deflate new cache object." );
    }

    SafeDelete( buf );
}

Here is the call graph for this function:

void CachedObjectMgr::UpdateCacheFromSS	(	const std::string &	objectID,
		PySubStream **	in_cached_data
	)

Definition at line 182 of file CachedObjectMgr.cpp.

References _UpdateCache(), PyCachedObjectDecoder::cache, PySubStream::data(), PyCachedObjectDecoder::Decode(), PyDecRef, and sLog.

Referenced by ObjCacheService::_LoadCachableObject().

{
    PyCachedObjectDecoder cache;
    if (!cache.Decode(in_cached_data)) {
        sLog.Error("CachedObjMgr","Failed to decode stream");
        return;
    }

    PyString* str = new PyString( objectID );
    PyBuffer* buf = cache.cache->data();
    _UpdateCache(str, &buf);

    PyDecRef( str );
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

CachedObjMap CachedObjectMgr::m_cachedObjects

protected

Definition at line 122 of file CachedObjectMgr.h.

Referenced by _UpdateCache(), GetCachedObject(), HaveCached(), InvalidateCache(), IsCacheUpToDate(), LoadCachedFromFile(), MakeCacheHint(), SaveCachedToFile(), and ~CachedObjectMgr().

---

The documentation for this class was generated from the following files:

• /backups/local/src/eve/EvEmu_Crucible/src/eve-common/cache/CachedObjectMgr.h
• /backups/local/src/eve/EvEmu_Crucible/src/eve-common/cache/CachedObjectMgr.cpp