virtual void run(void *arg)
{
Event ev;
if(isCollect)
{
EventAnswer *answ = ev.triggerAndCollect(name, buf, bufSize);
EventMessage msg(name, waitId, answ);
int msgLen;
char *msgBuf = msg.serialize(msgLen, msgManager);
msgManager->sendMessage(addr, msgBuf, msgLen);
delete []msgBuf;
delete answ;
Thread *thread = (Thread *)arg;
delete thread;
}
else
{
ev.triggerAndWait(name, buf, bufSize);
EventMessage msg(name, waitId);
int msgLen;
char *msgBuf = msg.serialize(msgLen, msgManager);
msgManager->sendMessage(addr, msgBuf, msgLen);
delete []msgBuf;
Thread *thread = (Thread *)arg;
delete thread;
}
}
bool Resources::fileExists(const string &path, InstanceID instanceId, const shared_ptr<Query>& query)
{
LOG4CXX_TRACE(logger, "Resources::fileExists. Checking file '" << path << "'");
NetworkManager* networkManager = NetworkManager::getInstance();
if (instanceId == query->getInstanceID())
{
LOG4CXX_TRACE(logger, "Resources::fileExists. Instance id " << instanceId << " is local instance. Returning result.");
return checkFileExists(path);
}
else
{
LOG4CXX_TRACE(logger, "Resources::fileExists. Instance id " << instanceId << " is remote instance. Requesting result.");
FileExistsResourcesCollector* collector = new FileExistsResourcesCollector();
uint64_t id = 0;
{
ScopedMutexLock lock(_lock);
id = ++_lastResourceCollectorId;
_resourcesCollectors[id] = collector;
}
shared_ptr<MessageDesc> msg = make_shared<MessageDesc>(mtResourcesFileExistsRequest);
shared_ptr<scidb_msg::ResourcesFileExistsRequest> request =
msg->getRecord<scidb_msg::ResourcesFileExistsRequest>();
msg->setQueryID(0);
request->set_resource_request_id(id);
request->set_file_path(path);
networkManager->sendMessage(instanceId, msg);
LOG4CXX_TRACE(logger, "Resources::fileExists. Waiting while instance return result for collector " << id);
try
{
Semaphore::ErrorChecker errorChecker = bind(&Query::validateQueryPtr, query);
collector->_collectorSem.enter(1, errorChecker);
}
catch (...)
{
LOG4CXX_TRACE(logger, "Resources::fileExists. Waiting for result of collector " << id <<
" interrupter by error");
{
ScopedMutexLock lock(_lock);
delete _resourcesCollectors[id];
_resourcesCollectors.erase(id);
}
throw;
}
LOG4CXX_TRACE(logger, "Resources::fileExists. Returning result of collector " << id);
bool result;
{
ScopedMutexLock lock(_lock);
result = ((FileExistsResourcesCollector*) _resourcesCollectors[id])->_instancesMap[instanceId];
delete _resourcesCollectors[id];
_resourcesCollectors.erase(id);
}
return result;
}
}
void Resources::handleFileExists(const shared_ptr<MessageDesc>& messageDesc)
{
NetworkManager* networkManager = NetworkManager::getInstance();
if (mtResourcesFileExistsRequest == messageDesc->getMessageType())
{
LOG4CXX_TRACE(logger, "Message is mtResourcesFileExistsRequest");
shared_ptr<scidb_msg::ResourcesFileExistsRequest> inMsgRecord =
messageDesc->getRecord<scidb_msg::ResourcesFileExistsRequest>();
const string& file = inMsgRecord->file_path();
LOG4CXX_TRACE(logger, "Checking file " << file);
shared_ptr<MessageDesc> msg = make_shared<MessageDesc>(mtResourcesFileExistsResponse);
msg->setQueryID(0);
shared_ptr<scidb_msg::ResourcesFileExistsResponse> outMsgRecord =
msg->getRecord<scidb_msg::ResourcesFileExistsResponse>();
outMsgRecord->set_resource_request_id(inMsgRecord->resource_request_id());
outMsgRecord->set_exits_flag(Resources::getInstance()->checkFileExists(file));
networkManager->sendMessage(messageDesc->getSourceInstanceID(), msg);
}
// mtResourcesFileExistsResponse
else
{
LOG4CXX_TRACE(logger, "Message is mtResourcesFileExistsResponse");
shared_ptr<scidb_msg::ResourcesFileExistsResponse> inMsgRecord =
messageDesc->getRecord<scidb_msg::ResourcesFileExistsResponse>();
LOG4CXX_TRACE(logger, "Marking file");
Resources::getInstance()->markFileExists(
inMsgRecord->resource_request_id(),
messageDesc->getSourceInstanceID(),
inMsgRecord->exits_flag());
}
}
