private void authorizeUsers()
{
// Authorize each of the users
for (int i = 0; i < d_uuids.Count; ++i)
{
Identity identity = d_session.CreateIdentity();
d_identities.Add(identity);
Request authRequest = d_apiAuthSvc.CreateAuthorizationRequest();
authRequest.Set("uuid", d_uuids[i]);
authRequest.Set("ipAddress", d_programAddresses[i]);
CorrelationID correlator = new CorrelationID(i);
EventQueue eventQueue = new EventQueue();
d_session.SendAuthorizationRequest(authRequest, identity,
eventQueue, correlator);
Event eventObj = eventQueue.NextEvent();
while (true)
{
printEvent(eventObj);
if (eventObj.Type == Event.EventType.RESPONSE ||
eventObj.Type == Event.EventType.PARTIAL_RESPONSE ||
eventObj.Type == Event.EventType.REQUEST_STATUS)
{
break;
}
eventObj = eventQueue.NextEvent();
}
}
}
private bool authorizeApplication(string token, out Identity identity)
{
bool isAuthorized = false;
bool isRunning = true;
identity = null;
if (!d_session.OpenService(API_AUTH_SVC_NAME))
{
System.Console.Error.WriteLine("Failed to open " + API_AUTH_SVC_NAME);
return(isAuthorized = false);
}
Service authService = d_session.GetService(API_AUTH_SVC_NAME);
Request authRequest = authService.CreateAuthorizationRequest();
authRequest.Set("token", token);
identity = d_session.CreateIdentity();
EventQueue authEventQueue = new EventQueue();
d_session.SendAuthorizationRequest(authRequest, identity, authEventQueue, new CorrelationID(1));
while (isRunning)
{
Event eventObj = authEventQueue.NextEvent();
System.Console.WriteLine("processEvent");
if (eventObj.Type == Event.EventType.RESPONSE || eventObj.Type == Event.EventType.REQUEST_STATUS)
{
foreach (Message msg in eventObj)
{
if (msg.MessageType == AUTHORIZATION_SUCCESS)
{
System.Console.WriteLine("Application authorization SUCCESS");
isAuthorized = true;
isRunning = false;
break;
}
else if (msg.MessageType == AUTHORIZATION_FAILURE)
{
System.Console.WriteLine("Application authorization FAILED");
System.Console.WriteLine(msg.ToString());
isRunning = false;
}
else
{
System.Console.WriteLine(msg.ToString());
}
}
}
}
return(isAuthorized);
}
private bool authorizeUsers()
{
bool is_any_user_authorized = false;
// Authorize each of the users
for (int i = 0; i < d_tokens.Count; ++i)
{
bool isRunning = true;
Identity identity = d_session.CreateIdentity();
d_identities.Add(identity);
Request authRequest = d_apiAuthSvc.CreateAuthorizationRequest();
authRequest.Set("token", d_tokens[i]);
CorrelationID correlator = new CorrelationID(i);
EventQueue eventQueue = new EventQueue();
d_session.SendAuthorizationRequest(authRequest, identity,
eventQueue, correlator);
Event eventObj = eventQueue.NextEvent();
while (isRunning)
{
if (eventObj.Type == Event.EventType.RESPONSE ||
eventObj.Type == Event.EventType.REQUEST_STATUS)
{
foreach (Message msg in eventObj)
{
if (msg.MessageType == AUTHORIZATION_SUCCESS)
{
System.Console.WriteLine("Authorization SUCCESS for user:"******"Authorization FAILED for user:" + (i + 1));
System.Console.WriteLine(msg);
isRunning = false;
break;
}
else
{
System.Console.WriteLine(msg);
isRunning = false;
}
}
}
}
}
return(is_any_user_authorized);
}
private void distributeMessage(Message msg)
{
Service service = msg.Service;
List <int> failedEntitlements = new List <int>();
Element securities = msg.GetElement(SECURITY_DATA);
int numSecurities = securities.NumValues;
System.Console.WriteLine("Processing " + numSecurities + " securities:");
for (int i = 0; i < numSecurities; ++i)
{
Element security = securities.GetValueAsElement(i);
String ticker = security.GetElementAsString(SECURITY);
Element entitlements = ((security.HasElement(EID_DATA) ?
security.GetElement(EID_DATA) : null));
int numUsers = d_identities.Count;
if (entitlements != null)
{
// Entitlements are required to access this data
for (int j = 0; j < numUsers; ++j)
{
failedEntitlements.Clear();
Identity identity = (Identity)d_identities[j];
if (identity.HasEntitlements(entitlements, service,
failedEntitlements))
{
System.Console.WriteLine("User: "******" is entitled to get data for: " + ticker);
// Now Distribute message to the user.
}
else
{
System.Console.WriteLine("User: "******" is NOT entitled to get data for: " + ticker +
" - Failed eids: ");
printFailedEntitlements(failedEntitlements);
}
}
}
else
{
// No Entitlements are required to access this data.
for (int j = 0; j < numUsers; ++j)
{
System.Console.WriteLine("User: "******" is entitled to get data for: " + ticker);
// Now Distribute message to the user.
}
}
}
}
private void SendRequest(Session session, Identity identity)
{
Console.WriteLine("Sending Request: {0}", d_requestType.ToString());
Service instrumentService = session.GetService(INSTRUMENT_SERVICE);
Request request;
try
{
request = instrumentService.CreateRequest(d_requestType.ToString());
}
catch (NotFoundException e)
{
throw new Exception(
string.Format("Request Type not found: {0}", d_requestType),
e);
}
request.Set(QUERY_ELEMENT, d_queryString);
request.Set(MAX_RESULTS_ELEMENT, d_maxResults);
foreach (KeyValuePair <string, string> entry in d_filters)
{
try
{
request.Set(entry.Key, entry.Value);
}
catch (NotFoundException e)
{
throw new Exception(string.Format("Filter not found: {0}", entry.Key), e);
}
catch (InvalidConversionException e)
{
throw new Exception(
string.Format(
"Invalid value: {0} for filter: {1}",
entry.Value,
entry.Key),
e);
}
}
request.Print(Console.Out);
Console.WriteLine();
session.SendRequest(request, identity, null);
}
private void sendRefDataRequest(bool isSync)
{
Request request = d_blpRefDataSvc.CreateRequest(
"ReferenceDataRequest");
// Add securities.
Element securities = request.GetElement("securities");
for (int i = 0; i < d_securities.Count; ++i)
{
securities.AppendValue((String)d_securities[i]);
}
// Add fields
Element fields = request.GetElement("fields");
fields.AppendValue("PX_LAST");
fields.AppendValue("PRICING_SOURCE");
request.Set("returnEids", true);
for (int i = 0; i < d_identities.Count; ++i)
{
// Send the request for each user
Identity identity = (Identity)d_identities[i];
System.Console.WriteLine("Sending RefDataRequest for User " + d_uuids[i]);
CorrelationID corId = new CorrelationID(d_uuids[i]);
d_session.Cancel(corId);
if (isSync)
{
// sync
EventQueue evtQueue = new EventQueue();
d_session.SendRequest(request, identity, evtQueue, corId);
eventLoop(evtQueue, d_session);
}
else
{
// async
d_session.SendRequest(request, identity, corId);
}
}
}
private void sendAuthRequest(Session session, String emrsUser, String ipAddress)
{
Service authService = session.GetService(d_auth);
Request authReq = authService.CreateAuthorizationRequest();
authReq.Set("emrsId", emrsUser);
authReq.Set("ipAddress", ipAddress);
this.identity = session.CreateIdentity();
try
{
System.Console.WriteLine("Sending Auth Request:" + authReq.ToString());
session.SendAuthorizationRequest(authReq, this.identity, new CorrelationID(identity));
System.Console.WriteLine("Sent Auth request.");
}
catch (System.Exception e)
{
System.Console.WriteLine("Unable to send authorization request: " + e.Message);
}
}
private void Run(string[] args)
{
try
{
ParseCommandLine(args);
SessionOptions sessionOptions = new SessionOptions();
sessionOptions.ServerHost = d_host;
sessionOptions.ServerPort = d_port;
sessionOptions.AuthenticationOptions = d_authOptions;
Console.WriteLine("Connecting to {0}:{1}", d_host, d_port);
using (Session session = new Session(sessionOptions))
{
if (!session.Start())
{
throw new Exception("Failed to start session");
}
Identity identity = null;
if (d_authOptions != null)
{
Authorize(out identity, session);
}
if (!session.OpenService(INSTRUMENT_SERVICE))
{
throw new Exception(
string.Format("Failed to open: {0}", INSTRUMENT_SERVICE));
}
SendRequest(session, identity);
EventLoop(session);
}
}
catch (Exception e)
{
Console.WriteLine(string.Format("Exception: {0}", e.Message));
Console.WriteLine();
PrintUsage();
}
}
public void processSubscriptionDataEvent(Event eventObj, Session session)
{
foreach (Message msg in eventObj)
{
if (!msg.HasElement(d_fieldAsName))
{
continue;
}
string topic = (string)msg.CorrelationID.Object;
System.Console.WriteLine(System.DateTime.Now.ToString("s")
+ ": " + topic + " - " + msg.MessageType);
Element field = msg.GetElement(d_fieldAsName);
if (field.IsNull)
{
System.Console.WriteLine(d_field + "is null, ignoring");
}
Service service = msg.Service;
bool needsEntitlement = msg.HasElement(EID);
for (int j = 0; j < d_identities.Count; ++j)
{
Identity identity = (Identity)d_identities[j];
if (!needsEntitlement ||
identity.HasEntitlements(msg.GetElement(EID), service))
{
System.Console.WriteLine("User: "******" is entitled to " + field);
// Now Distribute message to the user.
}
else
{
System.Console.WriteLine("User: "******" is NOT entitled for " + d_field + " because of " +
msg.GetElement(EID));
}
}
}
}
private bool Authorize(Service authService,
Identity identity,
Session session,
CorrelationID cid)
{
EventQueue tokenEventQueue = new EventQueue();
try {
session.GenerateToken(new CorrelationID(), tokenEventQueue);
} catch (Exception e) {
Console.WriteLine("Generate token failed with exception: \n"
+ e);
return(false);
}
String token = null;
int timeoutMilliSeconds = 10000;
Event eventObj = tokenEventQueue.NextEvent(timeoutMilliSeconds);
if (eventObj.Type == Event.EventType.TOKEN_STATUS ||
eventObj.Type == Event.EventType.REQUEST_STATUS)
{
foreach (Message msg in eventObj)
{
Console.WriteLine(msg.ToString());
if (msg.MessageType == TOKEN_SUCCESS)
{
token = msg.GetElementAsString("token");
}
}
}
if (token == null)
{
Console.Error.WriteLine("Failed to get token");
return(false);
}
Request authRequest = authService.CreateAuthorizationRequest();
authRequest.Set("token", token);
session.SendAuthorizationRequest(authRequest, identity, cid);
long startTime = System.DateTime.Now.Ticks;
const int WAIT_TIME = 10 * 1000; // 10 seconds
while (true)
{
eventObj = session.NextEvent(WAIT_TIME);
if (eventObj.Type == Event.EventType.RESPONSE ||
eventObj.Type == Event.EventType.PARTIAL_RESPONSE ||
eventObj.Type == Event.EventType.REQUEST_STATUS)
{
foreach (Message msg in eventObj)
{
Console.WriteLine(msg.ToString());
if (msg.MessageType == AUTHORIZATION_SUCCESS)
{
return(true);
}
else
{
return(false);
}
}
}
if (System.DateTime.Now.Ticks - startTime > WAIT_TIME * 10000)
{
return(false);
}
}
}
private void Run(String[] args)
{
if (!ParseCommandLine(args))
{
return;
}
SessionOptions.ServerAddress[] servers
= new SessionOptions.ServerAddress[d_hosts.Count];
for (int i = 0; i < d_hosts.Count; ++i)
{
servers[i]
= new SessionOptions.ServerAddress(d_hosts[i], d_port);
}
SessionOptions sessionOptions = new SessionOptions();
sessionOptions.ServerAddresses = servers;
sessionOptions.DefaultSubscriptionService = d_service;
sessionOptions.DefaultTopicPrefix = "ticker";
// normally defaults to "ticker"
sessionOptions.AuthenticationOptions = d_authOptions;
sessionOptions.AutoRestartOnDisconnection = true;
sessionOptions.NumStartAttempts = servers.Length;
Console.WriteLine("Connecting to");
foreach (SessionOptions.ServerAddress server in
sessionOptions.ServerAddresses)
{
Console.WriteLine(" " + server);
}
Console.WriteLine();
Session session = new Session(sessionOptions);
if (!session.Start())
{
for (;;)
{
Event e = session.TryNextEvent();
if (e == null)
{
break;
}
PrintMessage(e);
}
Console.Error.WriteLine("Failed to start session.");
return;
}
Identity identity = null;
if (d_authOptions != null)
{
bool isAuthorized = false;
identity = session.CreateIdentity();
if (session.OpenService("//blp/apiauth"))
{
Service authService = session.GetService("//blp/apiauth");
isAuthorized = Authorize(authService,
identity,
session,
new CorrelationID());
}
else
{
Console.Error.WriteLine("Failed to open //blp/apiauth.");
}
if (!isAuthorized)
{
Console.Error.WriteLine("No authorization");
return;
}
}
String fieldsString = "?fields=";
for (int iField = 0; iField < d_fields.Count; ++iField)
{
if (0 != iField)
{
fieldsString += ",";
}
fieldsString += d_fields[iField];
}
// NOTE: resources used by a snapshot request template are
// released only when 'RequestTemplateTerminated' message
// is received or when the session is destroyed. In order
// to release resources when request template is not needed
// anymore, user should call the 'Session.cancel' and pass
// the correlation id used when creating the request template,
// or call 'RequestTemplate.close'. If the 'Session.cancel'
// is used, all outstanding requests are canceled and the
// underlying subscription is closed immediately. If the
// handle is closed with the 'RequestTemplate.close', the
// underlying subscription is closed only when all outstanding
// requests are served.
Console.WriteLine("Creating snapshot request templates\n");
List <RequestTemplate> snapshots = new List <RequestTemplate>();
for (int iTopic = 0; iTopic < d_topics.Count; ++iTopic)
{
String subscriptionString
= d_service + d_topics[iTopic] + fieldsString;
RequestTemplate requestTemplate
= session.createSnapshotRequestTemplate(
subscriptionString,
new CorrelationID(iTopic),
identity);
snapshots.Add(requestTemplate);
}
int eventCount = 0;
while (true)
{
Event eventObj = session.NextEvent(1000);
foreach (Message msg in eventObj)
{
if (eventObj.Type == Event.EventType.RESPONSE ||
eventObj.Type == Event.EventType.PARTIAL_RESPONSE)
{
long iTopic = msg.CorrelationID.Value;
String topic = d_topics[(int)iTopic];
Console.WriteLine(topic + " - SNAPSHOT - ");
}
Console.WriteLine(msg);
}
if (eventObj.Type == Event.EventType.RESPONSE)
{
if (++eventCount >= d_maxEvents)
{
break;
}
}
if (eventObj.Type == Event.EventType.TIMEOUT)
{
Console.WriteLine(
"Sending request using the request templates\n");
for (int iTopic = 0; iTopic < snapshots.Count; ++iTopic)
{
session.SendRequest(snapshots[iTopic],
new CorrelationID(iTopic));
}
}
}
}
// Authorize should be called before any requests are sent.
public static void Authorize(out Identity identity, Session session)
{
identity = session.CreateIdentity();
if (!session.OpenService(AUTH_SERVICE))
{
throw new Exception(
string.Format("Failed to open auth service: {0}",
AUTH_SERVICE));
}
Service authService = session.GetService(AUTH_SERVICE);
EventQueue tokenEventQueue = new EventQueue();
session.GenerateToken(new CorrelationID(tokenEventQueue), tokenEventQueue);
string token = null;
// Generate token responses will come on the dedicated queue. There would be no other
// messages on that queue.
Event eventObj = tokenEventQueue.NextEvent(
Convert.ToInt32(WAIT_TIME.TotalMilliseconds));
if (eventObj.Type == Event.EventType.TOKEN_STATUS ||
eventObj.Type == Event.EventType.REQUEST_STATUS)
{
foreach (Message msg in eventObj)
{
System.Console.WriteLine(msg);
if (msg.MessageType == TOKEN_SUCCESS)
{
token = msg.GetElementAsString(TOKEN_ELEMENT);
}
}
}
if (token == null)
{
throw new Exception("Failed to get token");
}
Request authRequest = authService.CreateAuthorizationRequest();
authRequest.Set(TOKEN_ELEMENT, token);
session.SendAuthorizationRequest(authRequest, identity, null);
TimeSpan ts = WAIT_TIME;
for (DateTime startTime = DateTime.UtcNow;
ts.TotalMilliseconds > 0;
ts = ts - (DateTime.UtcNow - startTime))
{
eventObj = session.NextEvent(Convert.ToInt32(ts.TotalMilliseconds));
// Since no other requests were sent using the session queue, the response can
// only be for the Authorization request
if (eventObj.Type != Event.EventType.RESPONSE &&
eventObj.Type != Event.EventType.PARTIAL_RESPONSE &&
eventObj.Type != Event.EventType.REQUEST_STATUS)
{
continue;
}
foreach (Message msg in eventObj)
{
System.Console.WriteLine(msg);
if (msg.MessageType != AUTHORIZATION_SUCCESS)
{
throw new Exception("Authorization Failed");
}
}
return;
}
throw new Exception("Authorization Failed");
}
