Exemple #1
0
        private void initialise()
        {
            Log.logPrefix = "EasyIOI";

            this.iois = new IOIs(this);

            SessionOptions sessionOptions = new SessionOptions();

            sessionOptions.ServerHost = this.host;
            sessionOptions.ServerPort = this.port;

            this.session = new Session(sessionOptions, new EventHandler(processEvent));

            try
            {
                this.session.StartAsync();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }

            while (!this.ready)
            {
                ;
            }
        }
Exemple #2
0
        public string startSession()
        {
            string retval = "";

            retval += "\nStarting session...\n";
            SessionOptions d_sessionOptions = new SessionOptions();

            d_sessionOptions.ServerHost = d_host;
            d_sessionOptions.ServerPort = d_port;
            session = new Session(d_sessionOptions);
            if (!session.Start())
            {
                retval += "\nError: failed to start session.\n";
                return(retval);
            }
            retval += "\nSession started!\n";
            if (!session.OpenService(d_service))
            {
                session.Stop();
                retval += "\nError: failed to open service.\n";
                return(retval);
            }
            service = session.GetService(d_service);
            retval += "\nService opened!\n";
            return(retval);
        }
 public CorrelationExample()
 {
     d_sessionOptions            = new SessionOptions();
     d_sessionOptions.ServerHost = "localhost";
     d_sessionOptions.ServerPort = 8194;
     d_secInfoWindow             = new Window("SecurityInfo");
 }
Exemple #4
0
        /// <summary>
        /// Create and start session.
        /// Open refdata service for reference data requests.
        /// </summary>
        /// <returns></returns>
        private bool startAPISession()
        {
            bool status = false;

            // setup sessionOption
            SessionOptions sessionOptions = new SessionOptions();

            sessionOptions.ServerHost = d_host;
            sessionOptions.ServerPort = d_port;

            // create new session
            d_session = new Session(sessionOptions, new EventHandler(processEvent));
            // start session
            if (!d_session.Start())
            {
                MessageBox.Show("Failed to start session.", "Session");
            }
            else
            {
                // open refdata service
                if (!d_session.OpenService("//blp/refdata"))
                {
                    MessageBox.Show("Failed to open //blp/refdata", "Service");
                }
                else
                {
                    // sucess
                    status = true;
                }
            }
            return(status);
        }
Exemple #5
0
        private void initialise()
        {
            fields     = new SubscriptionFields(this);
            securities = new Securities(this);

            SessionOptions sessionOptions = new SessionOptions();

            sessionOptions.ServerHost = this.host;
            sessionOptions.ServerPort = this.port;

            this.session = new Session(sessionOptions, new EventHandler(processEvent));

            try
            {
                this.session.StartAsync();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }

            while (!this.ready)
            {
                ;
            }
        }
        private void run(string[] args)
        {
            // if only -h was entered for usage return without starting session
            if (!parseCommandLine(args))
            {
                return;
            }

            SessionOptions sessionOptions = new SessionOptions();

            sessionOptions.ServerHost = d_host;
            sessionOptions.ServerPort = d_port;
            System.Console.WriteLine("Connecting to " + d_host + ":" + d_port);

            Session session        = new Session(sessionOptions);
            bool    sessionStarted = session.Start();

            if (!sessionStarted)
            {
                System.Console.WriteLine("Failed to start session.");
                return;
            }

            if (!session.OpenService(REFDATA_SVC))
            {
                System.Console.WriteLine("Failed to open service: " + REFDATA_SVC);
                return;
            }

            Service fieldInfoService = session.GetService(REFDATA_SVC);
            Request request          = fieldInfoService.CreateRequest("HistoricalDataRequest");

            // Add securities to request
            Element securities = request.GetElement("securities");

            for (int i = 0; i < d_securities.Count; ++i)
            {
                securities.AppendValue((string)d_securities[i]);
            }

            // Add fields to request
            Element fields = request.GetElement("fields");

            for (int i = 0; i < d_fields.Count; ++i)
            {
                fields.AppendValue((string)d_fields[i]);
            }

            request.Set("startDate", d_startDate);
            request.Set("endDate", d_endDate);

            System.Console.WriteLine("Sending Request: " + request);
            session.SendRequest(request, null);

            eventLoop(session);

            session.Stop();
        }//end run
        /// <summary>
        /// Establish a Session
        /// Open tasvc Service
        /// Subscribe to securities and fields with overrides specified
        /// Event Loop
        /// </summary>
        /// <param name="args"></param>
        private void run(string[] args)
        {
            d_host = "localhost";
            d_port = 8194;

            if (!parseCommandLine(args))
            {
                return;
            }

            SessionOptions sessionOptions = new SessionOptions();

            sessionOptions.ServerHost = d_host;
            sessionOptions.ServerPort = d_port;

            System.Console.WriteLine("Connecting to " + d_host + ":" + d_port);
            Session session        = new Session(sessionOptions);
            bool    sessionStarted = session.Start();

            if (!sessionStarted)
            {
                System.Console.Error.WriteLine("Failed to start session.");
                return;
            }
            if (!session.OpenService("//blp/tasvc"))
            {
                System.Console.Error.WriteLine("Failed to open //blp/tasvc");
                return;
            }
            sessionOptions.DefaultSubscriptionService = "//blp/tasvc";

            System.Collections.Generic.List <Subscription> subscriptions
                = new System.Collections.Generic.List <Subscription>();

            // Create Technical Analysis WLPR Study Subscription
            Subscription wlprSubscription = createWLPRStudySubscription();

            System.Console.WriteLine("Subscribing to: " + wlprSubscription.SubscriptionString);
            subscriptions.Add(wlprSubscription);

            // Create Technical Analysis MAO Study Subscription
            Subscription maoSubscription = createMAOStudySubscription();

            System.Console.WriteLine("Subscribing to: " + maoSubscription.SubscriptionString);
            subscriptions.Add(maoSubscription);

            // Create Technical Analysis EMAVG Study Subscription
            Subscription emavgSubscription = createEMAVGStudySubscription();

            System.Console.WriteLine("Subscribing to: " + emavgSubscription.SubscriptionString);
            subscriptions.Add(emavgSubscription);

            // NOTE: User must be entitled to receive realtime data for securities subscribed
            session.Subscribe(subscriptions);

            // wait for events from session.
            eventLoop(session);
        }
Exemple #8
0
        private Session CreateSession()
        {
            String authOptions = string.Empty;

            SessionOptions sessionOptions = new SessionOptions();

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

            if (authOption == "APPLICATION")
            {
                // Set Application Authentication Option
                authOptions  = "AuthenticationMode=APPLICATION_ONLY;";
                authOptions += "ApplicationAuthenticationType=APPNAME_AND_KEY;";
                // ApplicationName is the entry in EMRS.
                authOptions += "ApplicationName=" + name;
            }
            else if (authOption == "USER_APP")
            {
                // Set User and Application Authentication Option
                authOptions  = "AuthenticationMode=USER_AND_APPLICATION;";
                authOptions += "AuthenticationType=OS_LOGON;";
                authOptions += "ApplicationAuthenticationType=APPNAME_AND_KEY;";
                // ApplicationName is the entry in EMRS.
                authOptions += "ApplicationName=" + name;
            }
            else if (authOption == "USER_DS_APP")
            {
                // Set User and Application Authentication Option
                authOptions  = "AuthenticationMode=USER_AND_APPLICATION;";
                authOptions += "AuthenticationType=DIRECTORY_SERVICE;";
                authOptions += "DirSvcPropertyName=" + dsName + ";";
                authOptions += "ApplicationAuthenticationType=APPNAME_AND_KEY;";
                // ApplicationName is the entry in EMRS.
                authOptions += "ApplicationName=" + name;
            }
            else if (authOption == "DIRSVC")
            {
                // Authenticate user using active directory service property
                authOptions  = "AuthenticationType=DIRECTORY_SERVICE;";
                authOptions += "DirSvcPropertyName=" + dsName;
            }
            else // default to "LOGON"
            {
                // Authenticate user using windows/unix login name
                authOptions = "AuthenticationType=OS_LOGON";
            }

            System.Console.WriteLine("Authentication Options = " + authOptions);
            sessionOptions.AuthenticationOptions = authOptions;
            System.Console.WriteLine("Connecting to " + serverHost + ":" + serverPort);

            session = new Session(sessionOptions);
            return(session);
        }
        private void run(String[] args)
        {
            SessionOptions d_sessionOptions = new SessionOptions();

            d_sessionOptions.ServerHost = d_host;
            d_sessionOptions.ServerPort = d_port;

            Session session = new Session(d_sessionOptions, new EventHandler(processEvent));

            session.StartAsync();
        }
Exemple #10
0
        public SubscriptionCorrelationExample()
        {
            d_sessionOptions            = new SessionOptions();
            d_sessionOptions.ServerHost = "localhost";
            d_sessionOptions.ServerPort = 8194;

            d_securityList = new List <string>();
            d_securityList.Add("IBM US Equity");
            d_securityList.Add("VOD LN Equity");
            d_gridWindow = new GridWindow("SecurityInfo", d_securityList);
        }
Exemple #11
0
        public Form1()
        {
            InitializeComponent();
            string serverHost = "localhost";
            int    serverPort = 8194;

            // set sesson options
            d_sessionOptions            = new SessionOptions();
            d_sessionOptions.ServerHost = serverHost;
            d_sessionOptions.ServerPort = serverPort;
            // init application
            initUI();
        }
Exemple #12
0
        public bool Connect(string user = "", string dataType = "//blp/refdata")
        {
            if (connected)
            {
                goto finish;
            }

            while (!connected)
            {
                reconnectAttempts++;

                string serverHost = "localhost";
                int    serverPort = 8194;

                SessionOptions sessionOptions = new SessionOptions();
                sessionOptions.ServerHost = serverHost;
                sessionOptions.ServerPort = serverPort;

                Trace.WriteLine("Connecting to Bloomberg " + dataType + ". Attempt " + reconnectAttempts + "/" + maxReconnectAttempts + ".");
                session = new Session(sessionOptions);

                bool sessionStarted = session.Start();

                try
                {
                    session.OpenService(dataType);
                    refDataService = session.GetService(dataType);
                    Trace.WriteLine("Connected to Bloomberg");
                    connected         = true;
                    reconnectAttempts = 0;
                }
                catch
                {
                    Trace.WriteLine("Failed to connect. ");
                    connected = false;
                    if (reconnectAttempts >= maxReconnectAttempts)
                    {
                        Trace.WriteLine("Tried to connect to Bloomberg " + reconnectAttempts + " times.");
                        Trace.WriteLine("Exiting");
                        Environment.Exit(0);
                    }

                    Trace.WriteLine("Waiting for " + reconnectionInterval + "s before retrying to connect.");
                    Thread.Sleep(reconnectionInterval * 1000);
                }
            }

finish:
            return(connected);
        }
Exemple #13
0
        public bool Connect(string user = "", string dataType = "//blp/refdata")
        {
            if (connected)
                goto finish;

            while (!connected)
            {
                reconnectAttempts++;

                string serverHost = "localhost";
                int serverPort = 8194;

                SessionOptions sessionOptions = new SessionOptions();
                sessionOptions.ServerHost = serverHost;
                sessionOptions.ServerPort = serverPort;

                Trace.WriteLine("Connecting to Bloomberg " + dataType +  ". Attempt " + reconnectAttempts + "/" + maxReconnectAttempts +".");
                session = new Session(sessionOptions);

                bool sessionStarted = session.Start();

                try
                {
                    session.OpenService(dataType);
                    refDataService = session.GetService(dataType);
                    Trace.WriteLine("Connected to Bloomberg");
                    connected = true;
                    reconnectAttempts = 0;
                }
                catch
                {
                    Trace.WriteLine("Failed to connect. ");
                    connected = false;
                    if (reconnectAttempts >= maxReconnectAttempts)
                    {
                        Trace.WriteLine("Tried to connect to Bloomberg " + reconnectAttempts + " times.");
                        Trace.WriteLine("Exiting");
                        Environment.Exit(0);
                    }

                    Trace.WriteLine("Waiting for " + reconnectionInterval + "s before retrying to connect.");
                    Thread.Sleep(reconnectionInterval * 1000);

                }
            }

            finish:
            return connected;
        }
Exemple #14
0
        private void run(string[] args)
        {
            d_host = "localhost";
            d_port = 8194;

            if (!parseCommandLine(args))
            {
                return;
            }

            SessionOptions sessionOptions = new SessionOptions();

            sessionOptions.ServerHost = d_host;
            sessionOptions.ServerPort = d_port;

            System.Console.WriteLine("Connecting to " + d_host + ":" + d_port);
            Session session        = new Session(sessionOptions);
            bool    sessionStarted = session.Start();

            if (!sessionStarted)
            {
                System.Console.WriteLine("Failed to start session.");
                return;
            }
            if (!session.OpenService("//blp/tasvc"))
            {
                System.Console.Error.WriteLine("Failed to open //blp/tasvc");
                return;
            }
            Service tasvcService = session.GetService("//blp/tasvc");

            // Create DMI Study Request
            Request dmiStudyRequest = createDMIStudyRequest(tasvcService);

            System.Console.WriteLine("Sending Request: " + dmiStudyRequest);
            session.SendRequest(dmiStudyRequest, null);
            eventLoop(session);

            // Create SMAVG Study Request
            Request smavgStudyRequest = createSMAVGStudyRequest(tasvcService);

            System.Console.WriteLine("Sending Request: " + smavgStudyRequest);
            session.SendRequest(smavgStudyRequest, null);
            eventLoop(session);
        }
        private void createSession()
        {
            SessionOptions options = new SessionOptions();

            options.ServerHost = d_host;
            options.ServerPort = d_port;

            System.Console.WriteLine("Connecting to " + d_host + ":" + d_port);

            d_session = new Session(options, new EventHandler(this.processEvent));
            bool sessionStarted = d_session.Start();

            if (!sessionStarted)
            {
                System.Console.WriteLine("Failed to start session. Exiting...");
                System.Environment.Exit(-1);
            }
        }
Exemple #16
0
        public Form1()
        {
            InitializeComponent();

            string serverHost = "localhost";
            int    serverPort = 8194;

            // set bar fields
            d_fields = new List <Name>();
            Name[] fields = { TIME, OPEN, HIGH, LOW, CLOSE, VOLUME, NUMBER_OF_TICKS };
            d_fields.AddRange(fields);

            d_subscriptions = new List <Subscription>();
            // set sesson options
            d_sessionOptions            = new SessionOptions();
            d_sessionOptions.ServerHost = serverHost;
            d_sessionOptions.ServerPort = serverPort;
            // initialize UI controls
            initUI();
        }
Exemple #17
0
        private void init()
        {
            SessionOptions sessionOptions = new SessionOptions();

            sessionOptions.ServerHost = "localhost";
            sessionOptions.ServerPort = 8194;

            session = new Session(sessionOptions);

            if (!session.Start())
            {
                throw new Exception("OvernightPrices: Failed to start session");
            }

            if (!session.OpenService("//blp/refdata"))
            {
                throw new Exception("OvernightPrices: Failed to open service");
            }

            refDataService = session.GetService("//blp/refdata");
        }
Exemple #18
0
        private void initializeSession()
        {
            if (this.environment == Environment.BETA)
            {
                emsxServiceName = "//blp/emapisvc_beta";
            }
            else if (this.environment == Environment.PRODUCTION)
            {
                emsxServiceName = "//blp/emapisvc";
            }
            sessionOptions = new SessionOptions();

            sessionOptions.ServerHost = this.host;
            sessionOptions.ServerPort = this.port;
            Log.LogMessage(LogLevels.BASIC, "Creating Session for " + this.host + ":" + this.port + " environment:" + environment.ToString());
            this.session = new Session(sessionOptions, new EventHandler(processEvent));
            if (!this.session.Start())
            {
                throw new System.Exception("Unable to start session.");
            }
        }
Exemple #19
0
        /// <summary>
        /// Initialize form controls
        /// </summary>
        private void initUI()
        {
            string serverHost = "localhost";
            int    serverPort = 8194;

            // set sesson options
            d_sessionOptions            = new SessionOptions();
            d_sessionOptions.ServerHost = serverHost;
            d_sessionOptions.ServerPort = serverPort;
            // initialize UI controls

            // add columns to data table
            if (d_data == null)
            {
                d_data = new DataTable();
            }
            d_data.Columns.Add("security");
            d_data.AcceptChanges();

            // add columns to data table
            if (bulkTable == null)
            {
                bulkTable = new DataTable();
            }



            if (d_overRides == null)
            {
                d_overRides = new DataTable();
            }
            d_overRides.Columns.Add("override");
            d_overRides.Columns.Add("value");
            d_overRides.AcceptChanges();

            // set grid data source
            //   dataGridViewData.DataSource = d_data;
        }
        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();
            }
        }
        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);
        }
        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));
                    }
                }
            }
        }
        private void run(String[] args)
        {
            d_serverHost = "localhost";
            d_serverPort = 8194;

            if (!parseCommandLine(args))
            {
                return;
            }

            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);
            bool    sessionStarted = session.Start();

            if (!sessionStarted)
            {
                System.Console.WriteLine("Failed to start session.");
                return;
            }
            if (!session.OpenService(APIFLDS_SVC))
            {
                System.Console.WriteLine("Failed to open service: "
                                         + APIFLDS_SVC);
                return;
            }

            Service fieldInfoService = session.GetService(APIFLDS_SVC);
            Request request          = fieldInfoService.CreateRequest(
                "FieldInfoRequest");
            Element idList = request.GetElement("id");

            request.Append("id", "LAST_PRICE");
            request.Append("id", "pq005");
            request.Append("id", "zz0002");

            request.Set("returnFieldDocumentation", false);

            System.Console.WriteLine("Sending Request: " + request);
            session.SendRequest(request, null);

            while (true)
            {
                try
                {
                    Event eventObj = session.NextEvent();
                    foreach (Message msg in eventObj)
                    {
                        if (eventObj.Type != Event.EventType.RESPONSE &&
                            eventObj.Type != Event.EventType.PARTIAL_RESPONSE)
                        {
                            continue;
                        }

                        Element fields      = msg.GetElement(FIELD_DATA);
                        int     numElements = fields.NumValues;

                        printHeader();
                        for (int i = 0; i < numElements; i++)
                        {
                            printField(fields.GetValueAsElement(i));
                        }
                        System.Console.WriteLine();
                    }
                    if (eventObj.Type == Event.EventType.RESPONSE)
                    {
                        break;
                    }
                }
                catch (Exception ex)
                {
                    System.Console.WriteLine("Got Exception:" + ex);
                }
            }
        }
        private bool createSession()
        {
            if (d_session != null)
            {
                d_session.Stop();
            }

            string authOptions = string.Empty;

            d_sessionOptions = new SessionOptions();

            if (d_authOption == "APPLICATION")
            {
                // Set Application Authentication Option
                authOptions  = "AuthenticationMode=APPLICATION_ONLY;";
                authOptions += "ApplicationAuthenticationType=APPNAME_AND_KEY;";
                // ApplicationName is the entry in EMRS.
                authOptions += "ApplicationName=" + d_name;
            }
            else if (d_authOption == "USER_APP")
            {
                // Set User and Application Authentication Option
                authOptions  = "AuthenticationMode=USER_AND_APPLICATION;";
                authOptions += "AuthenticationType=OS_LOGON;";
                authOptions += "ApplicationAuthenticationType=APPNAME_AND_KEY;";
                // ApplicationName is the entry in EMRS.
                authOptions += "ApplicationName=" + d_name;
            }
            else if (d_authOption == "DIRSVC")
            {
                // Authenticate user using active directory service property
                authOptions  = "AuthenticationType=DIRECTORY_SERVICE;";
                authOptions += "DirSvcPropertyName=" + d_name;
            }
            else if (d_authOption == "NONE")
            {
                // do nothing
            }
            else
            {
                // Authenticate user using windows/unix login name
                authOptions = "AuthenticationType=OS_LOGON";
            }

            System.Console.WriteLine("Authentication Options = " + authOptions);
            d_sessionOptions.AuthenticationOptions = authOptions;

            SessionOptions.ServerAddress[] servers = new SessionOptions.ServerAddress[d_hosts.Count];
            int index = 0;

            System.Console.WriteLine("Connecting to port " + d_port.ToString() + " on host(s):");
            foreach (string host in d_hosts)
            {
                servers[index] = new SessionOptions.ServerAddress(host, d_port);
                System.Console.WriteLine(host);
                index++;
            }

            // auto restart on disconnect
            d_sessionOptions.ServerAddresses            = servers;
            d_sessionOptions.AutoRestartOnDisconnection = true;
            d_sessionOptions.NumStartAttempts           = d_hosts.Count;

            d_session = new Session(d_sessionOptions);
            return(d_session.Start());
        }
        public bool CreateSession()
        {
            const string serverHost = "localhost";
            const int serverPort = 8194;

            // set sesson options
            _sessionOptions = new SessionOptions();
            _sessionOptions.ServerHost = serverHost;
            _sessionOptions.ServerPort = serverPort;

            return OpenSession();
        }
Exemple #26
0
 private void initializeSessionOptions()
 {
     SessionOptions            = new SessionOptions();
     SessionOptions.ServerHost = serverHost;
     SessionOptions.ServerPort = serverPort;
 }
Exemple #27
0
        private void btnStart_Click(object sender, EventArgs e)
        {
            bool result;
            // Create 2 string variables for the security and fields
            String security = tbSymbol.Text;
            String fields = "LAST_PRICE";

            //Initialize lists used
            prices = new List<double>();
            prices.Add(0);
            tickTestsResults = new List<double>();
            tickTestsResults.Add(0);

            // Create an instance of the SessionOptions object to hold the session parameters
            sessionOptions = new SessionOptions();

            // Set the session parameters in the SessionOptions object
            sessionOptions.ServerHost = "localhost";
            sessionOptions.ServerPort = 8194;

            // Create an instance of the Session object, passing the options and processBBEvent to it
            session = new Session(sessionOptions,
                      new Bloomberglp.Blpapi.EventHandler(processBBEvent));

            // Start the Session
            try
            {
                result = session.Start();

                //Display successful connection
                if (result)
                    lblAppStatus.Text = "Connection Successful!";

                // Open up the Market data Service
                result = session.OpenService("//blp/mktdata");

                // Create an instance of the new list of subscriptions
                subscriptions = new List<Subscription>();

                // Add a subscription. Create a new CorrelationID on the fly
                subscriptions.Add(new Subscription(security, fields, "",
                              new Bloomberglp.Blpapi.CorrelationID(security)));

                // Send out the subscriptions
                session.Subscribe(subscriptions);
            }
            catch (Exception ex)
            {
                System.Console.WriteLine("An error has occurred starting the service!");
                lblAppStatus.Text = ("An error has occurred starting the service!");
            }
        }
 private void btnStart_Click(object sender, EventArgs e)
 {
     bool result;
     // Define two string constants for the security and the fields
     // to be read.
     String security = "IBM US Equity";
     String fields = "LAST_PRICE";
     // Instantiate the SessionOptions object to hold the session parameters
     // Note that this was defined at the Form level scope.
     sessionOptions = new SessionOptions();
     // Since this program will run on the same PC as the Bloomberg software,
     //  we use “localhost” as the host name and port 8194 as the default port.
     sessionOptions.ServerHost = "localhost";
     sessionOptions.ServerPort = 8194;
     // Instantiate the Session object using the sessionOptions and
     // a reference to the event handler named processBBEvent
     session = new Session(sessionOptions,
               new Bloomberglp.Blpapi.EventHandler(processBBEvent));
     // Start the Session
     result = session.Start();
     // Open up the Market data Service
     result = session.OpenService("//blp/mktdata");
     // Instantiate the new list of subscriptions
     subscriptions = new List<Subscription>();
     // Get the symbol from tbSymbol text box
     security = tbSymbol.Text;
     // Add a subscription. Create a new CorrelationID on the fly
     subscriptions.Add(new Subscription(security, fields, "",
                       new Bloomberglp.Blpapi.CorrelationID(security)));
     // Kick off the subscriptions
     session.Subscribe(subscriptions);
 }
Exemple #29
0
 public Result startSession()
 {
     string retval = "";
     bool succ = true;
     retval += "\nStarting session...\n";
     SessionOptions d_sessionOptions = new SessionOptions();
     d_sessionOptions.ServerHost = d_host;
     d_sessionOptions.ServerPort = d_port;
     session = new Session(d_sessionOptions);
     if (!session.Start())
     {
         retval += "\nError: failed to start session.\n";
         succ = false;
     }
     else
     {
         retval += "\nSession started!\n";
         if (!session.OpenService(d_service))
         {
             session.Stop();
             retval += "\nError: failed to open service.\n";
             succ = false;
         }
         else
         {
             service = session.GetService(d_service);
             retval += "\nService opened!\n";
         }
     }
     Result result = new Result
     {
         retval = retval, success = succ
     };
     return result;
 }
Exemple #30
0
        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;
                }
            }
        }
Exemple #31
0
        private void run(String[] args)
        {
            d_serverHost = "localhost";
            d_serverPort = 8194;

            if (!parseCommandLine(args))
            {
                return;
            }

            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);
            bool    sessionStarted = session.Start();

            if (!sessionStarted)
            {
                System.Console.WriteLine("Failed to start session.");
                return;
            }
            if (!session.OpenService(APIFLDS_SVC))
            {
                System.Console.WriteLine("Failed to open service: "
                                         + APIFLDS_SVC);
                return;
            }

            Service fieldInfoService = session.GetService(APIFLDS_SVC);
            Request request          = fieldInfoService.CreateRequest(
                "CategorizedFieldSearchRequest");

            request.Set("searchSpec", "last price");
            Element exclude = request.GetElement("exclude");

            exclude.SetElement("fieldType", "Static");
            request.Set("returnFieldDocumentation", false);

            System.Console.WriteLine("Sending Request: " + request);
            session.SendRequest(request, null);

            while (true)
            {
                try
                {
                    Event eventObj = session.NextEvent();
                    foreach (Message msg in eventObj)
                    {
                        if (eventObj.Type != Event.EventType.RESPONSE &&
                            eventObj.Type != Event.EventType.PARTIAL_RESPONSE)
                        {
                            continue;
                        }
                        if (msg.HasElement(FIELD_SEARCH_ERROR))
                        {
                            System.Console.WriteLine(msg);
                            continue;
                        }

                        Element categories    = msg.GetElement(CATEGORY);
                        int     numCategories = categories.NumValues;

                        for (int catIdx = 0; catIdx < numCategories; ++catIdx)
                        {
                            Element category = categories.GetValueAsElement(catIdx);
                            String  Name     = category.GetElementAsString(
                                CATEGORY_NAME);
                            String Id = category.GetElementAsString(CATEGORY_ID);

                            System.Console.WriteLine("\n  Category Name:" +
                                                     padString(Name, CAT_NAME_LEN) +
                                                     "\tId:" + Id);

                            Element fields      = category.GetElement(FIELD_DATA);
                            int     numElements = fields.NumValues;

                            printHeader();
                            for (int i = 0; i < numElements; i++)
                            {
                                printField(fields.GetValueAsElement(i));
                            }
                        }
                        System.Console.WriteLine();
                    }
                    if (eventObj.Type == Event.EventType.RESPONSE)
                    {
                        break;
                    }
                }

                catch (Exception ex)
                {
                    System.Console.WriteLine("Got Exception:" + ex);
                }
            }
        }
 public string startSession()
 {
     string retval = "";
     retval += "\nStarting session...\n";
     SessionOptions d_sessionOptions = new SessionOptions();
     d_sessionOptions.ServerHost = d_host;
     d_sessionOptions.ServerPort = d_port;
     session = new Session(d_sessionOptions);
     if (!session.Start())
     {
         retval += "\nError: failed to start session.\n";
         return retval;
     }
     retval += "\nSession started!\n";
     if (!session.OpenService(d_service))
     {
         session.Stop();
         retval += "\nError: failed to open service.\n";
         return retval;
     }
     service = session.GetService(d_service);
     retval += "\nService opened!\n";
     return retval;
 }
Exemple #33
0
        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);
        }