protected void SetOutputChannel(UdpOutputChannel udpOutputChannel) { Fx.Assert(this.UdpOutputChannel == null, "this.UdpOutputChannel must be null"); Fx.Assert(udpOutputChannel != null, "udpOutputChannel can't be null, since SetOutputChannel should be called only once"); this.UdpOutputChannel = udpOutputChannel; }
public CloseAsyncResult(UdpOutputChannel channel, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.channel = channel; this.timeoutHelper = new TimeoutHelper(timeout); if (this.BeginCleanup()) { this.Complete(true); } }
private bool ContinueRetransmission(RetransmitState state) { this.ThrowIfTimedOut(); while (true) { switch (state) { case RetransmitState.TransmitCompleted: if (!this.retransmitIterator.MoveNext()) { // We are done retransmitting return(true); } if (this.retransmitIterator.CurrentDelay > 0) { this.retransmitTimer.Set(this.retransmitIterator.CurrentDelay); return(false); } state = RetransmitState.WaitCompleted; break; case RetransmitState.WaitCompleted: if (this.IsCanceled) { this.channel.ThrowIfAborted(); return(true); } // since we only invoke the encoder once just before the initial send of the message // we need to handle logging the message in the retransmission case if (MessageLogger.LogMessagesAtTransportLevel) { UdpOutputChannel.LogMessage(ref this.message, this.messageData); } // !completedSync if (!this.BeginTransmitMessage()) { return(false); } state = RetransmitState.TransmitCompleted; break; default: Fx.Assert("Unknown RetransmitState value encountered"); return(true); } } }
public UdpRequestContext(UdpOutputChannel outputChannel, Message requestMessage) : base(requestMessage, outputChannel.InternalCloseTimeout, outputChannel.InternalSendTimeout) { Fx.Assert(outputChannel != null, "replyChannel can't be null"); this.outputChannel = outputChannel; if (!NetworkInterfaceMessageProperty.TryGet(requestMessage, out this.networkInterfaceMessageProperty)) { Fx.Assert("requestMessage must always contain NetworkInterfaceMessageProperty"); } RemoteEndpointMessageProperty remoteEndpointMessageProperty; if (!requestMessage.Properties.TryGetValue(RemoteEndpointMessageProperty.Name, out remoteEndpointMessageProperty)) { Fx.Assert("requestMessage must always contain RemoteEndpointMessageProperty"); } UriBuilder uriBuilder = new UriBuilder(UdpConstants.Scheme, remoteEndpointMessageProperty.Address, remoteEndpointMessageProperty.Port); this.via = uriBuilder.Uri; }
public SendAsyncResult(UdpOutputChannel channel, Message message, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.timeoutHelper = new TimeoutHelper(timeout); this.channel = channel; this.message = message; bool throwing = true; bool completedSynchronously = false; try { this.Initialize(message); completedSynchronously = this.BeginTransmitMessage(); if (completedSynchronously && this.retransmissionEnabled) { // initial send completed sync, now we need to start the retransmission process... completedSynchronously = this.BeginRetransmission(); } throwing = false; } finally { if (throwing) { this.Cleanup(); } } if (completedSynchronously) { this.CompleteAndCleanup(true, null); } }
protected override void OnSend(Message message, TimeSpan timeout) { if (message is NullMessage) { return; } TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); IPEndPoint remoteEndPoint; UdpSocket[] sendSockets; Exception exceptionToBeThrown; sendSockets = this.GetSendSockets(message, out remoteEndPoint, out exceptionToBeThrown); if (exceptionToBeThrown != null) { throw FxTrace.Exception.AsError(exceptionToBeThrown); } if (timeoutHelper.RemainingTime() <= TimeSpan.Zero) { throw FxTrace.Exception.AsError(new TimeoutException(SR.SendTimedOut(remoteEndPoint, timeout))); } bool returnBuffer = false; ArraySegment <byte> messageData = default(ArraySegment <byte>); bool sendingMulticast = UdpUtility.IsMulticastAddress(remoteEndPoint.Address); SynchronousRetransmissionHelper retransmitHelper = null; RetransmitIterator retransmitIterator = null; bool shouldRetransmit = this.ShouldRetransmitMessage(sendingMulticast); try { if (shouldRetransmit) { retransmitIterator = this.CreateRetransmitIterator(sendingMulticast); retransmitHelper = new SynchronousRetransmissionHelper(sendingMulticast); this.RetransmitStarting(message.Headers.MessageId, retransmitHelper); } messageData = this.EncodeMessage(message); returnBuffer = true; this.TransmitMessage(messageData, sendSockets, remoteEndPoint, timeoutHelper); if (shouldRetransmit) { while (retransmitIterator.MoveNext()) { // wait for currentDelay time, then retransmit if (retransmitIterator.CurrentDelay > 0) { retransmitHelper.Wait(retransmitIterator.CurrentDelay); } if (retransmitHelper.IsCanceled) { ThrowIfAborted(); return; } // since we only invoke the encoder once just before the initial send of the message // we need to handle logging the message in the retransmission case if (MessageLogger.LogMessagesAtTransportLevel) { UdpOutputChannel.LogMessage(ref message, messageData); } this.TransmitMessage(messageData, sendSockets, remoteEndPoint, timeoutHelper); } } } finally { if (returnBuffer) { this.BufferManager.ReturnBuffer(messageData.Array); } if (shouldRetransmit) { this.RetransmitStopping(message.Headers.MessageId); if (retransmitHelper != null) { retransmitHelper.Dispose(); } } } }