protected override IAsyncResult OnBeginCreateInstance(SingletonDictionaryManager <string, IRequestSessionChannel> .SingletonContext singletonContext, string key, object loadingContext, TimeSpan timeout, AsyncCallback callback, object state) { Uri uri = new Uri(key); EndpointAddress endpointAddress = new EndpointAddress(uri, SbmpProtocolDefaults.GetEndpointIdentity(uri), new AddressHeader[0]); IChannelFactory <IRequestSessionChannel> channelFactory = this.defaultChannelFactory; if (!this.clientMode && loadingContext != null && loadingContext is bool && (bool)loadingContext) { channelFactory = this.securedChannelFactory; } IRequestSessionChannel requestSessionChannel = channelFactory.CreateChannel(endpointAddress); requestSessionChannel.SafeAddFaulted((object s, EventArgs e) => { this.RaiseNotifyCleanup(uri); try { base.BeginUnloadInstance(key, null, true, TimeSpan.FromSeconds(10), new AsyncCallback(ContainerChannelManager.UnloadCallback), this); } catch (Exception exception1) { Exception exception = exception1; if (Fx.IsFatal(exception)) { throw; } MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWriteExceptionAsWarning(exception.ToString())); } }); return(new CompletedAsyncResult <IRequestSessionChannel>(requestSessionChannel, callback, state)); }
private IChannelFactory <IRequestSessionChannel> CreateChannelFactory(bool useSslStreamSecurity, bool includeExceptionDetails, DnsEndpointIdentity endpointIdentity) { string str; int num = 0; CustomBinding customBinding = SbmpProtocolDefaults.CreateBinding(false, false, 2147483647, useSslStreamSecurity, endpointIdentity); DuplexRequestBindingElement duplexRequestBindingElement = new DuplexRequestBindingElement() { IncludeExceptionDetails = includeExceptionDetails, ClientMode = this.clientMode }; DuplexRequestBindingElement duplexRequestBindingElement1 = duplexRequestBindingElement; int num1 = num; num = num1 + 1; customBinding.Elements.Insert(num1, duplexRequestBindingElement1); BindingParameterCollection bindingParameterCollection = new BindingParameterCollection(); if (useSslStreamSecurity) { ClientCredentials clientCredential = new ClientCredentials(); clientCredential.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.Custom; clientCredential.ServiceCertificate.Authentication.CustomCertificateValidator = RetriableCertificateValidator.Instance; if (SoapProtocolDefaults.IsAvailableClientCertificateThumbprint(out str)) { clientCredential.ClientCertificate.SetCertificate(StoreLocation.LocalMachine, StoreName.My, X509FindType.FindByThumbprint, str); } bindingParameterCollection.Add(clientCredential); } this.MessageVersion = customBinding.MessageVersion; return(customBinding.BuildChannelFactory <IRequestSessionChannel>(bindingParameterCollection)); }
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; }
public AcceptMessageSessionAsyncResult(SbmpMessagingFactory messagingFactory, string entityName, string sessionId, MessagingEntityType?entityType, ReceiveMode receiveMode, int prefetchCount, Lazy <SbmpMessageCreator> controlMessageCreator, RetryPolicy retryPolicy, TimeSpan serverWaitTime, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.prefetchCount = prefetchCount; this.sessionId = sessionId; this.MessagingFactory = messagingFactory; this.retryPolicy = retryPolicy ?? messagingFactory.RetryPolicy.Clone(); LinkInfo linkInfo = new LinkInfo() { LinkId = messagingFactory.GetNextLinkId(), ConnectionId = messagingFactory.ConnectionId, LinkType = LinkType.Receive, IsSessionReceiver = true, ReceiveMode = receiveMode, EntityName = entityName, EntityType = entityType }; this.createLinkSettings = new CreateLinkSettings(messagingFactory, entityName, entityName, linkInfo, controlMessageCreator); AcceptMessageSessionCommand acceptMessageSessionCommand = new AcceptMessageSessionCommand() { SessionId = this.sessionId, Timeout = serverWaitTime, OperationTimeout = timeout, PrefetchCount = this.prefetchCount }; AcceptMessageSessionCommand acceptMessageSessionCommand1 = acceptMessageSessionCommand; string linkId = null; if (this.createLinkSettings.ControlMessageCreator != null && !string.IsNullOrWhiteSpace(this.createLinkSettings.ControlMessageCreator.Value.LinkInfo.LinkId)) { linkId = this.createLinkSettings.ControlMessageCreator.Value.LinkInfo.LinkId; } RequestInfo requestInfo = new RequestInfo() { ServerTimeout = new TimeSpan?(acceptMessageSessionCommand1.Timeout), SessionId = acceptMessageSessionCommand1.SessionId }; RequestInfo requestInfo1 = requestInfo; Message message = this.createLinkSettings.MessageCreator.CreateWcfMessage("http://schemas.microsoft.com/netservices/2011/06/servicebus/SbmpMessageReceiver/AcceptMessageSession", acceptMessageSessionCommand1, linkId, this.retryPolicy, null, requestInfo1); if (base.SyncContinue(this.MessagingFactory.Channel.BeginRequest(message, SbmpProtocolDefaults.BufferTimeout(timeout, this.MessagingFactory.GetSettings().EnableAdditionalClientTimeout), base.PrepareAsyncCompletion(AcceptMessageSessionAsyncResult.operationComplete), this))) { base.Complete(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; }
private void Initialize(bool useWebStream, bool useHttpsWebStream, IEnumerable <Uri> baseAddresses) { List <Uri> uris = new List <Uri>(); foreach (Uri baseAddress in baseAddresses) { if (base.Address == null) { base.Address = baseAddress; } UriBuilder uriBuilder = new UriBuilder(baseAddress); if (!this.Settings.GatewayMode && string.Compare(uriBuilder.Scheme, "sb", StringComparison.OrdinalIgnoreCase) != 0) { ExceptionTrace exception = Microsoft.ServiceBus.Messaging.FxTrace.Exception; string invalidUriScheme = Resources.InvalidUriScheme; object[] scheme = new object[] { uriBuilder.Scheme, "sb" }; throw exception.AsError(new ArgumentException(Microsoft.ServiceBus.SR.GetString(invalidUriScheme, scheme)), null); } if (!useWebStream) { uriBuilder.Scheme = SbmpProtocolDefaults.TransportUriScheme; } else { uriBuilder.Scheme = "sb"; uriBuilder.Port = (useHttpsWebStream ? RelayEnvironment.RelayHttpsPort : RelayEnvironment.RelayHttpPort); } if (!this.Settings.GatewayMode && uriBuilder.Port == -1) { if (!useWebStream) { uriBuilder.Port = RelayEnvironment.RelayNmfPort; } else { uriBuilder.Port = (useHttpsWebStream ? RelayEnvironment.RelayHttpsPort : RelayEnvironment.RelayHttpPort); } } MessagingUtilities.EnsureTrailingSlash(uriBuilder); uris.Add(uriBuilder.Uri); } this.baseAddresses = null; this.BaseAddress = uris.First <Uri>(); bool useSslStreamSecurity = this.Settings.UseSslStreamSecurity; CustomBinding customBinding = SbmpProtocolDefaults.CreateBinding(false, useWebStream, useHttpsWebStream, 2147483647, useSslStreamSecurity, this.Settings.EndpointIdentity); DuplexRequestBindingElement duplexRequestBindingElement = new DuplexRequestBindingElement() { ClientMode = !this.Settings.GatewayMode, IncludeExceptionDetails = true }; DuplexRequestBindingElement duplexRequestBindingElement1 = duplexRequestBindingElement; int num = 0; if (!this.Settings.GatewayMode) { RedirectBindingElement redirectBindingElement = new RedirectBindingElement() { EnableRedirect = this.Settings.EnableRedirect, UseSslStreamSecurity = useSslStreamSecurity, IncludeExceptionDetails = true, EndpointIdentity = this.Settings.EndpointIdentity }; RedirectBindingElement redirectBindingElement1 = redirectBindingElement; int num1 = num; num = num1 + 1; customBinding.Elements.Insert(num1, new ReconnectBindingElement(uris)); int num2 = num; num = num2 + 1; customBinding.Elements.Insert(num2, redirectBindingElement1); } int num3 = num; num = num3 + 1; customBinding.Elements.Insert(num3, new ReconnectBindingElement(uris)); int num4 = num; num = num4 + 1; customBinding.Elements.Insert(num4, duplexRequestBindingElement1); BindingParameterCollection bindingParameterCollection = new BindingParameterCollection(); if (useSslStreamSecurity) { ClientCredentials clientCredential = new ClientCredentials(); clientCredential.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.Custom; clientCredential.ServiceCertificate.Authentication.CustomCertificateValidator = RetriableCertificateValidator.Instance; bindingParameterCollection.Add(clientCredential); } this.ChannelFactory = customBinding.BuildChannelFactory <IRequestSessionChannel>(bindingParameterCollection); this.MessageVersion = customBinding.MessageVersion; this.ResourceManager = SbmpResourceManager.Instance; this.acceptMessageSessionForNamespaceLinkSettings = new CreateControlLinkSettings(this, string.Empty, "||", MessagingEntityType.Namespace, null); EventHandler eventHandler = new EventHandler(this.OnInnerFactoryFaulted); this.ChannelFactory.SafeAddFaulted(eventHandler); }
public void Start() { lock (this.transactionEnlistment.resourceManager.syncRoot) { this.transactionEnlistment.resourceManager.enlistmentMap.Remove(this.transactionEnlistment.transactionId); } try { CompleteTransactionCommand completeTransactionCommand = new CompleteTransactionCommand() { TransactionId = this.transactionEnlistment.transactionId, Timeout = SbmpResourceManager.TransactionEnlistment.rollbackTimeout, Commit = this.commit }; RequestInfo nullable = this.transactionEnlistment.RequestInfo.Clone(); nullable.ServerTimeout = new TimeSpan?(completeTransactionCommand.Timeout); nullable.TransactionId = completeTransactionCommand.TransactionId; Message message = this.transactionEnlistment.messageCreator.CreateWcfMessage("http://schemas.microsoft.com/netservices/2011/06/servicebus/SbmpConnection/CompleteTransaction", completeTransactionCommand, nullable); WorkUnitInfo.AddTo(message.Headers, "TxnWorkUnit", completeTransactionCommand.TransactionId, this.transactionEnlistment.GetNextSequenceNumber()); IAsyncResult asyncResult = this.transactionEnlistment.channel.BeginRequest(message, SbmpProtocolDefaults.BufferTimeout(SbmpResourceManager.TransactionEnlistment.rollbackTimeout, this.transactionEnlistment.messageCreator.DisableClientOperationTimeBuffer), SbmpResourceManager.TransactionEnlistment.CompleteTransactionHelper.operationCallback, this); if (asyncResult.CompletedSynchronously) { this.OperationComplete(asyncResult); } } catch (Exception exception1) { Exception exception = exception1; if (Fx.IsFatal(exception)) { throw; } this.OnError(exception); } }
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 <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 <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); }
private IAsyncResult BeginPeekCommand(TrackingContext trackingContext, long fromSequenceNumber, int messageCount, TimeSpan timeout, AsyncCallback callback, object state) { IAsyncResult asyncResult; try { PeekCommand peekCommand = new PeekCommand() { FromSequenceNumber = fromSequenceNumber, MessageCount = messageCount, Timeout = timeout, MessageVersion = BrokeredMessage.MessageVersion }; PeekCommand peekCommand1 = peekCommand; RequestInfo requestInfo = new RequestInfo() { ServerTimeout = new TimeSpan?(peekCommand1.Timeout), SequenceNumber = new long?(peekCommand1.FromSequenceNumber), MessageCount = new int?(peekCommand1.MessageCount) }; RequestInfo requestInfo1 = requestInfo; Message message = this.MessageCreator.CreateWcfMessage("http://schemas.microsoft.com/netservices/2011/06/servicebus/SbmpMessageBrowser/Peek", peekCommand1, null, base.RetryPolicy, trackingContext, requestInfo1); asyncResult = this.SbmpMessagingFactory.Channel.BeginRequest(message, SbmpProtocolDefaults.BufferTimeout(timeout, this.SbmpMessagingFactory.GetSettings().EnableAdditionalClientTimeout), callback, state); } catch (CommunicationException communicationException1) { CommunicationException communicationException = communicationException1; throw Microsoft.ServiceBus.Messaging.FxTrace.Exception.AsError(MessagingExceptionHelper.Unwrap(communicationException, base.IsClosedOrClosing), null); } catch (Exception exception1) { Exception exception = exception1; if (!Fx.IsFatal(exception) && base.IsClosedOrClosing) { throw new OperationCanceledException(SRClient.EntityClosedOrAborted, exception); } throw; } return(asyncResult); }
public static CustomBinding CreateBinding(bool portSharingEnabled, bool useWebStream, int maxReceivedMessageSize, bool useSslStreamSecurity, DnsEndpointIdentity endpointIdentity) { return(SbmpProtocolDefaults.CreateBinding(portSharingEnabled, useWebStream, false, maxReceivedMessageSize, useSslStreamSecurity, endpointIdentity)); }
public AcceptMessageSessionBrowserAsyncResult(SbmpBrowsableMessageSession messageSession, SbmpMessagingFactory messagingFactory, MessagingEntityType?entityType, ReceiveMode receiveMode, int prefetchCount, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.messageSession = messageSession; this.sessionId = messageSession.SessionId; this.MessagingFactory = messagingFactory; string path = messageSession.Path; LinkInfo linkInfo = new LinkInfo() { LinkId = messagingFactory.GetNextLinkId(), ConnectionId = messagingFactory.ConnectionId, LinkType = LinkType.Receive, IsSessionReceiver = true, ReceiveMode = receiveMode, EntityName = path, EntityType = entityType, SessionId = messageSession.SessionId }; this.createLinkSettings = new CreateLinkSettings(messagingFactory, path, path, linkInfo, null); AcceptMessageSessionCommand acceptMessageSessionCommand = new AcceptMessageSessionCommand() { SessionId = this.sessionId, Timeout = timeout, PrefetchCount = prefetchCount, IsSessionBrowser = true }; AcceptMessageSessionCommand acceptMessageSessionCommand1 = acceptMessageSessionCommand; RequestInfo requestInfo = new RequestInfo() { ServerTimeout = new TimeSpan?(acceptMessageSessionCommand1.Timeout), SessionId = acceptMessageSessionCommand1.SessionId }; RequestInfo requestInfo1 = requestInfo; Message message = this.createLinkSettings.MessageCreator.CreateWcfMessage("http://schemas.microsoft.com/netservices/2011/06/servicebus/SbmpMessageReceiver/AcceptMessageSession", acceptMessageSessionCommand1, null, this.messageSession.RetryPolicy, null, requestInfo1); if (base.SyncContinue(this.MessagingFactory.Channel.BeginRequest(message, SbmpProtocolDefaults.BufferTimeout(timeout, this.MessagingFactory.GetSettings().EnableAdditionalClientTimeout), base.PrepareAsyncCompletion(AcceptMessageSessionBrowserAsyncResult.operationComplete), this))) { base.Complete(true); } }
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; } } }
internal EndpointAddress CreateEndpointAddress(string entityName) { return(new EndpointAddress(this.CreateUri(entityName), SbmpProtocolDefaults.GetEndpointIdentity(this.BaseAddress), new AddressHeader[0])); }
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)); } }
public AcceptMessageSessionForNamespaceAsyncResult(SbmpMessagingFactory messagingFactory, ReceiveMode receiveMode, int prefetchCount, CreateControlLinkSettings controlLinkSettings, TimeSpan serverWaitTime, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { this.MessagingFactory = messagingFactory; this.controlLinkSettings = controlLinkSettings; this.receiveMode = receiveMode; AcceptMessageSessionForNamespaceCommand acceptMessageSessionForNamespaceCommand = new AcceptMessageSessionForNamespaceCommand() { PrefetchCount = prefetchCount, ReceiveMode = receiveMode, Timeout = serverWaitTime, OperationTimeout = timeout }; AcceptMessageSessionForNamespaceCommand acceptMessageSessionForNamespaceCommand1 = acceptMessageSessionForNamespaceCommand; RequestInfo requestInfo = new RequestInfo() { ServerTimeout = new TimeSpan?(acceptMessageSessionForNamespaceCommand1.Timeout), OperationTimeout = new TimeSpan?(acceptMessageSessionForNamespaceCommand1.OperationTimeout) }; RequestInfo requestInfo1 = requestInfo; Message message = this.controlLinkSettings.MessageCreator.CreateWcfMessage("http://schemas.microsoft.com/netservices/2011/06/servicebus/SbmpConnection/AcceptMessageSessionForNamespace", acceptMessageSessionForNamespaceCommand1, null, this.MessagingFactory.RetryPolicy, null, requestInfo1); if (base.SyncContinue(this.MessagingFactory.Channel.BeginRequest(message, SbmpProtocolDefaults.BufferTimeout(timeout, this.MessagingFactory.GetSettings().EnableAdditionalClientTimeout), base.PrepareAsyncCompletion(AcceptMessageSessionForNamespaceAsyncResult.operationComplete), this))) { base.Complete(true); } }