/*****************************************************************************
    *  Function    : createSession
    *  Description : This function creates a session object and opens the market
    *               bar service.  Returns false on failure of either.
    *  Arguments   : none
    *  Returns     : bool
    *****************************************************************************/
    private bool createSession()
    {
        if (d_session != null)
        {
            d_session.Stop();
        }

        System.Console.WriteLine("Connecting to " + d_sessionOptions.ServerHost +
                                 ":" + d_sessionOptions.ServerPort);
        d_session = new Session(d_sessionOptions, new EventHandler(processEvent));
        if (!d_session.Start())
        {
            System.Console.WriteLine("Failed to start session");
            return(false);
        }
        System.Console.WriteLine("Connected successfully\n");

        if (!d_session.OpenService("//blp/mktbar"))
        {
            System.Console.WriteLine("Failed to open service //blp/mktbar");
            d_session.Stop();
            return(false);
        }

        System.Console.WriteLine("Subscribing...");
        d_session.Subscribe(d_subscriptions);

        return(true);
    }
Example #2
0
        /// <summary>
        /// Initialises the specified URI session and opens the service.
        /// </summary>
        /// <param name="uri">The URI.</param>
        /// <returns></returns>
        private bool Initialise(string uri, int requestCount)
        {
            sessionOptions            = new BB.SessionOptions();
            sessionOptions.ServerHost = "localhost";
            sessionOptions.ServerPort = 8194;
            if (requestCount > sessionOptions.MaxPendingRequests)
            {
                sessionOptions.MaxPendingRequests = requestCount;
            }

            UpdateStatus("Starting the Bloomberg session.");
            session = new BB.Session(sessionOptions, new BB.EventHandler(processEvent));

            if (session.Start())
            {
                if (!session.OpenService(uri))
                {
                    throw new Exception("Bloomberg failed to open session " + uri);
                }
                return(true);
            }
            else
            {
                throw new Exception("An error occurred starting the Bloomberg session. Ensure Bloomberg is installed.");
            }
        }
Example #3
0
 /// <summary>
 /// Initializes the SecurityLookup instance by creating a session and authorizing it so that its
 /// ready to conduct searches. Once initialized multiple searches may be conducted with the same instance.
 /// </summary>
 public void Init()
 {
     try
     {
         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);
         session = new Session(sessionOptions);
         if (!session.Start())
         {
             throw new Exception("Failed to start session");
         }
         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));
         }
     }
     catch (Exception e)
     {
         Console.WriteLine(string.Format("Exception: {0}", e.Message));
         Console.WriteLine();
     }
 }
Example #4
0
    /*****************************************************************************
    *  Function    : IsBPipeAuthorized
    *  Description : This function authorize the token. A valid Identiy will contain
    *             the user/application credentials on authorization success.
    *             Returns false on failure.
    *  Arguments   : token string from GenerateToken(), reference to Identity
    *  Returns     : bool
    *****************************************************************************/
    private bool IsBPipeAuthorized(string token, out Identity identity)
    {
        bool isAuthorized = false;
        bool isRunning    = true;

        identity = null;

        if (!d_session.OpenService(AUTH_SVC))
        {
            System.Console.Error.WriteLine("Failed to open " + AUTH_SVC);
            return(isAuthorized = false);
        }
        Service authService = d_session.GetService(AUTH_SVC);


        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("Authorization SUCCESS");

                        isAuthorized = true;
                        isRunning    = false;
                        break;
                    }
                    else if (msg.MessageType == AUTHORIZATION_FAILURE)
                    {
                        System.Console.WriteLine("Authorization FAILED");
                        System.Console.WriteLine(msg);
                        isRunning = false;
                    }
                    else
                    {
                        System.Console.WriteLine(msg);
                    }
                }
            }
        }
        return(isAuthorized);
    }
Example #5
0
        public void Connect()
        {
            string serverHost = "api.bloomberg.com";
            int    serverPort = 0;

            SessionOptions sessionOptions = new SessionOptions();

            sessionOptions.ServerHost = serverHost;
            sessionOptions.ServerPort = serverPort;

            Log("Connecting to " + serverHost + ":" + serverPort);
            session = new Session(sessionOptions);
            bool sessionStarted = session.Start();

            if (!sessionStarted)
            {
                throw new Exception("Failed to start Bloomberg API session.");
            }
            if (!session.OpenService("//blp/refdata"))
            {
                throw new Exception("Failed to open //blp/refdata");
            }
            this.service = session.GetService("//blp/refdata");
        }
        /// <summary>
        /// Sets config and other session data to create the session
        /// </summary>
        /// <returns></returns>
        private Session CreateBloombergSession()
        {
            // retrieves the appsettings and fills the config object
            config = new BloombergApiSessionConfig();

            var sessionOptions = new SessionOptions { ServerHost = config.BbHost, ServerPort = config.BbPort };
            var session = new Session(sessionOptions);

            if (!session.Start())
            {
                //_Logging.Error("Unable to initiate Bloomberg session.");
                return null;
            }

            if (!session.OpenService(config.BbService))
            {
                //_Logging.Error("Unable to open Bloomberg service.");
                return null;
            }
            return session;
        }
Example #7
0
        /// <summary>
        /// Authorize should be called before any requests are sent. Called by init.
        /// </summary>
        /// <param name="identity"></param>
        /// <param name="session"></param>
        private 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");
        }