bool authorize(const Service& authService,
Identity *providerIdentity,
ProviderSession *session,
const CorrelationId& cid)
{
{
MutexGuard guard(&g_lock);
g_authorizationStatus[cid] = WAITING;
}
EventQueue tokenEventQueue;
session->generateToken(CorrelationId(), &tokenEventQueue);
std::string token;
Event event = tokenEventQueue.nextEvent();
if (event.eventType() == Event::TOKEN_STATUS ||
event.eventType() == Event::REQUEST_STATUS) {
MessageIterator iter(event);
while (iter.next()) {
Message msg = iter.message();
{
MutexGuard guard(&g_lock);
msg.print(std::cout);
}
if (msg.messageType() == TOKEN_SUCCESS) {
token = msg.getElementAsString(TOKEN);
}
else if (msg.messageType() == TOKEN_FAILURE) {
break;
}
}
}
if (token.length() == 0) {
MutexGuard guard(&g_lock);
std::cout << "Failed to get token" << std::endl;
return false;
}
Request authRequest = authService.createAuthorizationRequest();
authRequest.set(TOKEN, token.c_str());
session->sendAuthorizationRequest(
authRequest,
providerIdentity,
cid);
time_t startTime = time(0);
const int WAIT_TIME_SECONDS = 10;
while (true) {
{
MutexGuard guard(&g_lock);
if (WAITING != g_authorizationStatus[cid]) {
return AUTHORIZED == g_authorizationStatus[cid];
}
}
time_t endTime = time(0);
if (endTime - startTime > WAIT_TIME_SECONDS) {
return false;
}
SLEEP(1);
}
}
bool authorizeUsers()
{
Service authService = d_session->getService(APIAUTH_SVC);
bool is_any_user_authorized = false;
// Authorize each of the users
d_identities.reserve(d_tokens.size());
for (size_t i = 0; i < d_tokens.size(); ++i) {
d_identities.push_back(d_session->createIdentity());
Request authRequest = authService.createAuthorizationRequest();
authRequest.set("token", d_tokens[i].c_str());
CorrelationId correlator(&d_tokens[i]);
EventQueue eventQueue;
d_session->sendAuthorizationRequest(authRequest,
&d_identities[i], correlator, &eventQueue);
Event event = eventQueue.nextEvent();
if (event.eventType() == Event::RESPONSE ||
event.eventType() == Event::REQUEST_STATUS) {
MessageIterator msgIter(event);
while (msgIter.next()) {
Message msg = msgIter.message();
if (msg.messageType() == AUTHORIZATION_SUCCESS) {
std::cout << "User #" << (i+1)
<< " authorization success"
<< std::endl;
is_any_user_authorized = true;
}
else {
std::cout << "User #" << (i+1)
<< " authorization failed"
<< std::endl;
printEvent(event);
}
}
}
}
return is_any_user_authorized;
}
void clientRun(Session *requesterSession)
{
Session& session = *requesterSession;
std::cout << "Client is starting------" << std::endl;
if (!session.start()) {
std::cerr <<"Failed to start client session." << std::endl;
return;
}
Identity identity = session.createIdentity();
if (!d_authOptions.empty()) {
bool isAuthorized = false;
const char* authServiceName = "//blp/apiauth";
if (session.openService(authServiceName)) {
Service authService = session.getService(authServiceName);
isAuthorized = authorize(authService, &identity,
&session, CorrelationId((void *)"cauth"));
}
if (!isAuthorized) {
std::cerr << "No authorization" << std::endl;
return;
}
}
if (!session.openService(d_service.c_str())) {
std::cerr <<"Failed to open " << d_service << std::endl;
return;
}
Service service = session.getService(d_service.c_str());
Request request = service.createRequest("ReferenceDataRequest");
// append securities to request
// Add securities to request
Element securities = request.getElement("securities");
for (size_t i = 0; i < d_securities.size(); ++i) {
securities.appendValue(d_securities[i].c_str());
}
// Add fields to request
Element fields = request.getElement("fields");
for (size_t i = 0; i < d_fields.size(); ++i) {
fields.appendValue(d_fields[i].c_str());
}
request.set("timestamp", getTimestamp());
{
MutexGuard guard(&g_mutex);
std::cout << "Sending Request: " << request << std::endl;
}
EventQueue eventQueue;
session.sendRequest(request, identity,
CorrelationId((void *)"AddRequest"), &eventQueue);
while (true) {
Event event = eventQueue.nextEvent();
std::cout << std::endl << "Client received an event" << std::endl;
MessageIterator msgIter(event);
while (msgIter.next()) {
Message msg = msgIter.message();
MutexGuard guard(&g_mutex);
if (event.eventType() == Event::RESPONSE) {
if (msg.hasElement("timestamp")) {
double responseTime = msg.getElementAsFloat64(
"timestamp");
std::cout << "Response latency = "
<< getTimestamp() - responseTime
<< std::endl;
}
}
msg.print(std::cout) << std::endl;
}
if (event.eventType() == Event::RESPONSE) {
break;
}
}
}
Identity* authenticateWithApp(SEXP con_) {
Identity* identity_p = 0;
// via Rcpp Attributes we get a try/catch block with error propagation to R "for free"
Session* session =
reinterpret_cast<Session*>(checkExternalPointer(con_, "blpapi::Session*"));
// setup authorization service
std::string service("//blp/apiauth");
// authorize
if (session->openService(service.c_str())) {
Service authService = session->getService(service.c_str());
CorrelationId correlation_id(10);
std::string token;
EventQueue tokenEventQueue;
session->generateToken(correlation_id, &tokenEventQueue);
Event event = tokenEventQueue.nextEvent();
//
// get token for session
//
if(event.eventType() == Event::TOKEN_STATUS ||
event.eventType() == Event::REQUEST_STATUS) {
MessageIterator msgIter(event);
while(msgIter.next()) {
Message msg = msgIter.message();
if (msg.messageType() == "TokenGenerationSuccess") {
token = msg.getElementAsString("token");
} else if(msg.messageType() == "TokenGenerationFailure") {
Rcpp::stop("Failed to generate token");
}
}
}
//
// begin authorization
//
if(!token.empty()) {
Request authRequest = authService.createAuthorizationRequest();
authRequest.set("token", token.c_str());
identity_p = new Identity(session->createIdentity());
session->sendAuthorizationRequest(authRequest, identity_p);
// parse messages
bool message_found = false;
while(!message_found) {
Event event = session->nextEvent(100000);
if (event.eventType() == Event::RESPONSE ||
event.eventType() == Event::REQUEST_STATUS ||
event.eventType() == Event::PARTIAL_RESPONSE) {
MessageIterator msgIter(event);
while (msgIter.next()) {
Message msg = msgIter.message();
if (msg.messageType() == "AuthorizationSuccess") {
message_found = true;
} else {
Rcpp::stop(">>> Failed to Authorize");
}
}
} else if(event.eventType() == Event::TIMEOUT) {
Rcpp::stop("Timed out trying to authorize");
}
}
} else {
Rcpp::stop("Generated token was empty");
}
}
return identity_p;
}
