//public int RequestAllOrders()
 //{
 //    //try
 //    //{
 //    //    lock (this)
 //    //    {
 //    //        for (int i = 0; i < _pendingMessages.Count; i++)
 //    //        {
 //    //            if (_pendingMessages[i] is GetAllOrdersMessage)
 //    //            {
 //    //                TracerHelper.Trace(_sessionInformation.Info.Name);
 //    //                int result = ((GetAllOrdersMessage)_pendingMessages[i]).OperationID;
 //    //                System.Diagnostics.Debug.Assert(result != 0);
 //    //                _pendingMessages.RemoveAt(i);
 //    //                return result;
 //    //            }
 //    //        }
 //    //    }
 //    //}
 //    //catch (Exception ex)
 //    //{// Make sure we handle any possible unexpected exceptions, as otherwise they bring the
 //    //    // entire package (MT4 included) down with a bad error.
 //    //    SystemMonitor.Error(ex.Message);
 //    //}
 //    return 0;
 //}
 protected void SendToSubscribers(TransportMessage message)
 {
     TracerHelper.TraceEntry(message.GetType().Name + " to " + _subscribers.Count + " subscribers");
     lock (this)
     {
         foreach (KeyValuePair<ArbiterClientId, TransportInfo> pair in _subscribers)
         {
             SendResponding(pair.Value, message);
         }
     }
 }
        /// <summary>
        /// Helper, unused.
        /// </summary>
        /// <param name="inputMessage"></param>
        /// <returns></returns>
        protected bool VerifySubscriber(TransportMessage inputMessage)
        {
            if (_subscriberTransportMessageInfo == null)
            {
                return false;
            }

            lock (this)
            {
                return _subscriberTransportMessageInfo.CheckOriginalSender(inputMessage.TransportInfo);
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="message"></param>
        void SendToSubscriber(TransportMessage message)
        {
            TracerHelper.TraceEntry(message.GetType().Name);

            lock (this)
            {
                if (_subscriberTransportMessageInfo != null)
                {
                    this.SendResponding(_subscriberTransportMessageInfo, message);
                }
            }

            TracerHelper.TraceExit();
        }
        /// <summary>
        /// Change default TransportClient behaviour.
        /// Handle a requestMessage received from local Arbiter and send down the pipe.
        /// </summary>
        /// <param name="requestMessage"></param>
        protected override void OnMessageReceived(TransportMessage message)
        {
            if (message.IsRequest == false)
            {// Responce requestMessage.
                // Clear off the transporting information from the last node to here.
                message.TransportInfo.PopTransportInfo();
            }

            MessageContainer container = new MessageContainer(message);
            TracerHelper.Trace("[" + message.GetType().Name + "], length [" + container.MessageStreamLength + "]");

            if (_transportClient != null)
            {
                _transportClient.SendMessageContainer(container);
            }
            else
            {
                SystemMonitor.OperationError("Message received after Integration Client uninitialized [" + message.GetType().Name + "].", TracerItem.PriorityEnum.Medium);
            }
        }
 /// <summary>
 /// 
 /// </summary>
 protected virtual bool IsAddressedToMe(TransportMessage message)
 {
     return (message.TransportInfo.CurrentTransportInfo.Value.ReceiverID != null &&
         message.TransportInfo.CurrentTransportInfo.Value.ReceiverID.HasValue && this._ownerID.Equals(message.TransportInfo.CurrentTransportInfo.Value.ReceiverID.Value));
 }
Пример #6
0
 public new void SendResponding(TransportInfo incomingMessageTransportInfo, TransportMessage message)
 {
     base.SendResponding(incomingMessageTransportInfo, message);
 }
        /// <summary>
        /// Change default TransportClient behaviour.
        /// Handle a requestMessage received from local Arbiter and send down the pipe.
        /// </summary>
        /// <param name="requestMessage"></param>
        protected override void OnMessageReceived(TransportMessage message)
        {
            TracerHelper.TraceEntry();
            if (message.TransportInfo == null)
            {
                SystemMonitor.Error("Transport message stack can not be null.");
            }

            if (message.TransportInfo == null ||
                message.TransportInfo.TransportInfoCount == 0 ||
                message.TransportInfo.CurrentTransportInfo.Value.ReceiverID == null ||
                message.TransportInfo.CurrentTransportInfo.Value.ReceiverID.HasValue == false ||
                message.TransportInfo.CurrentTransportInfo.Value.ReceiverID.Value.Equals(this.SubscriptionClientID) == false)
            {// This requestMessage was sent to me, not to one of the clients on the server.

                SystemMonitor.Error("Error. Send messages to server-client instances.");
                return;
            }

            // We shall now establish the tag defining which will be the client connection receiving the requestMessage (or all).
            // by default send to all.
            string tagID = "*";

            if (message.IsRequest)
            {// Request.

                if (message.TransportInfo.ForwardTransportInfoCount != 0)
                {
                    if (message.TransportInfo.CurrentForwardTransportInfoAddress.HasValue)
                    {// Has value - take it into account, if no value is present, just use the "*" pop,
                     // and use the rest of the AdditionalForwardTransportSessionStack.
                        tagID = message.TransportInfo.CurrentForwardTransportInfoAddress.Value.SessionTag;
                    }

                    // Pop in both cases - if it is null or it is value.
                    message.TransportInfo.PopForwardTransportInfo();
                }
            }
            else
            {// Responce.
                // Clear the transporting information from the last node to here.
                message.TransportInfo.PopTransportInfo();

                // Now this is the additional marking in the case with the server - the marking of the PipeChannel.
                SystemMonitor.CheckError(message.TransportInfo.TransportInfoCount > 0 &&
                    message.TransportInfo.CurrentTransportInfo.Value.SenderID.Value.Id.Name == "PipeChannelID");

                // Responce requestMessage, read and pop out the channel ID entry .
                tagID = message.TransportInfo.PopTransportInfo().Value.SenderID.Value.SessionTag;
            }

            MessageContainer container = new MessageContainer(message);
            TracerHelper.Trace("[" + message.GetType().Name + "], tag [" + tagID + "] length [" + container.MessageStreamLength + "]");
            GeneralHelper.FireAndForget(delegate() { _transportServer.SendMessageContainer(tagID, container); });
        }
Пример #8
0
 public new TExpectedMessageClass SendAndReceive <TExpectedMessageClass>(TransportMessage message, TimeSpan timeOut)
     where TExpectedMessageClass : TransportMessage
 {
     return(base.SendAndReceive <TExpectedMessageClass>(message, timeOut));
 }
Пример #9
0
 public TExpectedMessageClass SendAndReceiveAddressed <TExpectedMessageClass>(
     ArbiterClientId receiverID, TransportMessage message, TimeSpan timeOut)
     where TExpectedMessageClass : TransportMessage
 {
     return(base.SendAndReceiveAddressed <TExpectedMessageClass>(receiverID, message, timeOut));
 }
Пример #10
0
 public new void SendAddressed(ArbiterClientId receiverID, TransportMessage message)
 {
     base.SendAddressed(receiverID, message);
 }
Пример #11
0
 /// <summary>
 ///
 /// </summary>
 public Message DirectCall(ArbiterClientId receiverID, TransportMessage message)
 {
     return(base.DirectCall(receiverID, message));
 }
Пример #12
0
 public new void Send(TransportMessage message)
 {
     base.Send(message);
 }