int
moveToPreloadedDir (const char *path, const char *iRODSPath) {
int status;
char preloadCachePath[MAX_NAME_LEN];
off_t cacheSize;
if (path == NULL || iRODSPath == NULL) {
rodsLog (LOG_DEBUG, "moveToPreloadedDir: input path or iRODSPath is NULL");
return (SYS_INTERNAL_NULL_INPUT_ERR);
}
status = _getCachePath(iRODSPath, preloadCachePath);
if(status < 0) {
rodsLog (LOG_DEBUG, "moveToPreloadedDir: failed to get cache path - %s", path);
return status;
}
// make dir
makeParentDirs(preloadCachePath);
// move the file
status = rename(path, preloadCachePath);
if(status < 0) {
rodsLog (LOG_DEBUG, "moveToPreloadedDir: rename error : %d", status);
return status;
}
// check whether preload cache exceeds limit
if(PreloadConfig.cacheMaxSize > 0) {
cacheSize = getFileSizeRecursive(PreloadConfig.cachePath);
if(cacheSize > (off_t)PreloadConfig.cacheMaxSize) {
// evict?
status = _evictOldCache(cacheSize - (off_t)PreloadConfig.cacheMaxSize);
if(status < 0) {
rodsLog (LOG_DEBUG, "moveToPreloadedDir: failed to evict old cache");
return status;
}
}
}
return (0);
}
int
preloadFile (const char *path, struct stat *stbuf) {
int status;
preloadThreadInfo_t *existingThreadInfo = NULL;
preloadThreadInfo_t *threadInfo = NULL;
preloadThreadData_t *threadData = NULL;
char iRODSPath[MAX_NAME_LEN];
off_t cacheSize;
// convert input path to iRODSPath
status = _getiRODSPath(path, iRODSPath);
if(status < 0) {
rodsLogError(LOG_ERROR, status, "preloadFile: _getiRODSPath error.");
rodsLog (LOG_ERROR, "preloadFile: failed to get iRODS path - %s", path);
return status;
}
// check the given file is already preloaded or preloading
LOCK(PreloadLock);
// check the given file is preloading
existingThreadInfo = (preloadThreadInfo_t *)lookupFromHashTable(PreloadThreadTable, iRODSPath);
if(existingThreadInfo != NULL) {
rodsLog (LOG_DEBUG, "preloadFile: preloading is already running - %s", iRODSPath);
UNLOCK(PreloadLock);
return 0;
}
if(_hasValidCache(iRODSPath, stbuf) != 0) {
// invalidate cache - this may fail if cache file does not exists
// if old cache exists in local, invalidate it
_invalidateCache(iRODSPath);
if(stbuf->st_size < PreloadConfig.preloadMinSize) {
rodsLog (LOG_DEBUG, "preloadFile: given file is smaller than preloadMinSize, canceling preloading - %s", iRODSPath);
UNLOCK(PreloadLock);
return (0);
}
// check whether preload cache exceeds limit
if(PreloadConfig.cacheMaxSize > 0) {
// cache max size is set
if(stbuf->st_size > (off_t)PreloadConfig.cacheMaxSize) {
rodsLog (LOG_DEBUG, "preloadFile: given file is bigger than cacheMaxSize, canceling preloading - %s", iRODSPath);
UNLOCK(PreloadLock);
return (0);
}
cacheSize = getFileSizeRecursive(PreloadConfig.cachePath);
if((cacheSize + stbuf->st_size) > (off_t)PreloadConfig.cacheMaxSize) {
// evict?
status = _evictOldCache((cacheSize + stbuf->st_size) - (off_t)PreloadConfig.cacheMaxSize);
if(status < 0) {
rodsLog (LOG_ERROR, "preloadFile: failed to evict old cache");
UNLOCK(PreloadLock);
return status;
}
}
}
// does not have valid cache. now, start a new preloading
// create a new thread to preload
threadInfo = (preloadThreadInfo_t *)malloc(sizeof(preloadThreadInfo_t));
threadInfo->path = strdup(iRODSPath);
threadInfo->running = PRELOAD_THREAD_RUNNING;
INIT_STRUCT_LOCK((*threadInfo));
insertIntoHashTable(PreloadThreadTable, iRODSPath, threadInfo);
// prepare thread argument
threadData = (preloadThreadData_t *)malloc(sizeof(preloadThreadData_t));
threadData->path = strdup(iRODSPath);
memcpy(&threadData->stbuf, stbuf, sizeof(struct stat));
threadData->threadInfo = threadInfo;
rodsLog (LOG_DEBUG, "preloadFile: start preloading - %s", iRODSPath);
#ifdef USE_BOOST
status = threadInfo->thread = new boost::thread(_preloadThread, (void *)threadData);
#else
status = pthread_create(&threadInfo->thread, NULL, _preloadThread, (void *)threadData);
#endif
} else {
rodsLog (LOG_DEBUG, "preloadFile: given file is already preloaded - %s", iRODSPath);
status = 0;
}
UNLOCK(PreloadLock);
return status;
}
