Exemplo n.º 1
0
        /// <summary>
        /// The CreateMessage method creates a new instance of
        /// a specific FIX message in accordance with the message
        /// definition in the dictionaries associated with the
        /// specified FIX application layer version. The message
        /// that is created by this implementation of the method
        /// will also include a populated header and trailer that
        /// conforms to the header and trailer definition found in
        /// the specified session layer FIX version.
        /// </summary>
        /// <param name="sxVersion">
        /// The session layer version of the FIX protocol that will
        /// be used to locate message definitions for the message that
        /// is to be created.
        /// </param>
        /// <param name="axVersion">
        /// The application layer version of the FIX protocol that
        /// will be used to locate the message definition for the
        /// message that is to be created.
        /// </param>
        /// <param name="msgType">
        /// The FIX message type of the message to create.
        /// </param>
        /// <returns>
        /// The resulting instance of a FIX message.
        /// </returns>
        public FixMessage CreateMessage(string sxVersion, string axVersion, string msgType)
        {
            FixMessage result = new FixMessage();

            // REC: Determine if the MsgType field has already
            // been defined and maintain a reference so that it
            // can be restored after this is done:
            FixField fldMsgType = GetField(35);

            // REC: Assign the specified MsgType to the internal
            // field map so that it gets substituted:
            SetField(new FixField(35, msgType));

            PopulateHdrElements(sxVersion, result);
            PopulateMsgElements(axVersion, msgType, result);
            PopulateTrlElements(sxVersion, result);

            // REC: Restore the previous value for the
            // message type, if one was present:
            if (fldMsgType != null)
            {
                SetField(fldMsgType);
            }
            else
            {
                // REC: The MsgType field was not present before
                // this call was made, so remove it:
                RemoveField(35);
            }


            return(result);
        }
Exemplo n.º 2
0
        /// <summary>
        /// The HandleSession_TestRequest method is invoked to
        /// handle a test request that has been received from the
        /// peer that the session is interacting with.
        /// </summary>
        /// <param name="msg">
        /// The FIX test request received from the peer.
        /// </param>
        private void HandleSession_TestRequest(FixMessage msg)
        {
            if (_currentState == SessionStates.Session_Opened)
            {
                // REC: Dispatch the administrative message to the
                // session's callback handler:
                _handler.OnSessionRxAdmMessage(this, msg);

                // REC: Construct a response message to the test
                // request and dispatch it to the peer:
                FixMessage msgResponse = _fixAssembler.CreateMessage(_sxVersion, _axVersion, "0");
                if (msgResponse != null)
                {
                    // REC: Retrieve the test request token from
                    // the incoming request and assign it to the
                    // outbound response message:
                    FixField fldTestReqID = msg.GetField(112);
                    if (fldTestReqID != null)
                    {
                        if (!string.IsNullOrEmpty(fldTestReqID.Content))
                        {
                            msgResponse.AddField(new FixField(112, fldTestReqID.Content));
                        }
                    }

                    Dispatch_AdmMessage(msgResponse);
                }
            }
            else
            {
            }
        }
Exemplo n.º 3
0
        public void OnSessionLogout(IVfxFixAppSession session, FixMessage msg)
        {
            FixField fixSCID = msg.Header.GetField(49);
            FixField fixTCID = msg.Header.GetField(56);

            Console.WriteLine(string.Format("FIX SERVER: {0} - LOGOUT.", fixSCID.Content));
        }
Exemplo n.º 4
0
        public void OnSessionLogon(IVfxFixAppSession session, FixMessage msg)
        {
            FixField fixSCID = msg.Header.GetField(49);
            FixField fixTCID = msg.Header.GetField(56);

            Console.WriteLine(string.Format("FIX CLIENT: {0} - LOGON", fixSCID.Content));
            System.Threading.ThreadPool.QueueUserWorkItem(HandleWork_SendMessages, session);
        }
Exemplo n.º 5
0
        /// <summary>
        /// The GetField method retrieves an instance of a field that
        /// has been configured in the assembler instance.
        /// </summary>
        /// <param name="tag">
        /// The FIX tag of the field to retrieve.
        /// </param>
        /// <returns>
        /// The instance of the FIX field that corresponds to the
        /// supplied tag, or null if there is no match.
        /// </returns>
        public FixField GetField(int tag)
        {
            FixField result = null;

            if (_mapFields.ContainsKey(tag))
            {
                result = _mapFields[tag];
            }
            return(result);
        }
Exemplo n.º 6
0
        // REC: The PopulateQueue method is a recursive function
        // that loads all of the elements in a FixCollection into
        // an instance of a SrcField queue so that the validator
        // can then process all the elements sequentially:
        private void PopulateQueue(Queue <SrcField> queue, FixCollection elements)
        {
            foreach (IFixElement element in elements)
            {
                if (element is FixField)
                {
                    FixField msgField = element as FixField;
                    if (msgField != null)
                    {
                        // REC: Attempt to resolve the field's name
                        // by retrieving it using it's tag:
                        string fieldName = ResolveFieldName(msgField.Tag.ToString());
                        if (fieldName == null)
                        {
                            fieldName = "Unresolved";
                        }

                        // REC: Create a new instance of SrcField that
                        // represents the contents of this field:
                        SrcField srcField = new SrcField();
                        srcField.Tag   = msgField.Tag.ToString();
                        srcField.Name  = fieldName;
                        srcField.Value = msgField.Content;

                        queue.Enqueue(srcField);
                    }
                }
                else if (element is FixGroup)
                {
                    FixGroup msgGroup = element as FixGroup;
                    if (msgGroup != null)
                    {
                        string groupName = ResolveFieldName(msgGroup.Tag.ToString());
                        if (groupName == null)
                        {
                            groupName = "Unresolved";
                        }

                        // REC: Create a new instance of SrcField that
                        // represents the contents of the group:
                        SrcField srcField = new SrcField();
                        srcField.Tag   = msgGroup.Tag.ToString();
                        srcField.Name  = groupName;
                        srcField.Value = msgGroup.Content;

                        queue.Enqueue(srcField);

                        foreach (FixCollection instance in msgGroup.Instances)
                        {
                            PopulateQueue(queue, instance);
                        }
                    }
                }
            }
        }
Exemplo n.º 7
0
 /// <summary>
 /// The SetField method registers an instance of a field with
 /// the assembler. The assembler will use this field whenever
 /// it constructs a message that contains the field's tag.
 /// </summary>
 /// <param name="field">
 /// The FIX field to register with the assembler.
 /// </param>
 public void SetField(FixField field)
 {
     if (!_mapFields.ContainsKey(field.Tag))
     {
         _mapFields.Add(field.Tag, field);
     }
     else
     {
         _mapFields[field.Tag] = field;
     }
 }
Exemplo n.º 8
0
        /// <summary>
        /// Updates the FIX value within the input FIX fields for the currently selected strategy.
        /// </summary>
        /// <param name="fixTag">FIX tag whose value is to be updated.</param>
        /// <param name="value">New value for the FIX tag being updated.</param>
        /// <remarks>This method is used to update FIX tag values that are used within StrategyEdits using the FIX_
        /// mechanism.  Controls that are initialized using the FIX_ mechanism and parameter values within strategies
        /// are unaffected when invoking this method.</remarks>
        public void UpdateFixValue(FixField fixTag, string value)
        {
            if (InputFixValues == null)
            {
                return;
            }

            InputFixValues[fixTag] = value;

            if (ViewModel != null)
            {
                ViewModel.EvaluateAffectedStrategyEdits(this, fixTag);
            }
        }
        /// <summary>
        /// Evaluates all the underlying <see cref="StrategyEdit_t"/>s and notifies any interested parties of change
        /// of state.
        /// </summary>
        /// <param name="inputValueProvider">Provider that providers access to any additional FIX field values that may
        /// be required in the Edit evaluation.</param>
        /// <returns>Summary state of all StrategyEdits after the evaluation.</returns>
        public bool EvaluateAffected(FixFieldValueProvider inputValueProvider, FixField fixField)
        {
            bool overallState = true;

            foreach (StrategyEditViewModel strategyEdit in this)
            {
                if (strategyEdit.Sources.Contains(Enum.GetName(typeof(FixField), fixField)))
                {
                    overallState &= strategyEdit.Evaluate(inputValueProvider);
                }
            }

            return(overallState);
        }
Exemplo n.º 10
0
        /// <summary>
        /// The HandleSession_Logon method is invoked to handle
        /// a logon message that has been received from the peer
        /// session that this session is communicating with.
        /// </summary>
        /// <param name="msg">
        /// The FIX logon message received from the peer.
        /// </param>
        private void HandleSession_Logon(FixMessage msg)
        {
            // REC: Ensure that we're in the appropriate state
            // to handle a logon message:
            if (_currentState == SessionStates.Session_Pending || _currentState == SessionStates.Session_Closed)
            {
                // REC: Retrieve the FIX SenderCompID of the peer
                // from the logon message:
                FixField fldSenderCompID = msg.Header.GetField(49);
                if (fldSenderCompID != null)
                {
                    string rxSenderCompID = fldSenderCompID.Content;
                    if (string.IsNullOrEmpty(rxSenderCompID))
                    {
                        // HELP: Should the session send a reject message
                        // in this case, given that the peer didn't send
                        // its FIX SenderCompID, or should this throw an
                        // argument exception?
                    }

                    // REC: Transition to the opened state:
                    _currentState = SessionStates.Session_Opened;

                    // REC: Notify the session's owner that the session
                    // has received the logon response from the server:
                    _handler.OnSessionLogon(this, msg);
                }
                else
                {
                    // REC: Throw an exception since the session has not
                    // yet been established and there will be no handler
                    // at the application level that can deal with this:
                    throw new ArgumentException("Logon message missing required field - SenderCompID.");
                }
            }
            else
            {
                // REC: Notify the session handler that an
                // administrative message has been received
                // from the peer session:
                _handler.OnSessionRxAdmMessage(this, msg);

                // REC: Throw an exception that indicates the
                // session is not in the appropriate state to
                // handle the received message:
                throw new InvalidOperationException("Session state invalid for received message.");
            }
        }
Exemplo n.º 11
0
        /// <summary>
        /// The AddMessage_Entrypoint method is the asynchronous
        /// entrypoint for processing add message requests that have
        /// been enqueued to the .NET thread pool through the instance
        /// of the sequencer that is associated with the database.
        /// </summary>
        /// <param name="state">
        /// The instance of TaskDetails_Add that is associated with
        /// the asynchronous add message request being processed.
        /// </param>
        private void AddMessage_Entrypoint(object state)
        {
            TaskDetails_Add taskDetails = state as TaskDetails_Add;

            if (taskDetails != null)
            {
                FixField fldSequence = taskDetails.SessionMsg.Header.GetField(34);
                if (fldSequence != null)
                {
                    // REC: Retrieve the message's text so that its
                    // length can be assigned to its index entry:
                    string msgText = taskDetails.SessionMsg.ToString();

                    // REC: Create an entry for the message in the
                    // index file associated with the session:
                    if (_mapSessions.ContainsKey(taskDetails.SessionId))
                    {
                        SessionDetails details = _mapSessions[taskDetails.SessionId];

                        IndexEntry idxEntry = new IndexEntry();
                        idxEntry.msgOffset   = details.MsgWriter.BaseStream.Position;
                        idxEntry.msgLength   = msgText.Length;
                        idxEntry.msgSequence = int.Parse(fldSequence.Content);

                        details.Index.Add(idxEntry);

                        details.MsgWriter.Write(msgText.ToCharArray());
                        details.MsgWriter.Flush();

                        string idxLine = string.Format("{0}:{1}:{2}", idxEntry.msgSequence, idxEntry.msgOffset, idxEntry.msgLength);
                        details.IdxWriter.WriteLine(idxLine.ToCharArray());
                        details.IdxWriter.Flush();
                    }
                }
            }
        }
Exemplo n.º 12
0
        /// <summary>
        /// Evaluates all strategy edits within the currently selected strategy.
        /// </summary>
        /// <param name="inputValueProvider">Provider that providers access to any additional FIX field values that may
        /// be required in the Edit evaluation.</param>
        /// <returns>Summary state of all StrategyEdits after the evaluation.</returns>
        public bool EvaluateAffectedStrategyEdits(IInitialFixValueProvider inputValueProvider, FixField updatedField)
        {
            FixFieldValueProvider additionalValues = inputValueProvider == null ?
                                                     FixFieldValueProvider.Empty : new FixFieldValueProvider(inputValueProvider, _underlyingStrategy.Parameters);

            bool result = StrategyEdits.EvaluateAffected(additionalValues, updatedField);

            foreach (ControlViewModel control in Controls)
            {
                control.OnValueChangeCompleted();
            }

            return(result);
        }
Exemplo n.º 13
0
        /// <summary>
        /// The HandleRxMessage method is invoked by the owner of an
        /// instance of a session to inform it that data has arrived
        /// from the peer system.
        /// </summary>
        /// <param name="mb">
        /// The message block that contains the data received from
        /// the peer system the session is communicating with.
        /// </param>
        public void HandleRxMessage(VfxEngine.Ipc.VfxMsgBlock mb)
        {
            string             content = Encoding.ASCII.GetString(mb.Buffer, 0, mb.Length());
            VfxFixParserResult fpr     = _fixParser.Parse(content, null, null, null);

            while (fpr.Status == VfxFixParserStatus.MsgComplete)
            {
                // REC: Adjust the read index in the message block
                // to compensate for the number of bytes parsed from
                // the incoming data stream:
                mb.RdIndex += fpr.Consumed;
                // REC: Crunch the message block to remove the data
                // that has already been parsed:
                mb.Crunch();

                // REC: Reset the timestamp that is used to determine
                // when the last message was received from the peer:
                this._lastRxTicks = DateTime.Now.Ticks;

                // REC: Determine if the message is a session layer
                // message and process it accordingly:
                FixField fldMsgType = fpr.Message.Header.GetField(35);
                if (fldMsgType != null)
                {
                    string strMsgType = fldMsgType.Content;
                    if (!string.IsNullOrEmpty(strMsgType))
                    {
                        switch (strMsgType)
                        {
                        case "A":
                            // Received a FIX logon message:
                            HandleSession_Logon(fpr.Message);
                            break;

                        case "0":
                            // Received a FIX heartbeat message:
                            HandleSession_Heartbeat(fpr.Message);
                            break;

                        case "1":
                            // Received a FIX test request:
                            HandleSession_TestRequest(fpr.Message);
                            break;

                        case "2":
                            // Received a FIX resend request:
                            HandleSession_Resend(fpr.Message);
                            break;

                        case "5":
                            // Received a FIX logout message:
                            HandleSession_Logout(fpr.Message);
                            break;

                        default:
                            // Received a message that should be
                            // routed to the session's owner:
                            HandleSession_Message(fpr.Message);
                            break;
                        }
                    }
                    else
                    {
                        // REC: If the session's identity hasn't been
                        // established yet, just throw an exception and
                        // let the session's owner shut it down:
                        if (_currentState == SessionStates.Session_Pending)
                        {
                            throw new ArgumentException("Initial message missing required field - FIX MsgType.");
                        }
                        else
                        {
                            // REC: The session has been established, so the
                            // session can send a reject message:
                        }
                    }
                }
                else
                {
                }

                // REC: Attempt to parse another message from
                // the buffer of data that has been received:
                content = Encoding.ASCII.GetString(mb.Buffer, 0, mb.Length());
                fpr     = _fixParser.Parse(content, null, null, null);
            }

            // REC: If the parser couldn't extract a complete message
            // from the supplied buffer, determine what to do next:
            if (fpr.Status != VfxFixParserStatus.MsgComplete)
            {
            }
        }
Exemplo n.º 14
0
        /// <summary>
        /// The HandleSession_Logon method is invoked to handle
        /// a logon message that has been received from the peer
        /// session that this session is communicating with.
        /// </summary>
        /// <param name="msg">
        /// The FIX logon message received from the peer.
        /// </param>
        private void HandleSession_Logon(FixMessage msg)
        {
            // REC: Ensure that we're in the appropriate state
            // to handle a logon message:
            if (_currentState == SessionStates.Session_Pending || _currentState == SessionStates.Session_Closed)
            {
                // REC: Retrieve the FIX SenderCompID of the peer
                // from the logon message:
                FixField fldSenderCompID = msg.Header.GetField(49);
                if (fldSenderCompID != null)
                {
                    // REC: The SenderCompID from the peer becomes the
                    // session's TargetCompID for outgoing messages:
                    _fixTargetCompID = fldSenderCompID.Content;

                    // REC: Now that the FIX SenderCompID of the peer
                    // session is known, it is used to construct the
                    // identifier for the session - used to retrieve
                    // the session's details from the database:
                    _sessionId = string.Format("{0}-{1}", _fixSenderCompID, _fixTargetCompID);

                    // REC: Attempt to retrieve the session details
                    // from the session database:
                    if (_fixDatabase != null)
                    {
                        // REC: Note that once a session record is acquired
                        // from the database, it must be released when it is
                        // no longer needed by the session instance...
                        _sessionRecord = _fixDatabase.AcquireSession(_sessionId);
                        if (this._resetSequence == true)
                        {
                            _sessionRecord.RxSequence = 1;
                            _sessionRecord.TxSequence = 1;
                        }
                    }

                    // REC: Register the peer session's SenderCompID as
                    // the TargetCompID for outgoing messages:
                    _fixAssembler.SetField(new FixField(56, _fixTargetCompID));

                    // REC: Assemble the response message:
                    FixMessage response = _fixAssembler.CreateMessage(_sxVersion, _axVersion, "A");

                    // REC: Handle the sequence number reset flag
                    // if it is present in the logon message:
                    FixField fieldReset = msg.GetField(141);
                    if (fieldReset != null)
                    {
                        response.AddField(new FixField(141, "Y"));
                    }

                    // REC: Transition to the opened state:
                    _currentState = SessionStates.Session_Opened;

                    // REC: Notify the session's owner that the peer
                    // session has sent the logon request:
                    _handler.OnSessionLogon(this, msg);

                    // REC: Dispatch the administrative message out
                    // to the session's owner:
                    Dispatch_AdmMessage(response);
                }
                else
                {
                    // REC: Throw an exception since the session has not
                    // yet been established and there will be no handler
                    // at the application level that can deal with this:
                    throw new ArgumentException("Logon message missing required field - SenderCompID.");
                }
            }
            else
            {
                // REC: Notify the session handler that an
                // administrative message has been received
                // from the peer session:
                _handler.OnSessionRxAdmMessage(this, msg);

                // REC: Throw an exception that indicates the
                // session is not in the appropriate state to
                // handle the received message:

                //throw new InvalidOperationException("Session state invalid for received message.");
            }
        }
Exemplo n.º 15
0
        // REC: Validate an instance of the FixMessage class against
        // the header/message/trailer definition in the dictionaries:
        public List <FixValidationResult> Validate(FixMessage msg)
        {
            List <FixValidationResult> result = new List <FixValidationResult>();

            // REC: Build a queue of all of the FIX elements that
            // are contained in the message:
            Queue <SrcField> srcFields = new Queue <SrcField>();

            // REC: Add the elements that are in the message's
            // header to the queue of source fields:
            PopulateQueue(srcFields, msg.Header);

            // REC: Add the elements that are in the message's
            // body to the queue of source fields:
            PopulateQueue(srcFields, msg.Content);

            // REC: Add the elements that are in the message's
            // trailer to the queue of source fields:
            PopulateQueue(srcFields, msg.Trailer);


            // REC: Create the MsgLayout structure that defines
            // the layout of a message as it is defined in the
            // configured FIX dictionaries:
            MsgLayout msgLayout = new MsgLayout();

            // REC: The message layout's header entries are
            // copied from the cached list of entries that is
            // created when the validator is configured:
            foreach (FixValidationResult hdrEntry in _cachedHeader)
            {
                msgLayout.Header.Add(hdrEntry.Clone() as FixValidationResult);
            }

            // REC: The message layout's content entries are
            // only configured if the corresponding message
            // type can be found in the dictionaries:
            FixField fldMsgType = msg.Header.GetField(35);

            if (fldMsgType != null)
            {
                string strMsgType = fldMsgType.Content;
                foreach (FixDictionary dx in _settings.Dictionaries)
                {
                    FixDxMessage dxMessage = dx.GetMessageByType(strMsgType);
                    if (dxMessage != null)
                    {
                        // REC: Expand the list of elements contained
                        // in the message's definition and populate the
                        // message layout element list with them:
                        FixDxCollection msgElements = dx.Resolve(dxMessage.Elements);
                        foreach (IFixDxElement msgElement in msgElements)
                        {
                            msgLayout.Message.Add(CreateResult(msgElement));
                        }

                        break;
                    }
                }
            }

            // REC: the message layout's trailer entries are
            // copied from the cached list of entries that is
            // created when the validator is configured:
            foreach (FixValidationResult trlEntry in _cachedTrailer)
            {
                msgLayout.Trailer.Add(trlEntry.Clone() as FixValidationResult);
            }


            // REC: After the message layout has been defined
            // the validator can compare the content of the
            // source message to the layout definition:
            return(ProcessElements(srcFields, msgLayout));
        }
Exemplo n.º 16
0
        public void OnSessionRxAppMessage(IVfxFixAppSession session, FixMessage msg)
        {
            FixField fixSCID = msg.Header.GetField(49);

            Console.WriteLine(string.Format("FIX SERVER: {0} SENT: {1}", fixSCID.Content, msg.ToString()));
        }