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 bool GenerateApplicationToken(out string token)
{
bool isTokenSuccess = false;
bool isRunning = false;
token = string.Empty;
CorrelationID tokenReqId = new CorrelationID(99);
EventQueue tokenEventQueue = new EventQueue();
System.Console.WriteLine("Application token generation");
d_session.GenerateToken(tokenReqId, tokenEventQueue);
while (!isRunning)
{
Event eventObj = tokenEventQueue.NextEvent();
if (eventObj.Type == Event.EventType.TOKEN_STATUS)
{
System.Console.WriteLine("processTokenEvents");
foreach (Message msg in eventObj)
{
System.Console.WriteLine(msg.ToString());
if (msg.MessageType == TOKEN_SUCCESS)
{
token = msg.GetElementAsString("token");
System.Console.WriteLine("Application token sucess");
isTokenSuccess = true;
isRunning = true;
break;
}
else if (msg.MessageType == TOKEN_FAILURE)
{
System.Console.WriteLine("Application token failure");
isRunning = true;
break;
}
else
{
System.Console.WriteLine("Error while application token generation");
isRunning = true;
break;
}
}
}
}
return(isTokenSuccess);
}
private bool GenerateToken()
{
bool isTokenSuccess = false;
bool isRunning = false;
CorrelationID tokenReqId = new CorrelationID(99);
EventQueue tokenEventQueue = new EventQueue();
session.GenerateToken(tokenReqId, tokenEventQueue);
while (!isRunning)
{
Event eventObj = tokenEventQueue.NextEvent();
if (eventObj.Type == Event.EventType.TOKEN_STATUS)
{
System.Console.WriteLine("processTokenEvents");
foreach (Message msg in eventObj)
{
System.Console.WriteLine(msg.ToString());
if (msg.MessageType == TOKEN_SUCCESS)
{
isTokenSuccess = true;
isRunning = true;
break;
}
else if (msg.MessageType == TOKEN_FAILURE)
{
Console.WriteLine("Received : " + TOKEN_FAILURE.ToString());
isRunning = true;
break;
}
else
{
Console.WriteLine("Error while Token Generation");
isRunning = true;
break;
}
}
}
}
return(isTokenSuccess);
}
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 eventLoop(EventQueue evtQueue, Session session)
{
bool done = false;
while (!done)
{
Event eventObj = evtQueue.NextEvent();
if (eventObj.Type == Event.EventType.PARTIAL_RESPONSE)
{
System.Console.WriteLine("Processing Partial Response");
processResponseEvent(eventObj);
}
else if (eventObj.Type == Event.EventType.RESPONSE)
{
System.Console.WriteLine("Processing Response");
processResponseEvent(eventObj);
done = true;
}
}
}
private void run(String[] args)
{
if (!parseCommandLine(args))
{
return;
}
// create session
if (!createSession())
{
System.Console.WriteLine("Fail to open session");
return;
}
if (d_authOption != "NONE")
{
// Authenticate user using Generate Token Request
if (!GenerateToken(out d_token))
{
return;
}
//Authorization : pass Token into authorization request. Returns User handle with user's entitlements info set by server.
if (!IsBPipeAuthorized(d_token, out d_identity))
{
return;
}
}
if (!d_session.OpenService(MKTDATA_SVC))
{
System.Console.Error.WriteLine("Failed to open " + MKTDATA_SVC);
return;
}
if (!d_session.OpenService(REFDATA_SVC))
{
System.Console.Error.WriteLine("Failed to open " + REFDATA_SVC);
return;
}
Subscription s = new Subscription("IBM US Equity", "LAST_PRICE", "");
List <Subscription> subscriptions = new List <Subscription>();
subscriptions.Add(s);
if (d_authOption != "NONE")
{
System.Console.WriteLine("Subscribing to IBM US Equity with Identity object");
d_session.Subscribe(subscriptions, d_identity);
}
else
{
System.Console.WriteLine("Subscribing to IBM US Equity");
d_session.Subscribe(subscriptions);
}
Service refDataService = d_session.GetService("//blp/refdata");
Request request = refDataService.CreateRequest("ReferenceDataRequest");
request.GetElement("securities").AppendValue("IBM US Equity");
request.GetElement("fields").AppendValue("DS002");
EventQueue eventQueue = new EventQueue();
if (d_authOption != "NONE")
{
System.Console.WriteLine("Requesting reference data IBM US Equity with Identity object");
d_session.SendRequest(request, d_identity, eventQueue, null);
}
else
{
System.Console.WriteLine("Requesting reference data IBM US Equity");
d_session.SendRequest(request, eventQueue, null);
}
while (true)
{
Event eventObj = eventQueue.NextEvent();
foreach (Message msg in eventObj)
{
System.Console.WriteLine(msg);
}
if (eventObj.Type == Event.EventType.RESPONSE)
{
break;
}
}
}
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)
{
String serverHost = "localhost";
int serverPort = 8194;
SessionOptions sessionOptions = new SessionOptions();
sessionOptions.ServerHost = serverHost;
sessionOptions.ServerPort = serverPort;
System.Console.WriteLine("Connecting to " + serverHost + ":" + serverPort);
Session session = new Session(sessionOptions,
new EventHandler(processEvent));
if (!session.Start())
{
System.Console.Error.WriteLine("Failed to start session.");
return;
}
if (!session.OpenService("//blp/mktdata"))
{
System.Console.Error.WriteLine("Failed to open //blp/mktdata");
return;
}
if (!session.OpenService("//blp/refdata"))
{
System.Console.Error.WriteLine("Failed to open //blp/refdata");
return;
}
System.Console.WriteLine("Subscribing to IBM US Equity");
Subscription s = new Subscription("IBM US Equity", "LAST_PRICE", "");
List <Subscription> subscriptions = new List <Subscription>();
subscriptions.Add(s);
session.Subscribe(subscriptions);
System.Console.WriteLine("Requesting reference data IBM US Equity");
Service refDataService = session.GetService("//blp/refdata");
Request request = refDataService.CreateRequest("ReferenceDataRequest");
request.GetElement("securities").AppendValue("IBM US Equity");
request.GetElement("fields").AppendValue("DS002");
EventQueue eventQueue = new EventQueue();
session.SendRequest(request, eventQueue, null);
while (true)
{
Event eventObj = eventQueue.NextEvent();
foreach (Message msg in eventObj)
{
System.Console.WriteLine(msg);
}
if (eventObj.Type == Event.EventType.RESPONSE)
{
break;
}
}
}
private void run(String[] args)
{
if (!parseCommandLine(args))
{
printUsage();
System.Environment.Exit(-1);
}
SessionOptions sessionOptions = new SessionOptions();
sessionOptions.ServerHost = d_serverHost;
sessionOptions.ServerPort = d_serverPort;
System.Console.WriteLine("Connecting to " + d_serverHost + ":"
+ d_serverPort);
Session session = new Session(sessionOptions);
if (!session.Start())
{
System.Console.WriteLine("Failed to start session.");
return;
}
if (!session.OpenService(API_AUTH_SVC_NAME))
{
System.Console.WriteLine("Failed to open service: " + API_AUTH_SVC_NAME);
System.Environment.Exit(-1);
}
Service apiAuthSvc = session.GetService(API_AUTH_SVC_NAME);
EventQueue eventQueue = new EventQueue();
CorrelationID correlator = new CorrelationID(10);
Request request = apiAuthSvc.CreateRequest("SecurityEntitlementsRequest");
Element securities = request.GetElement("securities");
for (int i = 0; i < d_securities.Count; ++i)
{
securities.AppendValue(d_securities[i]);
}
session.SendRequest(request, eventQueue, correlator);
Event eventObj = eventQueue.NextEvent(5000 * 60);
if (eventObj.Type == Event.EventType.RESPONSE ||
eventObj.Type == Event.EventType.REQUEST_STATUS)
{
foreach (Message msg in eventObj)
{
if (msg.MessageType.Equals(SECURITYENTITLEMENTS_RESPONSE))
{
Element eidData = msg.GetElement("eidData");
if (eidData.NumValues == 0)
{
printEvent(eventObj);
}
else
{
for (int i = 0; i < eidData.NumValues; ++i)
{
Element item = eidData.GetValueAsElement(i);
int status = item.GetElementAsInt32("status");
System.Console.Write((String)d_securities[i] + "\t:\t");
if (0 == status)
{
Element eids = item.GetElement("eids");
for (int j = 0; j < eids.NumValues; ++j)
{
System.Console.Write(eids.GetValueAsInt32(j) + " ");
}
}
else
{ // anything nonzero, means we failed to retrieve eids for security
System.Console.Write("Failed (" + status + ")");
}
System.Console.WriteLine();
}
session.Cancel(correlator);
}
}
}
}
else
{
printEvent(eventObj);
}
session.Cancel(correlator);
}
// 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");
}
/// <summary>
/// Get security data
/// </summary>
private void getData()
{
// get reference data service
if (d_service == null)
{
d_service = d_session.GetService("//blp/refdata");
}
// create reference data request
Request request = d_service.CreateRequest("ReferenceDataRequest");
// set security
request.GetElement("securities").AppendValue(textBoxSecurity.Text.ToUpper().Trim() + " Mtge");
// set fields
Element fields = request.GetElement("fields");
fields.AppendValue("MTG_PL_CPR_1M");
fields.AppendValue("MTG_CDR_1M");
fields.AppendValue("MTG_VPR_1M");
fields.AppendValue("MTG_SEV_1M");
fields.AppendValue("CREDIT_MODELED_INDICATOR");
fields.AppendValue("MTG_AMT_OUT_FACE");
fields.AppendValue("MTG_FACTOR");
fields.AppendValue("CPN");
fields.AppendValue("MTG_TRANCHE_TYP_LONG");
fields.AppendValue("RTG_SP_INITIAL");
fields.AppendValue("RTG_SP");
fields.AppendValue("RTG_MDY_INITIAL");
fields.AppendValue("RTG_MOODY");
fields.AppendValue("ORIG_CREDIT_SUPPORT");
fields.AppendValue("CURR_CREDIT_SUPPORT");
fields.AppendValue("CREDIT_SUPPORT_COVERAGE");
fields.AppendValue("COLLAT_TYP");
fields.AppendValue("MTG_POOL_FACTOR");
fields.AppendValue("MTG_NUM_POOLS");
fields.AppendValue("MTG_WACPN");
fields.AppendValue("MTG_WHLN_WALA");
fields.AppendValue("MTG_WHLN_30DLQ");
fields.AppendValue("MTG_WHLN_60DLQ");
fields.AppendValue("MTG_WHLN_90DLQ");
fields.AppendValue("BANKRUPT_PCT");
fields.AppendValue("MTG_WHLN_FCLS");
fields.AppendValue("MTG_WHLN_REO");
fields.AppendValue("MTG_DELQ_60PLUS_CUR");
fields.AppendValue("MTG_DELQ_90PLUS_CUR");
fields.AppendValue("CURR_CUM_LOSS_AMT");
// create event queue for synchronus request
EventQueue eventQueue = new EventQueue();
// send request
d_session.SendRequest(request, eventQueue, null);
// wait for data to come back
while (true)
{
Event eventObj = eventQueue.NextEvent();
// process data
foreach (Message msg in eventObj)
{
// check for request error
if (msg.HasElement(RESPONSE_ERROR))
{
MessageBox.Show("REQUEST FAILED: " +
msg.GetElement(RESPONSE_ERROR).ToString(), "Request Error");
continue;
}
// get securities
Element securities = msg.GetElement(SECURITY_DATA);
int numSecurities = securities.NumValues;
for (int i = 0; i < numSecurities; ++i)
{
// get security
Element security = securities.GetValueAsElement(i);
string ticker = security.GetElementAsString(SECURITY);
// check for security error
if (security.HasElement("securityError"))
{
MessageBox.Show("SECURITY FAILED: " +
security.GetElement(SECURITY_ERROR).ToString(), "Security Error");
continue;
}
// get fields
Element returnFields = security.GetElement(FIELD_DATA);
if (returnFields.NumElements > 0)
{
// get number of fields returned
int numElements = returnFields.NumElements;
for (int j = 0; j < numElements; ++j)
{
// get field
Element field = returnFields.GetElement(j);
// populate textbox on Data tab
populateTextBox(tabPageData, field.Name.ToString(), field.GetValueAsString());
}
}
}
}
if (eventObj.Type == Event.EventType.RESPONSE)
{
// all the data came back for this request
break;
}
}
}
private void run(String[] args)
{
if (!parseCommandLine(args))
{
printUsage();
System.Console.Read();
System.Environment.Exit(-1);
}
SessionOptions sessionOptions = new SessionOptions();
sessionOptions.ServerHost = d_serverHost;
sessionOptions.ServerPort = d_serverPort;
System.Console.WriteLine("Connecting to " + d_serverHost + ":"
+ d_serverPort);
Session session = new Session(sessionOptions);
if (!session.Start())
{
System.Console.WriteLine("Failed to start session.");
return;
}
if (!session.OpenService(API_AUTH_SVC_NAME))
{
System.Console.WriteLine("Failed to open service: " + API_AUTH_SVC_NAME);
System.Environment.Exit(-1);
}
Service apiAuthSvc = session.GetService(API_AUTH_SVC_NAME);
EventQueue eventQueue = new EventQueue();
CorrelationID correlator = new CorrelationID(10);
Request request = apiAuthSvc.CreateRequest("UserEntitlementsRequest");
Element userinfo = request.GetElement("userInfo");
userinfo.SetElement("uuid", d_uuid);
session.SendRequest(request, eventQueue, correlator);
Event eventObj = eventQueue.NextEvent(5000 * 60);
if (eventObj.Type == Event.EventType.RESPONSE ||
eventObj.Type == Event.EventType.REQUEST_STATUS)
{
foreach (Message msg in eventObj)
{
if (msg.MessageType.Equals(USERENTITLEMENTS_RESPONSE))
{
Element returnedEids = msg.GetElement("eids");
int numeids = returnedEids.NumValues;
if (numeids == 0)
{
System.Console.WriteLine("No EIDs returned for user " + d_uuid);
}
else
{
if (d_eids.Count == 0)
{
printEvent(eventObj);
}
else
{
for (int i = 0; i < d_eids.Count; i++)
{
int eid_to_verify = d_eids[i];
bool found = false;
for (int j = 0; j < numeids; j++)
{
if (returnedEids.GetValueAsInt32(j) == eid_to_verify)
{
found = true;
break;
}
}
if (found == true)
{
System.Console.WriteLine("User " + d_uuid +
" is entitled for "
+ eid_to_verify);
}
else
{
System.Console.WriteLine("User " + d_uuid +
" is NOT entitled for "
+ eid_to_verify);
}
}
}
}
}
else
{
printEvent(eventObj);
}
}
}
else
{
printEvent(eventObj);
}
session.Cancel(correlator);
}
