void CCacheWriter::InitializeCache(CReaderCacheManager& cache_manager,
const TPluginManagerParamTree* params)
{
const TPluginManagerParamTree* writer_params = params ?
params->FindNode(NCBI_GBLOADER_WRITER_CACHE_DRIVER_NAME) : 0;
ICache* id_cache = 0;
ICache* blob_cache = 0;
auto_ptr<TParams> id_params
(GetCacheParams(writer_params, eCacheWriter, eIdCache));
auto_ptr<TParams> blob_params
(GetCacheParams(writer_params, eCacheWriter, eBlobCache));
_ASSERT(id_params.get());
_ASSERT(blob_params.get());
const TParams* share_id_param =
id_params->FindNode(NCBI_GBLOADER_WRITER_CACHE_PARAM_SHARE);
bool share_id = !share_id_param ||
NStr::StringToBool(share_id_param->GetValue().value);
const TParams* share_blob_param =
blob_params->FindNode(NCBI_GBLOADER_WRITER_CACHE_PARAM_SHARE);
bool share_blob = !share_blob_param ||
NStr::StringToBool(share_blob_param->GetValue().value);
if (share_id || share_blob) {
if ( share_id ) {
ICache* cache = cache_manager.
FindCache(CReaderCacheManager::fCache_Id,
id_params.get());
if ( cache ) {
_ASSERT(!id_cache);
id_cache = cache;
}
}
if ( share_blob ) {
ICache* cache = cache_manager.
FindCache(CReaderCacheManager::fCache_Blob,
blob_params.get());
if ( cache ) {
_ASSERT(!blob_cache);
blob_cache = cache;
}
}
}
if ( !id_cache ) {
id_cache = CreateCache(writer_params, eCacheWriter, eIdCache);
if ( id_cache ) {
cache_manager.RegisterCache(*id_cache,
CReaderCacheManager::fCache_Id);
}
}
if ( !blob_cache ) {
blob_cache = CreateCache(writer_params, eCacheWriter, eBlobCache);
if ( blob_cache ) {
cache_manager.RegisterCache(*blob_cache,
CReaderCacheManager::fCache_Blob);
}
}
SetIdCache(id_cache);
SetBlobCache(blob_cache);
}
bool MEmblemMgr::PrepareCache()
{
if (LoadCache()) {
return true;
} else {
return CreateCache();
}
}
//-*****************************************************************************
// This version creates a cache.
AbcA::ArchiveReaderPtr
ReadArchive::operator()( const std::string &iFileName ) const
{
AbcA::ReadArraySampleCachePtr cachePtr = CreateCache();
Alembic::Util::shared_ptr<ArImpl> archivePtr(
new ArImpl( iFileName, cachePtr, m_cacheHierarchy ) );
return archivePtr;
}
bool VFSHandle_ZIP::OpenLocation(char *loc, bool create)
{
SetFilename(loc);
FindArchiveName();
VFSHandle *h = fusion->vfs->Open(m_archive,"bin",false);
if(h == NULL && create == true){
VFSHandle *h = fusion->vfs->Open(m_archive,"bin",true);
fusion->vfs->Close(h);
}else{
return false;
}
if(VFSHandle_file::Open(m_archive,false) == true){
CreateCache();
return true;
}
return false;
}
/**
* See previous CreateCache method. This method simply invokes that one with
* the same start and end time and a cache size of one.
*
* @param time Ephemeris time to cache
*/
void Spice::CreateCache (double time, double tol) {
CreateCache(time,time,1,tol);
}
void
NNSpoolResponse1(Connection *conn)
{
ServReq *sreq = conn->co_SReq;
char *buf;
int len;
conn->co_Func = NNSpoolResponse1;
conn->co_State = "spres1";
if ((len = MBReadLine(&conn->co_RMBuf, &buf)) > 0) {
conn->co_ServerByteCount += len;
if (strtol(buf, NULL, 10) == 220) {
/* We have a positive answer, we may cache article */
if (conn->co_Desc->d_Cache) {
CreateCache(conn);
}
/*
* sr_CConn may be NULL if client was terminated while
* server operation was still in progress.
*/
if (conn->co_SReq->sr_CConn) {
MBFree(&conn->co_SReq->sr_CConn->co_ArtBuf);
switch(sreq->sr_CConn->co_ArtMode) {
case COM_BODYNOSTAT:
break;
case COM_STAT:
case COM_HEAD:
case COM_BODY:
case COM_ARTICLE:
MBLogPrintf(sreq->sr_CConn, &sreq->sr_CConn->co_ArtBuf, "%03d 0 %s %s\r\n",
GoodRC(sreq->sr_CConn),
sreq->sr_MsgId,
GoodResId(sreq->sr_CConn)
);
break;
case COM_BODYWVF:
MBLogPrintf(sreq->sr_CConn, &sreq->sr_CConn->co_ArtBuf, "%03d %lld %s %s\r\n",
GoodRC(sreq->sr_CConn),
artno_art(sreq->sr_CConn->co_ArtBeg, sreq->sr_CConn->co_ArtEnd, sreq->sr_CConn->co_ArtNo, sreq->sr_CConn->co_Numbering),
sreq->sr_MsgId,
GoodResId(sreq->sr_CConn)
);
break;
case COM_ARTICLEWVF:
{
const char *ovdata;
const char *msgid;
int ovlen;
if ((ovdata = NNRetrieveHead(sreq->sr_CConn, &ovlen, &msgid, NULL, NULL, NULL)) != NULL) {
MBLogPrintf(sreq->sr_CConn, &sreq->sr_CConn->co_TMBuf, "%03d %lld %s %s\r\n",
GoodRC(sreq->sr_CConn),
artno_art(sreq->sr_CConn->co_ArtBeg, sreq->sr_CConn->co_ArtEnd, sreq->sr_CConn->co_ArtNo, sreq->sr_CConn->co_Numbering),
sreq->sr_MsgId,
GoodResId(sreq->sr_CConn)
);
DumpOVHeaders(sreq->sr_CConn, ovdata, ovlen);
MBPrintf(&sreq->sr_CConn->co_TMBuf, "\r\n");
sreq->sr_CConn->co_ArtMode = COM_BODYNOSTAT;
} else {
NNSpoolResponseScrap(conn);
return; /* bleh */
}
}
break;
}
}
NNSpoolResponse2(conn);
return;
}
else if (strtol(buf, NULL, 10) == 430) {
conn->co_ServerArticleNotFoundErrorCount++;
}
else {
conn->co_ServerArticleMiscErrorCount++;
}
if (sreq->sr_CConn == NULL)
NNFinishSReq(conn, NULL, 0);
else if (sreq->sr_CConn->co_ArtMode == COM_BODYNOSTAT)
NNFinishSReq(conn, "(article not available)\r\n.\r\n", 1);
else if (sreq->sr_CConn->co_RequestFlags == ARTFETCH_ARTNO)
NNFinishSReq(conn, "423 No such article number in this group\r\n", 1);
else
NNFinishSReq(conn, "430 No such article\r\n", 1);
} else if (len < 0) {
NNServerTerminate(conn);
} else {
/* else we haven't got the response yet */
/* note that we get here at least every 30s or so via forceallcheck */
if (conn->co_Desc->d_Timeout && (time(NULL) > sreq->sr_Time + conn->co_Desc->d_Timeout)) {
logit(LOG_ERR, "Timeout elapsed waiting for %s to answer request %s (2), closing spool server", conn->co_Desc->d_Id, sreq->sr_MsgId);
NNServerTerminate(conn);
}
}
}