protected override IEnumerator <IteratorAsyncResult <TIteratorAsyncResult> .AsyncStep> GetAsyncSteps() { if (this.Transaction == null) { this.wcfMessage = this.CreateWcfMessage(); } else { SbmpMessageCreator sbmpMessageCreator1 = (this.controlMessageCreator == null ? this.MessageCreator : this.controlMessageCreator.Value); SbmpTransactionalAsyncResult <TIteratorAsyncResult> sbmpTransactionalAsyncResult = this; IteratorAsyncResult <TIteratorAsyncResult> .BeginCall beginCall = (TIteratorAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => { SbmpResourceManager resourceManager = thisPtr.messagingFactory.ResourceManager; System.Transactions.Transaction transaction = thisPtr.Transaction; IRequestSessionChannel requestSessionChannel = thisPtr.channel; SbmpMessageCreator sbmpMessageCreator = sbmpMessageCreator1; object obj = thisPtr; return(resourceManager.BeginEnlist(transaction, requestSessionChannel, sbmpMessageCreator, new Action <RequestInfo>(obj.PartitionInfoSetter), t, c, s)); }; yield return(sbmpTransactionalAsyncResult.CallAsync(beginCall, (TIteratorAsyncResult thisPtr, IAsyncResult a) => thisPtr.txnSeqNumber = thisPtr.messagingFactory.ResourceManager.EndEnlist(a), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); this.wcfMessage = this.CreateWcfMessage(); WorkUnitInfo.AddTo(this.wcfMessage.Headers, "TxnWorkUnit", this.Transaction.TransactionInformation.LocalIdentifier, this.txnSeqNumber); } SbmpTransactionalAsyncResult <TIteratorAsyncResult> sbmpTransactionalAsyncResult1 = this; IteratorAsyncResult <TIteratorAsyncResult> .BeginCall beginCall1 = (TIteratorAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.channel.BeginRequest(thisPtr.wcfMessage, SbmpProtocolDefaults.BufferTimeout(t, this.messagingFactory.GetSettings().EnableAdditionalClientTimeout), c, s); yield return(sbmpTransactionalAsyncResult1.CallAsync(beginCall1, (TIteratorAsyncResult thisPtr, IAsyncResult a) => thisPtr.Response = thisPtr.channel.EndRequest(a), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); }
protected override IEnumerator <IteratorAsyncResult <AmqpCbsLink.SendTokenAsyncResult> .AsyncStep> GetAsyncSteps() { string str; AmqpCbsLink.SendTokenAsyncResult sendTokenAsyncResult = this; IteratorAsyncResult <AmqpCbsLink.SendTokenAsyncResult> .BeginCall beginCall = (AmqpCbsLink.SendTokenAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.tokenProvider.BeginGetMessagingToken(this.namespaceAddress, thisPtr.resource, thisPtr.requiredClaims[0], false, t, c, s); yield return(sendTokenAsyncResult.CallAsync(beginCall, (AmqpCbsLink.SendTokenAsyncResult thisPtr, IAsyncResult r) => thisPtr.swt = (SimpleWebSecurityToken)thisPtr.tokenProvider.EndGetMessagingToken(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); if (this.swt is SharedAccessSignatureToken) { str = "servicebus.windows.net:sastoken"; } else if (this.swt != null) { str = "amqp:swt"; } else { str = null; } string str1 = str; if (str1 != null) { if (!this.cbsLink.FaultTolerantLink.TryGetOpenedObject(out this.requestResponseLink)) { AmqpCbsLink.SendTokenAsyncResult sendTokenAsyncResult1 = this; IteratorAsyncResult <AmqpCbsLink.SendTokenAsyncResult> .BeginCall beginCall1 = (AmqpCbsLink.SendTokenAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.cbsLink.FaultTolerantLink.BeginGetInstance(t, c, s); yield return(sendTokenAsyncResult1.CallAsync(beginCall1, (AmqpCbsLink.SendTokenAsyncResult thisPtr, IAsyncResult r) => thisPtr.requestResponseLink = thisPtr.cbsLink.FaultTolerantLink.EndGetInstance(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); } AmqpValue amqpValue = new AmqpValue() { Value = this.swt.Token }; AmqpMessage applicationProperty = AmqpMessage.Create(amqpValue); applicationProperty.ApplicationProperties = new ApplicationProperties(); applicationProperty.ApplicationProperties.Map["operation"] = "put-token"; applicationProperty.ApplicationProperties.Map["type"] = str1; applicationProperty.ApplicationProperties.Map["name"] = this.audience; applicationProperty.ApplicationProperties.Map["expiration"] = this.swt.ExpiresOn; AmqpMessage amqpMessage = null; yield return(base.CallAsync((AmqpCbsLink.SendTokenAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => this.requestResponseLink.BeginRequest(applicationProperty, t, c, s), (AmqpCbsLink.SendTokenAsyncResult thisPtr, IAsyncResult r) => amqpMessage = this.requestResponseLink.EndRequest(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); int item = (int)amqpMessage.ApplicationProperties.Map["status-code"]; string item1 = (string)amqpMessage.ApplicationProperties.Map["status-description"]; if (item != 202) { base.Complete(AmqpCbsLink.SendTokenAsyncResult.ConvertToException(item, item1)); } else { this.ValidTo = this.swt.ValidTo; } } else { base.Complete(new InvalidOperationException(SRAmqp.AmqpUnssuportedTokenType)); } }
protected override IEnumerator <IteratorAsyncResult <AmqpMessageSender.SendAsyncResult> .AsyncStep> GetAsyncSteps() { try { this.amqpMessage = this.CreateAmqpMessage(); } catch (Exception exception) { base.Complete(exception); goto Label0; } if (!this.parent.sendLink.TryGetOpenedObject(out this.amqpLink)) { AmqpMessageSender.SendAsyncResult sendAsyncResult = this; IteratorAsyncResult <AmqpMessageSender.SendAsyncResult> .BeginCall beginCall = (AmqpMessageSender.SendAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.parent.sendLink.BeginGetInstance(t, c, s); yield return(sendAsyncResult.CallAsync(beginCall, (AmqpMessageSender.SendAsyncResult thisPtr, IAsyncResult r) => thisPtr.amqpLink = thisPtr.parent.sendLink.EndGetInstance(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); if (base.LastAsyncStepException == null) { goto Label1; } base.Complete(ExceptionHelper.GetClientException(base.LastAsyncStepException, this.parent.messagingFactory.RemoteContainerId)); goto Label0; } Label1: if (this.amqpLink.Settings.MaxMessageSize.HasValue) { ulong serializedMessageSize = (ulong)this.amqpMessage.SerializedMessageSize; if (serializedMessageSize <= Convert.ToUInt64(this.amqpLink.Settings.MaxMessageSize)) { goto Label2; } AmqpMessageSender.SendAsyncResult sendAsyncResult1 = this; object value = this.amqpMessage.DeliveryId.Value; object obj = serializedMessageSize; ulong? maxMessageSize = this.amqpLink.Settings.MaxMessageSize; sendAsyncResult1.Complete(new MessageSizeExceededException(SRAmqp.AmqpMessageSizeExceeded(value, obj, maxMessageSize.Value))); goto Label0; } Label2: AmqpMessageSender.SendAsyncResult sendAsyncResult2 = this; IteratorAsyncResult <AmqpMessageSender.SendAsyncResult> .BeginCall beginCall1 = (AmqpMessageSender.SendAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.amqpLink.BeginSendMessage(thisPtr.amqpMessage, thisPtr.parent.GetDeliveryTag(), AmqpConstants.NullBinary, t, c, s); yield return(sendAsyncResult2.CallAsync(beginCall1, (AmqpMessageSender.SendAsyncResult thisPtr, IAsyncResult r) => thisPtr.outcome = thisPtr.amqpLink.EndSendMessage(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); if (base.LastAsyncStepException != null) { base.Complete(ExceptionHelper.GetClientException(base.LastAsyncStepException, this.amqpLink.GetTrackingId())); } else if (this.outcome.DescriptorCode == Rejected.Code) { Rejected rejected = (Rejected)this.outcome; base.Complete(ExceptionHelper.ToMessagingContract(rejected.Error)); } Label0: yield break; }
protected override IEnumerator <IteratorAsyncResult <CloseOrAbortLinkAsyncResult> .AsyncStep> GetAsyncSteps() { Exception exception; if (this.batchManager != null) { if (!this.aborting) { CloseOrAbortLinkAsyncResult closeOrAbortLinkAsyncResult = this; IteratorAsyncResult <CloseOrAbortLinkAsyncResult> .BeginCall beginCall = (CloseOrAbortLinkAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.batchManager.BeginClose(t, c, s); IteratorAsyncResult <CloseOrAbortLinkAsyncResult> .EndCall endCall = (CloseOrAbortLinkAsyncResult thisPtr, IAsyncResult a) => thisPtr.batchManager.EndClose(a); yield return(closeOrAbortLinkAsyncResult.CallAsync(beginCall, endCall, (CloseOrAbortLinkAsyncResult thisPtr, TimeSpan t) => thisPtr.batchManager.Close(t), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); } else { this.batchManager.Abort(); } } try { RequestInfo requestInfo = new RequestInfo() { ServerTimeout = new TimeSpan?(SbmpProtocolDefaults.BufferTimeout(base.RemainingTime(), true)) }; RequestInfo requestInfo1 = requestInfo; this.closeMessage = this.linkMessageCreator.CreateWcfMessage("http://schemas.microsoft.com/netservices/2011/06/servicebus/SbmpConnection/CloseLink", new CloseLinkCommand(), this.parentLinkId, null, null, requestInfo1); } catch (Exception exception2) { Exception exception1 = exception2; if (Fx.IsFatal(exception1)) { throw; } CloseOrAbortLinkAsyncResult closeOrAbortLinkAsyncResult1 = this; if (this.aborting) { exception = null; } else { exception = exception1; } closeOrAbortLinkAsyncResult1.Complete(exception); goto Label0; } IteratorAsyncResult <CloseOrAbortLinkAsyncResult> .ExceptionPolicy exceptionPolicy = (this.aborting ? IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue : IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer); CloseOrAbortLinkAsyncResult closeOrAbortLinkAsyncResult2 = this; IteratorAsyncResult <CloseOrAbortLinkAsyncResult> .BeginCall beginCall1 = (CloseOrAbortLinkAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.channel.BeginRequest(thisPtr.closeMessage, SbmpProtocolDefaults.BufferTimeout(t, true), c, s); yield return(closeOrAbortLinkAsyncResult2.CallAsync(beginCall1, (CloseOrAbortLinkAsyncResult thisPtr, IAsyncResult a) => thisPtr.channel.EndRequest(a), (IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy)exceptionPolicy)); Label0: yield break; }
protected override IEnumerator <IteratorAsyncResult <GetMessageSessionsAsyncResult> .AsyncStep> GetAsyncSteps() { Message message = null; do { Message message1 = this.CreateRequestMessage(); GetMessageSessionsAsyncResult getMessageSessionsAsyncResult = this; IteratorAsyncResult <GetMessageSessionsAsyncResult> .BeginCall beginCall = (GetMessageSessionsAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.MessagingFactory.Channel.BeginRequest(message1, SbmpProtocolDefaults.BufferTimeout(t, thisPtr.MessagingFactory.GetSettings().EnableAdditionalClientTimeout), c, s); yield return(getMessageSessionsAsyncResult.CallAsync(beginCall, (GetMessageSessionsAsyncResult thisPtr, IAsyncResult r) => message = thisPtr.MessagingFactory.Channel.EndRequest(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); }while (base.LastAsyncStepException == null && message != null && this.ShouldContinue(message)); base.Complete(base.LastAsyncStepException); }
protected override IEnumerator <IteratorAsyncResult <SbmpBrowsableMessageSession.GetStateAsyncResult> .AsyncStep> GetAsyncSteps() { object obj = null; bool flag = false; if (this.sbmpMessageSession.InnerMessageReceiver == null) { bool flag1 = false; try { object thisLock = this.sbmpMessageSession.ThisLock; object obj1 = thisLock; obj = thisLock; Monitor.Enter(obj1, ref flag1); this.sbmpMessageSession.resetEvent.WaitOne(); } finally { if (flag1) { Monitor.Exit(obj); } } try { if (this.sbmpMessageSession.InnerMessageReceiver != null) { goto Label0; } flag = true; SbmpBrowsableMessageSession.GetStateAsyncResult getStateAsyncResult = this; IteratorAsyncResult <SbmpBrowsableMessageSession.GetStateAsyncResult> .BeginCall beginCall = (SbmpBrowsableMessageSession.GetStateAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.BeginAcceptMessageSessionBrowser(t, c, s); yield return(getStateAsyncResult.CallAsync(beginCall, (SbmpBrowsableMessageSession.GetStateAsyncResult thisPtr, IAsyncResult r) => thisPtr.EndAcceptMessageSessionBrowser(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); } finally { this.sbmpMessageSession.resetEvent.Set(); } } Label0: if (this.sbmpMessageSession.InnerMessageReceiver != null && !flag) { GetSessionStateCommand getSessionStateCommand = new GetSessionStateCommand() { SessionId = this.sbmpMessageSession.SessionId, Timeout = base.RemainingTime(), TransactionId = null, IsBrowseMode = true }; GetSessionStateCommand getSessionStateCommand1 = getSessionStateCommand; RequestInfo requestInfo1 = new RequestInfo() { ServerTimeout = new TimeSpan?(getSessionStateCommand1.Timeout) }; RequestInfo requestInfo = requestInfo1; SbmpMessageReceiver innerMessageReceiver = (SbmpMessageReceiver)this.sbmpMessageSession.InnerMessageReceiver; this.wcfMessage = innerMessageReceiver.MessageCreator.CreateWcfMessage("http://schemas.microsoft.com/netservices/2011/06/servicebus/SbmpMessageReceiver/GetSessionState", getSessionStateCommand1, null, this.sbmpMessageSession.RetryPolicy, this.trackingContext, requestInfo); yield return(base.CallAsync((SbmpBrowsableMessageSession.GetStateAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => innerMessageReceiver.SbmpMessagingFactory.Channel.BeginRequest(thisPtr.wcfMessage, SbmpProtocolDefaults.BufferTimeout(t, innerMessageReceiver.MessagingFactory.GetSettings().EnableAdditionalClientTimeout), c, s), (SbmpBrowsableMessageSession.GetStateAsyncResult thisPtr, IAsyncResult a) => thisPtr.Response = innerMessageReceiver.SbmpMessagingFactory.Channel.EndRequest(a), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); if (base.LastAsyncStepException == null) { this.SessionState = this.Response.GetBody <GetSessionStateResponseCommand>().SessionState; } } }
protected override IEnumerator <IteratorAsyncResult <AmqpMessageReceiver.DisposeAsyncResult> .AsyncStep> GetAsyncSteps() { Exception messagingContract; this.deliveryTag = this.PopulateDeliveryTag(); if (!this.parent.receiveLink.TryGetOpenedObject(out this.amqpLink)) { Microsoft.ServiceBus.Messaging.Amqp.Framing.Error error1 = this.parent.GetSessionLockLostError(); if (error1 == null) { AmqpMessageReceiver.DisposeAsyncResult disposeAsyncResult = this; IteratorAsyncResult <AmqpMessageReceiver.DisposeAsyncResult> .BeginCall beginCall = (AmqpMessageReceiver.DisposeAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.parent.receiveLink.BeginGetInstance(t, c, s); yield return(disposeAsyncResult.CallAsync(beginCall, (AmqpMessageReceiver.DisposeAsyncResult thisPtr, IAsyncResult r) => thisPtr.amqpLink = thisPtr.parent.receiveLink.EndGetInstance(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); if (base.LastAsyncStepException == null) { goto Label1; } base.LastAsyncStepException = this.ProcessException(ExceptionHelper.GetClientException(base.LastAsyncStepException, this.parent.messagingFactory.RemoteContainerId)); base.Complete(base.LastAsyncStepException); goto Label0; } else { base.Complete(ExceptionHelper.ToMessagingContract(error1)); goto Label0; } } Label1: AmqpMessageReceiver.DisposeAsyncResult disposeAsyncResult1 = this; IteratorAsyncResult <AmqpMessageReceiver.DisposeAsyncResult> .BeginCall beginCall1 = (AmqpMessageReceiver.DisposeAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.amqpLink.BeginDisposeMessage(thisPtr.deliveryTag, thisPtr.outcome, thisPtr.batchable, t, c, s); yield return(disposeAsyncResult1.CallAsync(beginCall1, (AmqpMessageReceiver.DisposeAsyncResult thisPtr, IAsyncResult r) => thisPtr.disposeOutcome = thisPtr.amqpLink.EndDisposeMessage(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); if (base.LastAsyncStepException == null) { Microsoft.ServiceBus.Messaging.Amqp.Framing.Error error = null; if (this.disposeOutcome.DescriptorCode == Rejected.Code) { Microsoft.ServiceBus.Messaging.Amqp.Framing.Error error2 = ((Rejected)this.disposeOutcome).Error; Microsoft.ServiceBus.Messaging.Amqp.Framing.Error error3 = error2; error = error2; if (error3 != null) { if (!error.Condition.Equals(AmqpError.NotFound.Condition)) { base.LastAsyncStepException = ExceptionHelper.ToMessagingContract(error); } else if (this.IsDisposeWithoutSideEffect()) { base.LastAsyncStepException = null; } else if (!this.parent.sessionReceiver) { base.LastAsyncStepException = new MessageLockLostException(SRClient.MessageLockLost); } else { base.LastAsyncStepException = new SessionLockLostException(SRClient.SessionLockExpiredOnMessageSession); } base.Complete(this.ProcessException(base.LastAsyncStepException)); } } } else { if (!(base.LastAsyncStepException is OperationCanceledException) || this.amqpLink.State == AmqpObjectState.Opened) { base.LastAsyncStepException = ExceptionHelper.GetClientException(base.LastAsyncStepException, this.amqpLink.GetTrackingId()); } else if (!this.parent.sessionReceiver) { base.LastAsyncStepException = new MessageLockLostException(SRClient.MessageLockLost, base.LastAsyncStepException); } else { Microsoft.ServiceBus.Messaging.Amqp.Framing.Error error4 = this.parent.GetSessionLockLostError(); AmqpMessageReceiver.DisposeAsyncResult disposeAsyncResult2 = this; if (error4 != null) { messagingContract = ExceptionHelper.ToMessagingContract(error4); } else { messagingContract = new SessionLockLostException(SRClient.SessionLockExpiredOnMessageSession, base.LastAsyncStepException); } disposeAsyncResult2.LastAsyncStepException = messagingContract; } base.Complete(this.ProcessException(base.LastAsyncStepException)); } Label0: yield break; }
protected override IEnumerator <IteratorAsyncResult <AmqpSubscriptionClient.CloseAsyncResult> .AsyncStep> GetAsyncSteps() { if (this.client.controlLink.TryGetOpenedObject(out this.amqpLink)) { AmqpSubscriptionClient.CloseAsyncResult closeAsyncResult = this; IteratorAsyncResult <AmqpSubscriptionClient.CloseAsyncResult> .BeginCall beginCall = (AmqpSubscriptionClient.CloseAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.client.messagingFactory.BeginCloseEntity(thisPtr.amqpLink, t, c, s); yield return(closeAsyncResult.CallAsync(beginCall, (AmqpSubscriptionClient.CloseAsyncResult thisPtr, IAsyncResult r) => thisPtr.client.messagingFactory.EndCloseEntity(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); } AmqpSubscriptionClient.CloseAsyncResult closeAsyncResult1 = this; IteratorAsyncResult <AmqpSubscriptionClient.CloseAsyncResult> .BeginCall beginCall1 = (AmqpSubscriptionClient.CloseAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.client.BaseOnBeginClose(t, c, s); IteratorAsyncResult <AmqpSubscriptionClient.CloseAsyncResult> .EndCall endCall = (AmqpSubscriptionClient.CloseAsyncResult thisPtr, IAsyncResult r) => thisPtr.client.BaseOnEndClose(r); yield return(closeAsyncResult1.CallAsync(beginCall1, endCall, (AmqpSubscriptionClient.CloseAsyncResult thisPtr, TimeSpan t) => thisPtr.client.BaseOnClose(t), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); }
protected override IEnumerator <IteratorAsyncResult <SocketMessageHelper.SendMessageAsyncResult> .AsyncStep> GetAsyncSteps() { this.countBytes = BitConverter.GetBytes(this.messageBytes.Count); SocketMessageHelper.SendMessageAsyncResult sendMessageAsyncResult = this; IteratorAsyncResult <SocketMessageHelper.SendMessageAsyncResult> .BeginCall beginCall = (SocketMessageHelper.SendMessageAsyncResult thisRef, TimeSpan t, AsyncCallback c, object s) => thisRef.connection.BeginWrite(thisRef.countBytes, 0, (int)thisRef.countBytes.Length, true, t, c, s); yield return(sendMessageAsyncResult.CallAsync(beginCall, (SocketMessageHelper.SendMessageAsyncResult thisRef, IAsyncResult r) => thisRef.connection.EndWrite(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); SocketMessageHelper.SendMessageAsyncResult sendMessageAsyncResult1 = this; IteratorAsyncResult <SocketMessageHelper.SendMessageAsyncResult> .BeginCall beginCall1 = (SocketMessageHelper.SendMessageAsyncResult thisRef, TimeSpan t, AsyncCallback c, object s) => thisRef.connection.BeginWrite(thisRef.messageBytes.Array, thisRef.messageBytes.Offset, thisRef.messageBytes.Count, true, t, c, s); yield return(sendMessageAsyncResult1.CallAsync(beginCall1, (SocketMessageHelper.SendMessageAsyncResult thisRef, IAsyncResult r) => thisRef.connection.EndWrite(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); }
protected override IEnumerator <IteratorAsyncResult <AmqpChannelListener.AmqpInputSessionChannel.TryReceiveAsyncResult> .AsyncStep> GetAsyncSteps() { if (!this.inputChannel.DoneReceivingInCurrentState()) { AmqpChannelListener.AmqpInputSessionChannel.TryReceiveAsyncResult tryReceiveAsyncResult = this; IteratorAsyncResult <AmqpChannelListener.AmqpInputSessionChannel.TryReceiveAsyncResult> .BeginCall beginCall = (AmqpChannelListener.AmqpInputSessionChannel.TryReceiveAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.inputChannel.link.BeginReceiveMessage(t, c, s); yield return(tryReceiveAsyncResult.CallAsync(beginCall, (AmqpChannelListener.AmqpInputSessionChannel.TryReceiveAsyncResult thisPtr, IAsyncResult a) => thisPtr.Outcome = thisPtr.inputChannel.link.EndReceiveMessage(a, out thisPtr.amqpMessage), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); this.Message = this.inputChannel.AmqpMessageToChannelMessage(this.amqpMessage); if (this.amqpMessage != null) { this.inputChannel.link.DisposeMessage(this.amqpMessage, AmqpConstants.AcceptedOutcome, true, this.amqpMessage.Batchable); } } else { this.Message = null; this.Outcome = true; } }
protected override IEnumerator <IteratorAsyncResult <SbmpMessagingFactory.OpenAsyncResult> .AsyncStep> GetAsyncSteps() { if (this.factory.ShouldIntialize) { SbmpMessagingFactory.OpenAsyncResult openAsyncResult = this; IteratorAsyncResult <SbmpMessagingFactory.OpenAsyncResult> .BeginCall beginCall = (SbmpMessagingFactory.OpenAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => Microsoft.ServiceBus.Messaging.NetworkDetector.BeginCheckTcp(thisPtr.factory.baseAddresses, SbmpProtocolDefaults.BufferTimeout(t, thisPtr.factory.GetSettings().EnableAdditionalClientTimeout), c, s); yield return(openAsyncResult.CallAsync(beginCall, (SbmpMessagingFactory.OpenAsyncResult thisPtr, IAsyncResult r) => thisPtr.factory.Initialize(!Microsoft.ServiceBus.Messaging.NetworkDetector.EndCheckTcp(r), true, thisPtr.factory.baseAddresses), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); } SbmpMessagingFactory.OpenAsyncResult openAsyncResult1 = this; IteratorAsyncResult <SbmpMessagingFactory.OpenAsyncResult> .BeginCall beginCall1 = (SbmpMessagingFactory.OpenAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.factory.ChannelFactory.BeginOpen(SbmpProtocolDefaults.BufferTimeout(t, thisPtr.factory.GetSettings().EnableAdditionalClientTimeout), c, s); IteratorAsyncResult <SbmpMessagingFactory.OpenAsyncResult> .EndCall endCall = (SbmpMessagingFactory.OpenAsyncResult thisPtr, IAsyncResult r) => thisPtr.factory.ChannelFactory.EndOpen(r); yield return(openAsyncResult1.CallAsync(beginCall1, endCall, (SbmpMessagingFactory.OpenAsyncResult thisPtr, TimeSpan t) => thisPtr.factory.ChannelFactory.Open(SbmpProtocolDefaults.BufferTimeout(t, thisPtr.factory.GetSettings().EnableAdditionalClientTimeout)), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); if (this.ContinueAfterCommunicationException(base.LastAsyncStepException)) { EndpointAddress endpointAddress = this.factory.CreateEndpointAddress(string.Empty); this.factory.Channel = this.factory.ChannelFactory.CreateChannel(endpointAddress); SbmpMessagingFactory.OpenAsyncResult openAsyncResult2 = this; IteratorAsyncResult <SbmpMessagingFactory.OpenAsyncResult> .BeginCall beginCall2 = (SbmpMessagingFactory.OpenAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.factory.Channel.BeginOpen(SbmpProtocolDefaults.BufferTimeout(t, thisPtr.factory.GetSettings().EnableAdditionalClientTimeout), c, s); IteratorAsyncResult <SbmpMessagingFactory.OpenAsyncResult> .EndCall endCall1 = (SbmpMessagingFactory.OpenAsyncResult thisPtr, IAsyncResult r) => thisPtr.factory.Channel.EndOpen(r); yield return(openAsyncResult2.CallAsync(beginCall2, endCall1, (SbmpMessagingFactory.OpenAsyncResult thisPtr, TimeSpan t) => thisPtr.factory.Channel.Open(SbmpProtocolDefaults.BufferTimeout(t, thisPtr.factory.GetSettings().EnableAdditionalClientTimeout)), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); this.ContinueAfterCommunicationException(base.LastAsyncStepException); } }
protected override IEnumerator <IteratorAsyncResult <SbmpMessagingFactory.CloseAsyncResult> .AsyncStep> GetAsyncSteps() { SbmpMessagingFactory.CloseAsyncResult closeAsyncResult = this; IteratorAsyncResult <SbmpMessagingFactory.CloseAsyncResult> .BeginCall beginCall = (SbmpMessagingFactory.CloseAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.factory.BaseOnBeginClose(t, c, s); IteratorAsyncResult <SbmpMessagingFactory.CloseAsyncResult> .EndCall endCall = (SbmpMessagingFactory.CloseAsyncResult thisPtr, IAsyncResult r) => thisPtr.factory.BaseOnEndClose(r); yield return(closeAsyncResult.CallAsync(beginCall, endCall, (SbmpMessagingFactory.CloseAsyncResult thisPtr, TimeSpan t) => thisPtr.factory.BaseClose(t), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); if (this.ContinueAfterCommunicationException(base.LastAsyncStepException)) { if (this.channel != null) { SbmpMessagingFactory.CloseAsyncResult closeAsyncResult1 = this; IteratorAsyncResult <SbmpMessagingFactory.CloseAsyncResult> .BeginCall beginCall1 = (SbmpMessagingFactory.CloseAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.channel.BeginClose(SbmpProtocolDefaults.BufferTimeout(t, thisPtr.factory.GetSettings().EnableAdditionalClientTimeout), c, s); IteratorAsyncResult <SbmpMessagingFactory.CloseAsyncResult> .EndCall endCall1 = (SbmpMessagingFactory.CloseAsyncResult thisPtr, IAsyncResult r) => thisPtr.channel.EndClose(r); yield return(closeAsyncResult1.CallAsync(beginCall1, endCall1, (SbmpMessagingFactory.CloseAsyncResult thisPtr, TimeSpan t) => thisPtr.channel.Close(SbmpProtocolDefaults.BufferTimeout(t, thisPtr.factory.GetSettings().EnableAdditionalClientTimeout)), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); if (!this.ContinueAfterCommunicationException(base.LastAsyncStepException)) { goto Label0; } } if (this.factory.ChannelFactory != null) { SbmpMessagingFactory.CloseAsyncResult closeAsyncResult2 = this; IteratorAsyncResult <SbmpMessagingFactory.CloseAsyncResult> .BeginCall beginCall2 = (SbmpMessagingFactory.CloseAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.factory.ChannelFactory.BeginClose(SbmpProtocolDefaults.BufferTimeout(t, thisPtr.factory.GetSettings().EnableAdditionalClientTimeout), c, s); IteratorAsyncResult <SbmpMessagingFactory.CloseAsyncResult> .EndCall endCall2 = (SbmpMessagingFactory.CloseAsyncResult thisPtr, IAsyncResult r) => thisPtr.factory.ChannelFactory.EndClose(r); yield return(closeAsyncResult2.CallAsync(beginCall2, endCall2, (SbmpMessagingFactory.CloseAsyncResult thisPtr, TimeSpan t) => thisPtr.factory.ChannelFactory.Close(SbmpProtocolDefaults.BufferTimeout(t, thisPtr.factory.GetSettings().EnableAdditionalClientTimeout)), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); } this.ContinueAfterCommunicationException(base.LastAsyncStepException); } Label0: yield break; }
protected override IEnumerator <IteratorAsyncResult <SbmpResourceManager.TransactionEnlistment.CreateInstanceAsyncResult> .AsyncStep> GetAsyncSteps() { CreateTransactionCommand createTransactionCommand = new CreateTransactionCommand() { TransactionId = this.owner.transactionId, Timeout = base.RemainingTime() }; RequestInfo nullable = this.owner.RequestInfo.Clone(); nullable.ServerTimeout = new TimeSpan?(createTransactionCommand.Timeout); nullable.TransactionId = createTransactionCommand.TransactionId; this.request = this.owner.messageCreator.CreateWcfMessage("http://schemas.microsoft.com/netservices/2011/06/servicebus/SbmpConnection/CreateTransaction", createTransactionCommand, nullable); SbmpResourceManager.TransactionEnlistment.CreateInstanceAsyncResult createInstanceAsyncResult = this; IteratorAsyncResult <SbmpResourceManager.TransactionEnlistment.CreateInstanceAsyncResult> .BeginCall beginCall = (SbmpResourceManager.TransactionEnlistment.CreateInstanceAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.owner.channel.BeginRequest(thisPtr.request, SbmpProtocolDefaults.BufferTimeout(t, thisPtr.owner.messageCreator.DisableClientOperationTimeBuffer), c, s); yield return(createInstanceAsyncResult.CallAsync(beginCall, (SbmpResourceManager.TransactionEnlistment.CreateInstanceAsyncResult thisPtr, IAsyncResult r) => thisPtr.response = thisPtr.owner.channel.EndRequest(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); if (this.response.IsFault) { base.Complete(new MessagingException(this.response.ToString())); } }
protected override IEnumerator <IteratorAsyncResult <GetRuntimeEntityDescriptionAsyncResult> .AsyncStep> GetAsyncSteps() { MessagingClientEtwProvider.TraceClient(() => { }); if (!this.executeOnce) { while (this.ShouldGetEntityInfo(MessagingExceptionHelper.Unwrap(base.LastAsyncStepException as CommunicationException))) { if (!RuntimeEntityDescriptionCache.TryGet(this.entityAddress, out this.runtimeEntityDescription)) { this.request = this.CreateOrGetRequestMessage(); GetRuntimeEntityDescriptionAsyncResult getRuntimeEntityDescriptionAsyncResult = this; IteratorAsyncResult <GetRuntimeEntityDescriptionAsyncResult> .BeginCall beginCall = (GetRuntimeEntityDescriptionAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.factory.Channel.BeginRequest(thisPtr.request, t, c, s); yield return(getRuntimeEntityDescriptionAsyncResult.CallAsync(beginCall, (GetRuntimeEntityDescriptionAsyncResult thisPtr, IAsyncResult a) => thisPtr.response = thisPtr.factory.Channel.EndRequest(a), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); if (base.LastAsyncStepException == null) { this.runtimeEntityDescription = GetRuntimeEntityDescriptionAsyncResult.BuildRuntimeEntityDescription(this.response); RuntimeEntityDescriptionCache.AddOrUpdate(this.entityAddress, this.runtimeEntityDescription); this.clientEntity.RuntimeEntityDescription = this.runtimeEntityDescription; } else { if (!base.LastAsyncStepException.IsWrappedExceptionTransient()) { yield return(base.CallAsyncSleep(Constants.GetRuntimeEntityDescriptionNonTransientSleepTimeout)); } else { yield return(base.CallAsyncSleep(TimeSpan.FromSeconds((double)(this.attempt % 60)) + TimeSpan.FromMilliseconds((double)ConcurrentRandom.Next(1, 1000)))); } GetRuntimeEntityDescriptionAsyncResult getRuntimeEntityDescriptionAsyncResult1 = this; getRuntimeEntityDescriptionAsyncResult1.attempt = getRuntimeEntityDescriptionAsyncResult1.attempt + 1; } } else { this.clientEntity.RuntimeEntityDescription = this.runtimeEntityDescription; } } } else { if (!RuntimeEntityDescriptionCache.TryGet(this.entityAddress, out this.runtimeEntityDescription)) { this.request = this.CreateOrGetRequestMessage(); GetRuntimeEntityDescriptionAsyncResult getRuntimeEntityDescriptionAsyncResult2 = this; IteratorAsyncResult <GetRuntimeEntityDescriptionAsyncResult> .BeginCall beginCall1 = (GetRuntimeEntityDescriptionAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.factory.Channel.BeginRequest(thisPtr.request, t, c, s); yield return(getRuntimeEntityDescriptionAsyncResult2.CallAsync(beginCall1, (GetRuntimeEntityDescriptionAsyncResult thisPtr, IAsyncResult a) => thisPtr.response = thisPtr.factory.Channel.EndRequest(a), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); this.runtimeEntityDescription = GetRuntimeEntityDescriptionAsyncResult.BuildRuntimeEntityDescription(this.response); RuntimeEntityDescriptionCache.AddOrUpdate(this.entityAddress, this.runtimeEntityDescription); } this.clientEntity.RuntimeEntityDescription = this.runtimeEntityDescription; } }
protected override IEnumerator <IteratorAsyncResult <SbmpSubscriptionClient.CloseAsyncResult> .AsyncStep> GetAsyncSteps() { if (!this.aborting) { if (this.parent.ControlMessageCreator.IsValueCreated) { SbmpSubscriptionClient.CloseAsyncResult closeAsyncResult = this; IteratorAsyncResult <SbmpSubscriptionClient.CloseAsyncResult> .BeginCall beginCall = (SbmpSubscriptionClient.CloseAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => (new CloseOrAbortLinkAsyncResult(thisPtr.parent.ControlMessageCreator.Value, ((SbmpMessagingFactory)thisPtr.parent.MessagingFactory).Channel, null, t, false, c, s)).Start(); yield return(closeAsyncResult.CallAsync(beginCall, (SbmpSubscriptionClient.CloseAsyncResult thisPtr, IAsyncResult r) => AsyncResult <CloseOrAbortLinkAsyncResult> .End(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); } SbmpSubscriptionClient.CloseAsyncResult closeAsyncResult1 = this; IteratorAsyncResult <SbmpSubscriptionClient.CloseAsyncResult> .BeginCall beginCall1 = (SbmpSubscriptionClient.CloseAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.parent.BaseBeginClose(t, c, s); yield return(closeAsyncResult1.CallAsync(beginCall1, (SbmpSubscriptionClient.CloseAsyncResult thisPtr, IAsyncResult r) => thisPtr.parent.EndBaseClose(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); } else { if (this.parent.ControlMessageCreator.IsValueCreated) { CloseOrAbortLinkAsyncResult closeOrAbortLinkAsyncResult = new CloseOrAbortLinkAsyncResult(this.parent.ControlMessageCreator.Value, ((SbmpMessagingFactory)this.parent.MessagingFactory).Channel, null, base.RemainingTime(), true, null, null); closeOrAbortLinkAsyncResult.Schedule(); } this.parent.BaseAbort(); } }
protected override IEnumerator <IteratorAsyncResult <AmqpManagementLink.GetEventHubRuntimeInfoAsyncResult> .AsyncStep> GetAsyncSteps() { if (!this.managementLink.FaultTolerantLink.TryGetOpenedObject(out this.requestResponseLink)) { AmqpManagementLink.GetEventHubRuntimeInfoAsyncResult getEventHubRuntimeInfoAsyncResult = this; IteratorAsyncResult <AmqpManagementLink.GetEventHubRuntimeInfoAsyncResult> .BeginCall beginCall = (AmqpManagementLink.GetEventHubRuntimeInfoAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.managementLink.FaultTolerantLink.BeginGetInstance(t, c, s); yield return(getEventHubRuntimeInfoAsyncResult.CallAsync(beginCall, (AmqpManagementLink.GetEventHubRuntimeInfoAsyncResult thisPtr, IAsyncResult r) => thisPtr.requestResponseLink = thisPtr.managementLink.FaultTolerantLink.EndGetInstance(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); } AmqpMessage applicationProperty = AmqpMessage.Create(); applicationProperty.ApplicationProperties = new ApplicationProperties(); applicationProperty.ApplicationProperties.Map["name"] = this.eventHubPath; applicationProperty.ApplicationProperties.Map["operation"] = "READ"; applicationProperty.ApplicationProperties.Map["type"] = "com.microsoft:eventhub"; AmqpManagementLink.GetEventHubRuntimeInfoAsyncResult getEventHubRuntimeInfoAsyncResult1 = this; IteratorAsyncResult <AmqpManagementLink.GetEventHubRuntimeInfoAsyncResult> .BeginCall beginCall1 = (AmqpManagementLink.GetEventHubRuntimeInfoAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.requestResponseLink.BeginRequest(applicationProperty, t, c, s); yield return(getEventHubRuntimeInfoAsyncResult1.CallAsync(beginCall1, (AmqpManagementLink.GetEventHubRuntimeInfoAsyncResult thisPtr, IAsyncResult r) => thisPtr.getRuntimeInfoResponse = thisPtr.requestResponseLink.EndRequest(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); int item = (int)this.getRuntimeInfoResponse.ApplicationProperties.Map["status-code"]; string str = (string)this.getRuntimeInfoResponse.ApplicationProperties.Map["status-description"]; if (item != 200) { base.Complete(AmqpManagementLink.GetEventHubRuntimeInfoAsyncResult.ConvertToException(item, str)); } else { this.Result = MessageConverter.GetEventHubRuntimeInfo(this.getRuntimeInfoResponse); } }
protected override IEnumerator <IteratorAsyncResult <WebSocketRelayedConnectionListener.ConnectAsyncResult> .AsyncStep> GetAsyncSteps() { Uri uri = ServiceBusUriHelper.CreateServiceUri(Uri.UriSchemeHttps, this.Request.HttpsEndpoint.ToString(), "/"); ServiceBusClientWebSocket serviceBusClientWebSocket = new ServiceBusClientWebSocket("wsrelayedconnection"); yield return(base.CallAsync((WebSocketRelayedConnectionListener.ConnectAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => serviceBusClientWebSocket.BeginConnect(uri.Host, uri.Port, ConnectConstants.ConnectionInitiateTimeout, c, s), (WebSocketRelayedConnectionListener.ConnectAsyncResult thisPtr, IAsyncResult r) => serviceBusClientWebSocket.EndConnect(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); this.connection = new ClientWebSocketConnection(serviceBusClientWebSocket, this.relayedConnectionListener.bufferSize, this.relayedConnectionListener.uri, this.Activity); this.message = Message.CreateMessage(this.relayedConnectionListener.messageHelper.MessageVersion, "RelayedAccept", new AcceptMessage(this.Request.Id)); this.message.Headers.To = EndpointAddress.AnonymousUri; WebSocketRelayedConnectionListener.ConnectAsyncResult connectAsyncResult = this; IteratorAsyncResult <WebSocketRelayedConnectionListener.ConnectAsyncResult> .BeginCall beginCall = (WebSocketRelayedConnectionListener.ConnectAsyncResult thisRef, TimeSpan t, AsyncCallback c, object s) => thisRef.relayedConnectionListener.messageHelper.BeginSendMessage(thisRef.connection, thisRef.message, t, c, s); yield return(connectAsyncResult.CallAsync(beginCall, (WebSocketRelayedConnectionListener.ConnectAsyncResult thisRef, IAsyncResult r) => thisRef.relayedConnectionListener.messageHelper.EndSendMessage(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); IOThreadScheduler.ScheduleCallbackNoFlow(new Action <object>(this.relayedConnectionListener.BeginConnectCallback), this.connection); }
protected override IEnumerator <IteratorAsyncResult <SbmpMessageSender.CancelScheduledMessageCommandAsyncResult> .AsyncStep> GetAsyncSteps() { CancelScheduledMessageCommand cancelScheduledMessageCommand = new CancelScheduledMessageCommand() { SequenceNumbers = this.sequenceNumbers, Timeout = base.RemainingTime(), TransactionId = null }; CancelScheduledMessageCommand cancelScheduledMessageCommand1 = cancelScheduledMessageCommand; RequestInfo requestInfo1 = new RequestInfo() { ServerTimeout = new TimeSpan?(cancelScheduledMessageCommand1.Timeout), TransactionId = cancelScheduledMessageCommand1.TransactionId }; RequestInfo nullable = requestInfo1; nullable.SequenceNumber = new long?(this.sequenceNumbers.First <long>()); if (this.trackingContext != null) { SbmpMessageSender.TraceCancel(this.relatedActivity, this.trackingContext, this.sequenceNumbers); } this.wcfMessage = this.messageSender.MessageCreator.CreateWcfMessage("http://schemas.microsoft.com/netservices/2011/06/servicebus/SbmpMessageSender/CancelScheduledMessage", cancelScheduledMessageCommand1, null, this.messageSender.RetryPolicy, this.trackingContext, nullable); SbmpMessageSender.CancelScheduledMessageCommandAsyncResult cancelScheduledMessageCommandAsyncResult = this; IteratorAsyncResult <SbmpMessageSender.CancelScheduledMessageCommandAsyncResult> .BeginCall beginCall = (SbmpMessageSender.CancelScheduledMessageCommandAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.messageSender.SbmpMessagingFactory.Channel.BeginRequest(thisPtr.wcfMessage, thisPtr.OriginalTimeout, c, s); yield return(cancelScheduledMessageCommandAsyncResult.CallAsync(beginCall, (SbmpMessageSender.CancelScheduledMessageCommandAsyncResult thisPtr, IAsyncResult r) => thisPtr.messageSender.SbmpMessagingFactory.Channel.EndRequest(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); }
protected override IEnumerator <IteratorAsyncResult <SocketMessageHelper.ReceiveBytesAsyncResult> .AsyncStep> GetAsyncSteps() { SocketMessageHelper.ReceiveBytesAsyncResult receiveBytesAsyncResult = this; IteratorAsyncResult <SocketMessageHelper.ReceiveBytesAsyncResult> .BeginCall readBytesAsyncResult = (SocketMessageHelper.ReceiveBytesAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => new SocketMessageHelper.ReadBytesAsyncResult(thisPtr.connection, thisPtr.size, false, t, c, s); yield return(receiveBytesAsyncResult.CallAsync(readBytesAsyncResult, (SocketMessageHelper.ReceiveBytesAsyncResult thisPtr, IAsyncResult r) => thisPtr.Bytes = AsyncResult <SocketMessageHelper.ReadBytesAsyncResult> .End(r).Bytes, IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); }
protected override IEnumerator <IteratorAsyncResult <SbmpMessageSender.ScheduleMessageCommandAsyncResult> .AsyncStep> GetAsyncSteps() { ScheduleMessageCommand scheduleMessageCommand = new ScheduleMessageCommand() { Messages = MessageCollection.Wrap(this.messages), Timeout = base.RemainingTime(), TransactionId = null }; ScheduleMessageCommand scheduleMessageCommand1 = scheduleMessageCommand; RequestInfo requestInfo1 = new RequestInfo() { ServerTimeout = new TimeSpan?(scheduleMessageCommand1.Timeout), TransactionId = scheduleMessageCommand1.TransactionId }; RequestInfo requestInfo = requestInfo1; this.messageSender.AddRequestInfoHeader(requestInfo, this.messages); if (this.trackingContext != null) { SbmpMessageSender.TraceSend(this.relatedActivity, this.trackingContext, this.messages); } this.wcfMessage = this.messageSender.MessageCreator.CreateWcfMessage("http://schemas.microsoft.com/netservices/2011/06/servicebus/SbmpMessageSender/ScheduleMessage", scheduleMessageCommand1, null, this.messageSender.RetryPolicy, this.trackingContext, requestInfo); SbmpMessageSender.ScheduleMessageCommandAsyncResult scheduleMessageCommandAsyncResult = this; IteratorAsyncResult <SbmpMessageSender.ScheduleMessageCommandAsyncResult> .BeginCall beginCall = (SbmpMessageSender.ScheduleMessageCommandAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.messageSender.SbmpMessagingFactory.Channel.BeginRequest(thisPtr.wcfMessage, thisPtr.OriginalTimeout, c, s); yield return(scheduleMessageCommandAsyncResult.CallAsync(beginCall, (SbmpMessageSender.ScheduleMessageCommandAsyncResult thisPtr, IAsyncResult a) => thisPtr.response = thisPtr.messageSender.SbmpMessagingFactory.Channel.EndRequest(a), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); ScheduleMessageResponseCommand body = this.response.GetBody <ScheduleMessageResponseCommand>(); if (body.SequenceNumbers != null) { foreach (long sequenceNumber in body.SequenceNumbers) { this.SequenceNumbers.Add(sequenceNumber); } } }
protected override IEnumerator <IteratorAsyncResult <RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult> .AsyncStep> GetAsyncSteps() { RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.EntityLinkValue entityLinkValue; RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.EntityLinkValue entityLinkValue1; string str; object obj; this.ThrowIfNotSupportedClientSettings(); Message message = null; int num = this.incomingMessage.Headers.FindHeader("Authorization", "http://schemas.microsoft.com/servicebus/2010/08/protocol/"); string empty = string.Empty; if (this.incomingMessage.Properties != null && this.incomingMessage.Properties.TryGetValue("ParentLinkId", out obj)) { empty = (string)obj; } LinkInfo header = LinkInfo.GetHeader(this.incomingMessage.Headers); bool flag = !string.IsNullOrWhiteSpace(empty); str = (flag ? empty : header.LinkId); RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.EntityLinkKey entityLinkKey = new RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.EntityLinkKey(header.EntityName, str); RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.EntityLinkValue entityLinkValue2 = null; IRequestSessionChannel requestSessionChannel = null; if (this.sessionChannel.containerNameResolutionMode != ContainerNameResolutionMode.DisableRedirect && !string.IsNullOrEmpty(entityLinkKey.EntityName) && !this.sessionChannel.entityMap.TryGetValue(entityLinkKey, out entityLinkValue2)) { if (!this.sessionChannel.bindingElement.EnableRedirect) { RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult requestAsyncResult = this; IteratorAsyncResult <RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult> .BeginCall beginCall = (RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.sessionChannel.primaryChannel.BeginRequest(thisPtr.incomingMessage, t, c, s); IteratorAsyncResult <RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult> .EndCall endCall = (RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult thisPtr, IAsyncResult r) => message = thisPtr.sessionChannel.primaryChannel.EndRequest(r); yield return(requestAsyncResult.CallAsync(beginCall, endCall, (RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult thisPtr, TimeSpan t) => message = thisPtr.sessionChannel.primaryChannel.Request(thisPtr.incomingMessage, t), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); } else { RedirectCommand redirectCommand = new RedirectCommand(); Message to = Message.CreateMessage(this.incomingMessage.Version, "http://schemas.microsoft.com/netservices/2011/06/servicebus/SbmpRedirect/Redirect", redirectCommand); to.Headers.To = this.incomingMessage.Headers.To; header.AddTo(to.Headers); if (num >= 0) { to.Headers.CopyHeaderFrom(this.incomingMessage.Headers, num); } RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult requestAsyncResult1 = this; IteratorAsyncResult <RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult> .BeginCall beginCall1 = (RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.sessionChannel.primaryChannel.BeginRequest(to, t, c, s); yield return(requestAsyncResult1.CallAsync(beginCall1, (RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult thisPtr, IAsyncResult r) => message = thisPtr.sessionChannel.primaryChannel.EndRequest(r), (RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult thisPtr, TimeSpan t) => message = thisPtr.sessionChannel.primaryChannel.Request(to, t), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); } if (message == null || !string.Equals(message.Headers.Action, "http://schemas.microsoft.com/netservices/2011/06/servicebus/SbmpRedirect/RedirectResponse", StringComparison.OrdinalIgnoreCase)) { if (base.LastAsyncStepException != null) { goto Label1; } this.ResponseMessage = message; if (!flag && string.Equals(this.incomingMessageAction, "http://schemas.microsoft.com/netservices/2011/06/servicebus/SbmpConnection/CloseLink", StringComparison.OrdinalIgnoreCase)) { this.sessionChannel.entityMap.TryRemove(entityLinkKey, out entityLinkValue); goto Label0; } else { goto Label0; } } else { LinkInfo linkInfo = LinkInfo.GetHeader(message.Headers); RedirectResponseCommand body = message.GetBody <RedirectResponseCommand>(); entityLinkValue2 = new RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.EntityLinkValue(body.RedirectTo, linkInfo); this.sessionChannel.containerNameResolutionMode = body.ContainerNameResolutionMode; this.ThrowIfNotSupportedClientSettings(); if (body.ContainerNameResolutionMode != ContainerNameResolutionMode.DisableRedirect) { this.sessionChannel.entityMap.TryAdd(entityLinkKey, entityLinkValue2); } } } Label1: if (entityLinkValue2 == null || this.sessionChannel.containerNameResolutionMode == ContainerNameResolutionMode.DisableRedirect || !this.sessionChannel.bindingElement.EnableRedirect && this.sessionChannel.containerNameResolutionMode == ContainerNameResolutionMode.AllowRedirect) { requestSessionChannel = this.sessionChannel.primaryChannel; } else { RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult requestAsyncResult2 = this; IteratorAsyncResult <RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult> .BeginCall beginCall2 = (RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.sessionChannel.correlatorManager.BeginGetCorrelator(entityLinkValue2.ContainerLocation, t, c, s); yield return(requestAsyncResult2.CallAsync(beginCall2, (RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult thisPtr, IAsyncResult a) => requestSessionChannel = thisPtr.sessionChannel.correlatorManager.EndGetCorrelator(a), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); this.incomingMessage.Headers.RemoveAll("LinkInfo", "http://schemas.microsoft.com/netservices/2011/06/servicebus"); header.TransferDestinationEntityAddress = entityLinkValue2.UpdatedLinkInfo.TransferDestinationEntityAddress; header.TransferDestinationMessagingInstanceHandle = entityLinkValue2.UpdatedLinkInfo.TransferDestinationMessagingInstanceHandle; header.TransferDestinationResourceResourceId = entityLinkValue2.UpdatedLinkInfo.TransferDestinationResourceResourceId; header.EntityType = entityLinkValue2.UpdatedLinkInfo.EntityType; header.EntityName = entityLinkValue2.UpdatedLinkInfo.EntityName; header.AddTo(this.incomingMessage.Headers); } if (!flag && string.Equals(this.incomingMessageAction, "http://schemas.microsoft.com/netservices/2011/06/servicebus/SbmpConnection/CloseLink", StringComparison.OrdinalIgnoreCase)) { this.sessionChannel.entityMap.TryRemove(entityLinkKey, out entityLinkValue1); } yield return(base.CallAsync((RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => requestSessionChannel.BeginRequest(thisPtr.incomingMessage, t, c, s), (RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult thisPtr, IAsyncResult r) => thisPtr.ResponseMessage = requestSessionChannel.EndRequest(r), (RedirectBindingElement.RedirectContainerChannelFactory <TChannel> .RedirectContainerSessionChannel.RequestAsyncResult thisPtr, TimeSpan t) => thisPtr.ResponseMessage = requestSessionChannel.Request(thisPtr.incomingMessage, t), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); Label0: yield break; }
protected override IEnumerator <IteratorAsyncResult <T> .AsyncStep> GetAsyncSteps() { bool flag; TimeSpan timeSpan; while (true) { bool flag1 = false; if (!this.bypassCache) { lock (this.TokenProvider.mutex) { TokenProvider.TokenInfo tokenInfoFromCache = this.TokenProvider.GetTokenInfoFromCache(this.cacheKey); flag = this.OnProcessCachedEntryFromTokenProvider(tokenInfoFromCache); } if (flag) { break; } } Stopwatch stopwatch = Stopwatch.StartNew(); try { TokenProvider.GetTokenAsyncResultBase <T> getTokenAsyncResultBase = this; IteratorAsyncResult <T> .BeginCall getTokenBeginCall = this.GetTokenBeginCall; yield return(getTokenAsyncResultBase.CallAsync(getTokenBeginCall, (T thisPtr, IAsyncResult r) => thisPtr.OnCompletion(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); if (base.LastAsyncStepException != null) { goto Label0; } stopwatch.Stop(); MessagingPerformanceCounters.IncrementTokenAcquisitionLatency(this.appliesToUri, stopwatch.ElapsedTicks); MessagingPerformanceCounters.IncrementTokensAcquiredPerSec(this.appliesToUri, 1); break; } finally { stopwatch.Stop(); } Label0: MessagingPerformanceCounters.IncrementTokenAcquisitionFailuresPerSec(this.appliesToUri, 1); SecurityTokenException lastAsyncStepException = base.LastAsyncStepException as SecurityTokenException; TokenProviderException tokenProviderException = base.LastAsyncStepException as TokenProviderException; TimeoutException timeoutException = base.LastAsyncStepException as TimeoutException; if (timeoutException != null && timeoutException.InnerException != null && timeoutException.InnerException is WebException) { flag1 = true; } else if (tokenProviderException != null && tokenProviderException.InnerException != null && tokenProviderException.InnerException is WebException) { flag1 = true; } else if (lastAsyncStepException != null) { TokenProviderHelper.InternalSecurityTokenException internalSecurityTokenException = lastAsyncStepException as TokenProviderHelper.InternalSecurityTokenException; flag1 = true; if (internalSecurityTokenException != null) { base.LastAsyncStepException = new SecurityTokenException(internalSecurityTokenException.Message, internalSecurityTokenException.InnerException); switch (internalSecurityTokenException.StatusCode) { case HttpStatusCode.BadRequest: case HttpStatusCode.Unauthorized: { flag1 = false; break; } } } } if (flag1) { TimeSpan timeSpan1 = base.RemainingTime(); if (timeSpan1 <= TimeSpan.Zero) { flag1 = false; } else { yield return(base.CallAsyncSleep(TimeoutHelper.Min(this.retrySleepTime, timeSpan1))); TimeSpan timeSpan2 = this.retrySleepTime.Add(this.retrySleepTime); TokenProvider.GetTokenAsyncResultBase <T> getTokenAsyncResultBase1 = this; timeSpan = (timeSpan2 < TokenProvider.MaxRetrySleepTime ? timeSpan2 : TokenProvider.MaxRetrySleepTime); getTokenAsyncResultBase1.retrySleepTime = timeSpan; } } if (!flag1) { if (base.LastAsyncStepException == null) { break; } base.Complete(base.LastAsyncStepException); break; } } }
protected override IEnumerator <IteratorAsyncResult <AmqpSubscriptionClient.RuleAsyncResult> .AsyncStep> GetAsyncSteps() { if (!this.client.controlLink.TryGetOpenedObject(out this.amqpLink)) { AmqpSubscriptionClient.RuleAsyncResult ruleAsyncResult = this; IteratorAsyncResult <AmqpSubscriptionClient.RuleAsyncResult> .BeginCall beginCall = (AmqpSubscriptionClient.RuleAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.client.controlLink.BeginGetInstance(t, c, s); yield return(ruleAsyncResult.CallAsync(beginCall, (AmqpSubscriptionClient.RuleAsyncResult thisPtr, IAsyncResult r) => thisPtr.amqpLink = thisPtr.client.controlLink.EndGetInstance(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); } AmqpValue amqpValue = new AmqpValue() { Value = this.CreateCommand() }; AmqpMessage amqpMessage = AmqpMessage.Create(amqpValue); amqpMessage.Batchable = false; AmqpSubscriptionClient.RuleAsyncResult ruleAsyncResult1 = this; IteratorAsyncResult <AmqpSubscriptionClient.RuleAsyncResult> .BeginCall beginCall1 = (AmqpSubscriptionClient.RuleAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.amqpLink.BeginSendMessage(amqpMessage, thisPtr.client.GetControlMessageDeliveryTag(), new ArraySegment <byte>(), t, c, s); yield return(ruleAsyncResult1.CallAsync(beginCall1, (AmqpSubscriptionClient.RuleAsyncResult thisPtr, IAsyncResult r) => thisPtr.outcome = thisPtr.amqpLink.EndSendMessage(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); if (this.outcome.DescriptorCode == Rejected.Code) { base.Complete(ExceptionHelper.ToMessagingContract(((Rejected)this.outcome).Error)); } }
protected override IEnumerator <IteratorAsyncResult <ContainerChannelManager.OpenInstanceAsyncResult> .AsyncStep> GetAsyncSteps() { ContainerChannelManager.OpenInstanceAsyncResult openInstanceAsyncResult = this; IteratorAsyncResult <ContainerChannelManager.OpenInstanceAsyncResult> .BeginCall beginCall = (ContainerChannelManager.OpenInstanceAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.channel.BeginOpen(t, c, s); IteratorAsyncResult <ContainerChannelManager.OpenInstanceAsyncResult> .EndCall endCall = (ContainerChannelManager.OpenInstanceAsyncResult thisPtr, IAsyncResult r) => thisPtr.channel.EndOpen(r); yield return(openInstanceAsyncResult.CallAsync(beginCall, endCall, (ContainerChannelManager.OpenInstanceAsyncResult thisPtr, TimeSpan t) => thisPtr.channel.Open(t), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); }
protected override IEnumerator <IteratorAsyncResult <AmqpMessageReceiver.ReceiveAsyncResult> .AsyncStep> GetAsyncSteps() { if (!this.parent.receiveLink.TryGetOpenedObject(out this.amqpLink)) { Microsoft.ServiceBus.Messaging.Amqp.Framing.Error error = this.parent.GetSessionLockLostError(); if (error == null) { AmqpMessageReceiver.ReceiveAsyncResult receiveAsyncResult = this; IteratorAsyncResult <AmqpMessageReceiver.ReceiveAsyncResult> .BeginCall beginCall = (AmqpMessageReceiver.ReceiveAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.parent.receiveLink.BeginGetInstance(t, c, s); yield return(receiveAsyncResult.CallAsync(beginCall, (AmqpMessageReceiver.ReceiveAsyncResult thisPtr, IAsyncResult r) => thisPtr.amqpLink = thisPtr.parent.receiveLink.EndGetInstance(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); if (base.LastAsyncStepException == null) { goto Label1; } if (this.shouldThrowTimeout || !(base.LastAsyncStepException is TimeoutException)) { base.Complete(ExceptionHelper.GetClientException(base.LastAsyncStepException, this.parent.messagingFactory.RemoteContainerId)); goto Label0; } else { base.Complete(null); goto Label0; } } else { base.Complete(ExceptionHelper.ToMessagingContract(error)); goto Label0; } } Label1: bool flag = true; do { Label3: if (!flag) { goto Label0; } AmqpMessageReceiver.ReceiveAsyncResult receiveAsyncResult1 = this; IteratorAsyncResult <AmqpMessageReceiver.ReceiveAsyncResult> .BeginCall beginCall1 = (AmqpMessageReceiver.ReceiveAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.BeginReceive(thisPtr.amqpLink, t, c, s); yield return(receiveAsyncResult1.CallAsync(beginCall1, (AmqpMessageReceiver.ReceiveAsyncResult thisPtr, IAsyncResult r) => thisPtr.AmqpMessages = thisPtr.EndReceive(thisPtr.amqpLink, r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); if (base.LastAsyncStepException == null) { try { flag = false; if (this.AmqpMessages != null && this.AmqpMessages.Any <AmqpMessage>()) { flag = !this.ProcessMessage(this.AmqpMessages); } } catch (AmqpException amqpException) { base.Complete(ExceptionHelper.ToMessagingContract(amqpException.Error)); goto Label0; } if (base.RemainingTime() <= TimeSpan.Zero) { flag = false; } else { goto Label3; } } else { base.Complete(ExceptionHelper.GetClientException(base.LastAsyncStepException, this.amqpLink.GetTrackingId())); goto Label0; } }while (!this.shouldThrowTimeout); goto Label2; Label0: yield break; Label2: base.Complete(new TimeoutException(SRCore.TimeoutOnOperation(base.OriginalTimeout))); goto Label0; }
protected override IEnumerator <IteratorAsyncResult <SharedChannel <TChannel> .CloseOrAbortAsyncResult> .AsyncStep> GetAsyncSteps() { if (this.channel != null) { if (!this.abort) { SharedChannel <TChannel> .CloseOrAbortAsyncResult closeOrAbortAsyncResult = this; IteratorAsyncResult <SharedChannel <TChannel> .CloseOrAbortAsyncResult> .BeginCall beginCall = (SharedChannel <TChannel> .CloseOrAbortAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.channel.BeginClose(t, c, s); IteratorAsyncResult <SharedChannel <TChannel> .CloseOrAbortAsyncResult> .EndCall endCall = (SharedChannel <TChannel> .CloseOrAbortAsyncResult thisPtr, IAsyncResult r) => thisPtr.channel.EndClose(r); yield return(closeOrAbortAsyncResult.CallAsync(beginCall, endCall, (SharedChannel <TChannel> .CloseOrAbortAsyncResult thisPtr, TimeSpan t) => thisPtr.channel.Close(t), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); } else { this.channel.Abort(); } } }
protected override IEnumerator <IteratorAsyncResult <AmqpCbsLink.OpenCbsRequestResponseLinkAsyncResult> .AsyncStep> GetAsyncSteps() { string str = "$cbs"; if (base.RemainingTime() > TimeSpan.Zero) { try { AmqpSessionSettings amqpSessionSetting = new AmqpSessionSettings() { Properties = new Fields() }; this.session = new AmqpSession(this.connection, amqpSessionSetting, this); this.connection.AddSession(this.session, null); } catch (InvalidOperationException invalidOperationException1) { InvalidOperationException invalidOperationException = invalidOperationException1; base.Complete(new MessagingException(invalidOperationException.Message, false, invalidOperationException)); goto Label0; } AmqpCbsLink.OpenCbsRequestResponseLinkAsyncResult openCbsRequestResponseLinkAsyncResult = this; IteratorAsyncResult <AmqpCbsLink.OpenCbsRequestResponseLinkAsyncResult> .BeginCall beginCall = (AmqpCbsLink.OpenCbsRequestResponseLinkAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.session.BeginOpen(t, c, s); yield return(openCbsRequestResponseLinkAsyncResult.CallAsync(beginCall, (AmqpCbsLink.OpenCbsRequestResponseLinkAsyncResult thisPtr, IAsyncResult r) => thisPtr.session.EndOpen(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); Exception lastAsyncStepException = base.LastAsyncStepException; if (lastAsyncStepException == null) { AmqpLinkSettings amqpLinkSetting = new AmqpLinkSettings(); AmqpLinkSettings amqpLinkSetting1 = amqpLinkSetting; AmqpSymbol timeoutName = ClientConstants.TimeoutName; TimeSpan timeSpan = base.RemainingTime(); amqpLinkSetting1.AddProperty(timeoutName, (uint)timeSpan.TotalMilliseconds); amqpLinkSetting.Target = new Target() { Address = str }; amqpLinkSetting.Source = new Source() { Address = str }; amqpLinkSetting.InitialDeliveryCount = new uint?(0); amqpLinkSetting.TotalLinkCredit = 50; amqpLinkSetting.AutoSendFlow = true; amqpLinkSetting.SettleType = SettleMode.SettleOnSend; this.Link = new RequestResponseAmqpLink(this.session, amqpLinkSetting); AmqpCbsLink.OpenCbsRequestResponseLinkAsyncResult openCbsRequestResponseLinkAsyncResult1 = this; IteratorAsyncResult <AmqpCbsLink.OpenCbsRequestResponseLinkAsyncResult> .BeginCall beginCall1 = (AmqpCbsLink.OpenCbsRequestResponseLinkAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.Link.BeginOpen(t, c, s); yield return(openCbsRequestResponseLinkAsyncResult1.CallAsync(beginCall1, (AmqpCbsLink.OpenCbsRequestResponseLinkAsyncResult thisPtr, IAsyncResult r) => thisPtr.Link.EndOpen(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); lastAsyncStepException = base.LastAsyncStepException; if (lastAsyncStepException == null) { MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWriteAmqpOpenEntitySucceeded(this.connection, this.Link, this.Link.Name, str)); } else { this.Link = null; MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWriteAmqpOpenEntityFailed(this.connection, this.Link, this.Link.Name, str, lastAsyncStepException.Message)); this.session.SafeClose(); base.Complete(Microsoft.ServiceBus.Messaging.Amqp.ExceptionHelper.ToMessagingContract(lastAsyncStepException, this.connection.RemoteEndpoint.ToString())); } } else { MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWriteAmqpOpenEntityFailed(this.connection, this.session, string.Empty, str, lastAsyncStepException.Message)); this.session.Abort(); base.Complete(Microsoft.ServiceBus.Messaging.Amqp.ExceptionHelper.ToMessagingContract(lastAsyncStepException, this.connection.RemoteEndpoint.ToString())); } } else { if (this.session != null) { this.session.SafeClose(); } base.Complete(new TimeoutException(SRAmqp.AmqpTimeout(base.OriginalTimeout, str))); } Label0: yield break; }
protected override IEnumerator <IteratorAsyncResult <SharedChannel <TChannel> .CreateChannelAsyncResult> .AsyncStep> GetAsyncSteps() { ServiceBusUriManager serviceBusUriManager = new ServiceBusUriManager(this.sharedChannel.viaAddresses.ToList <Uri>(), false); while (true) { if (serviceBusUriManager.MoveNextUri()) { this.Channel = this.sharedChannel.innerFactory.CreateChannel(new EndpointAddress(serviceBusUriManager.Current, new AddressHeader[0]), serviceBusUriManager.Current); SharedChannel <TChannel> .CreateChannelAsyncResult createChannelAsyncResult = this; IteratorAsyncResult <SharedChannel <TChannel> .CreateChannelAsyncResult> .BeginCall beginCall = (SharedChannel <TChannel> .CreateChannelAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.Channel.BeginOpen(t, c, s); yield return(createChannelAsyncResult.CallAsync(beginCall, (SharedChannel <TChannel> .CreateChannelAsyncResult thisPtr, IAsyncResult r) => thisPtr.Channel.EndOpen(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); if (base.LastAsyncStepException == null) { break; } this.Channel.Abort(); } else { if (base.LastAsyncStepException == null) { break; } if (!(base.LastAsyncStepException is TimeoutException)) { throw base.LastAsyncStepException; } throw new CommunicationException(SRClient.OpenChannelFailed(base.OriginalTimeout), base.LastAsyncStepException); } } }
protected override IEnumerator <IteratorAsyncResult <SbmpBrowsableMessageSession.PeekMessagesAsyncResult> .AsyncStep> GetAsyncSteps() { object obj = null; if (this.sbmpMessageSession.InnerMessageReceiver == null) { bool flag = false; try { object thisLock = this.sbmpMessageSession.ThisLock; object obj1 = thisLock; obj = thisLock; Monitor.Enter(obj1, ref flag); this.sbmpMessageSession.resetEvent.WaitOne(); } finally { if (flag) { Monitor.Exit(obj); } } try { if (this.sbmpMessageSession.InnerMessageReceiver != null) { goto Label0; } SbmpBrowsableMessageSession.PeekMessagesAsyncResult peekMessagesAsyncResult = this; IteratorAsyncResult <SbmpBrowsableMessageSession.PeekMessagesAsyncResult> .BeginCall beginCall = (SbmpBrowsableMessageSession.PeekMessagesAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.BeginAcceptMessageSessionBrowser(t, c, s); yield return(peekMessagesAsyncResult.CallAsync(beginCall, (SbmpBrowsableMessageSession.PeekMessagesAsyncResult thisPtr, IAsyncResult r) => thisPtr.EndAcceptMessageSessionBrowser(r), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); } finally { this.sbmpMessageSession.resetEvent.Set(); } } Label0: if (this.sbmpMessageSession.InnerMessageReceiver != null) { SbmpBrowsableMessageSession.PeekMessagesAsyncResult peekMessagesAsyncResult1 = this; IteratorAsyncResult <SbmpBrowsableMessageSession.PeekMessagesAsyncResult> .BeginCall beginCall1 = (SbmpBrowsableMessageSession.PeekMessagesAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.sbmpMessageSession.InnerMessageReceiver.BeginPeekBatch(thisPtr.trackingContext, thisPtr.fromSequenceNumber, thisPtr.messageCount, SbmpProtocolDefaults.BufferTimeout(t, thisPtr.sbmpMessageSession.MessagingFactory.GetSettings().EnableAdditionalClientTimeout), c, s); yield return(peekMessagesAsyncResult1.CallAsync(beginCall1, (SbmpBrowsableMessageSession.PeekMessagesAsyncResult thisPtr, IAsyncResult a) => thisPtr.Messages = thisPtr.sbmpMessageSession.InnerMessageReceiver.EndPeekBatch(a), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Transfer)); } }
protected override IEnumerator <IteratorAsyncResult <ServiceBusInputSessionChannelListener.AcceptChannelAsyncResult> .AsyncStep> GetAsyncSteps() { if (!this.owner.DoneReceivingInCurrentState()) { Stopwatch stopwatch = Stopwatch.StartNew(); ServiceBusInputSessionChannelListener.AcceptChannelAsyncResult acceptChannelAsyncResult = this; IteratorAsyncResult <ServiceBusInputSessionChannelListener.AcceptChannelAsyncResult> .BeginCall beginCall = (ServiceBusInputSessionChannelListener.AcceptChannelAsyncResult thisPtr, TimeSpan t, AsyncCallback c, object s) => thisPtr.owner.MessagingFactory.BeginAcceptMessageSession(this.owner.MessagingAddress.EntityName, null, this.owner.ReceiveMode, thisPtr.acceptMessageSessionTimeout, thisPtr.acceptMessageSessionTimeout, c, s); yield return(acceptChannelAsyncResult.CallAsync(beginCall, (ServiceBusInputSessionChannelListener.AcceptChannelAsyncResult thisPtr, IAsyncResult r) => thisPtr.Channel = new ServiceBusInputSessionChannel(thisPtr.owner.MessagingFactory.EndAcceptMessageSession(r), thisPtr.owner), IteratorAsyncResult <TIteratorAsyncResult> .ExceptionPolicy.Continue)); stopwatch.Stop(); if (base.LastAsyncStepException != null) { Exception lastAsyncStepException = this.owner.OnException(base.LastAsyncStepException); if (lastAsyncStepException == null) { lastAsyncStepException = base.LastAsyncStepException; } Exception exception = lastAsyncStepException; long ticks = base.RemainingTime().Ticks; long num = this.retryTimeSpan.Ticks; TimeSpan elapsed = stopwatch.Elapsed; TimeSpan timeSpan = TimeSpan.FromTicks(Math.Min(ticks, num - elapsed.Ticks)); if (timeSpan > TimeSpan.Zero) { yield return(base.CallAsyncSleep(timeSpan)); } this.owner.IncrementRetryTimeSpan(this.retryTimeSpan); base.Complete(exception); } else { this.owner.ResetRetryTimeSpan(); base.Complete(null); } } else { base.Complete(null); } }