int Logic::createRequest(bool simple, const std::string &client, const std::string &session,
const std::string &user, const std::string &privilege,
cynara_check_id &checkId, cynara_response_callback callback,
void *userResponseData) {
if (!m_operationPermitted)
return CYNARA_API_OPERATION_NOT_ALLOWED;
if (!ensureConnection())
return CYNARA_API_SERVICE_NOT_AVAILABLE;
ProtocolFrameSequenceNumber sequenceNumber;
if (!m_sequenceContainer.get(sequenceNumber))
return CYNARA_API_MAX_PENDING_REQUESTS;
PolicyKey key(client, user, privilege);
ResponseCallback responseCallback(callback, userResponseData);
m_checks.insert(CheckPair(sequenceNumber, CheckData(key, session, responseCallback,
simple)));
if (simple)
m_socketClient.appendRequest(SimpleCheckRequest(key, sequenceNumber));
else
m_socketClient.appendRequest(CheckRequest(key, sequenceNumber));
onStatusChange(m_socketClient.getSockFd(), cynara_async_status::CYNARA_STATUS_FOR_RW);
checkId = static_cast<cynara_check_id>(sequenceNumber);
return CYNARA_API_SUCCESS;
}
//----------------------------------------
void GenericAPICore::process()
//----------------------------------------
{
GenericRequest *req;
GenericResponse *res;
if (!m_suspended)
{
// Process timeout on pending requests
while((m_outCount > 0) && ((req = m_outboundQueue.front().first)->getTimeout() <= time(NULL)))
{
--m_outCount;
res = m_outboundQueue.front().second;
m_outboundQueue.pop();
responseCallback(res);
delete res;
delete req;
}
// Process timeout on pending responses
while((m_pendingCount > 0) && ((res = (*m_pending.begin()).second)->getTimeout() <= time(NULL)))
{
--m_pendingCount;
m_pending.erase(m_pending.begin());
responseCallback(res);
delete res;
}
while(m_outCount > 0)
{
pair<GenericRequest *, GenericResponse *> out_pair = m_outboundQueue.front();
req = out_pair.first;
res = out_pair.second;
GenericConnection *con = NULL;
if (req->getMappedServerTrack() == 0) // request has no originating "owner" server
{
con = getNextActiveConnection(); // it does not matter which server we send this to
}
else
{
ServerTrackObject *stobj = findServer(req->getMappedServerTrack());
if (stobj)
{
con = stobj->getConnection(); // the server connection to respond to
req->setServerTrack(stobj->getRealServerTrack()); // map server track back to REAL server track
//printf("\nUnmapping %d to %d", stobj->getMappedServerTrack(), req->getMappedServerTrack()); //debug
delete stobj;
}
}
if (con != NULL)
{
Base::ByteStream msg;
req->pack(msg);
con->Send(msg);
m_pending.insert(pair<unsigned, GenericResponse *>(res->getTrack(), res));
--m_outCount;
++m_pendingCount;
m_outboundQueue.pop();
delete req;
}
else
{
//no active connections
break; //from while loop
}
}
}
for (std::vector<GenericConnection *>::iterator conIter = m_serverConnections.begin(); conIter != m_serverConnections.end(); conIter++)
{
GenericConnection *con = *conIter;
con->process();
}
}
