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"); }