void DiskCachingFileLoaderCache::InitCache(const std::string &path) {
cacheSize_ = 0;
indexCount_ = 0;
oldestGeneration_ = 0;
maxBlocks_ = MAX_BLOCKS_LOWER_BOUND;
flags_ = 0;
generation_ = 0;
const std::string cacheFilePath = MakeCacheFilePath(path);
bool fileLoaded = LoadCacheFile(cacheFilePath);
// We do some basic locking to protect against two things: crashes and concurrency.
// Concurrency will break the file. Crashes will probably leave it inconsistent.
if (fileLoaded && !LockCacheFile(true)) {
if (RemoveCacheFile(cacheFilePath)) {
// Create a new one.
fileLoaded = false;
} else {
// Couldn't remove, in use? Give up on caching.
CloseFileHandle();
}
}
if (!fileLoaded) {
CreateCacheFile(cacheFilePath);
if (!LockCacheFile(true)) {
CloseFileHandle();
}
}
}
bool IndexBitConnector::Save(char *fileName)
{
IndexBitConnectorHeader h;
while (true)
{
if (CreateCacheFile(fileName,CACHE_SIG_NAME,&h,sizeof(h),Method)==false)
break;
h.MemToAlloc = MemToAlloc;
if (file.Write(&h,sizeof(h))==false)
break;
if (file.Write(Data,MemToAlloc)==false)
break;
if (file.Write(Indexes,sizeof(UInt64)*((UInt64)nrRecords))==false)
break;
if (file.Write(Labels.GetData(),Labels.GetAllocated())==false)
break;
if (SaveRecordHashesAndFeatureNames()==false)
break;
CloseCacheFile();
return true;
}
notifier->Error("[%s] Unable to write into %s",ObjectName,fileName);
CloseCacheFile();
DeleteFileA(fileName);
return false;
}
HRESULT KProcessPerfCacheMgr::Init(LPCWSTR strCacheFile, LPCWSTR urlMapName)
{
m_strCacheFile = strCacheFile;
m_strUrlMapName = urlMapName;
if (!OpenCacheFile())
{
if (!CreateCacheFile())
{
kws_log(TEXT("KProcessPerfCacheMgr::Init try create cache file"));
return E_FAIL;
}
if (!OpenCacheFile())
{
kws_log(TEXT("KProcessPerfCacheMgr::Init try open cache file 2 failed"));
return E_FAIL;
}
}
kws_log(TEXT("KProcessPerfCacheMgr::Init sucess"));
return S_OK;
}
DataStream* ResourceManager::AddCacheFile(const char *filename)
{
if (!core->GameOnCD)
return FileStream::OpenFile(filename);
char fname[_MAX_PATH];
ExtractFileFromPath(fname, filename);
FileStream *dest = OpenCacheFile(fname);
// already in cache
if (dest)
return dest;
FileStream* src = FileStream::OpenFile(fname);
dest = CreateCacheFile(fname);
if (!src || !dest) {
printMessage("ResourceManager", "Failed to copy file '%s'\n", RED, fname);
abort();
}
size_t blockSize = 1024 * 1000;
char buff[1024 * 1000];
do {
if (blockSize > src->Remains())
blockSize = src->Remains();
size_t len = src->Read(buff, blockSize);
size_t c = dest->Write(buff, len);
if (c != len) {
printMessage("ResourceManager", "Failed to write to file '%s'\n", RED, fname);
abort();
}
} while (src->Remains());
delete src;
delete dest;
return OpenCacheFile(fname);
}
DataStream *ResourceManager::AddCompressedCacheFile(DataStream *stream, const char* filename, int length, bool overwrite)
{
if (!core->IsAvailable(PLUGIN_COMPRESSION_ZLIB)) {
printMessage("ResourceManager", "No compression manager available.\nCannot load compressed file.\n", RED);
return NULL;
}
char fname[_MAX_PATH];
ExtractFileFromPath(fname, filename);
FileStream *str = NULL;
if (!overwrite)
str = OpenCacheFile(fname);
if (!str) {
FileStream *out = CreateCacheFile(fname);
if (!out) {
printMessage("ResourceManager", "Failed to write to file '%s'.\n", RED, fname);
return NULL;
}
PluginHolder<Compressor> comp(PLUGIN_COMPRESSION_ZLIB);
if (comp->Decompress(out, stream, length) != GEM_OK) {
delete out;
return NULL;
}
delete out;
} else {
stream->Seek(length, GEM_CURRENT_POS);
}
delete str;
return OpenCacheFile(fname);
}
