Code:
/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / TransactionBridge / Microsoft / Transactions / Wsat / InputOutput / Registration.cs / 1 / Registration.cs
//------------------------------------------------------------------------------ // Copyright (c) Microsoft Corporation. All rights reserved. //----------------------------------------------------------------------------- // This file implements registration-related messaging using System; using System.ServiceModel.Channels; using System.Diagnostics; using System.ServiceModel; using System.ServiceModel.Security; using System.ServiceModel.Transactions; using System.Xml; using Microsoft.Transactions.Bridge; using Microsoft.Transactions.Wsat.Messaging; using Microsoft.Transactions.Wsat.Protocol; using Microsoft.Transactions.Wsat.StateMachines; using DiagnosticUtility = Microsoft.Transactions.Bridge.DiagnosticUtility; using Fault = Microsoft.Transactions.Wsat.Messaging.Fault; namespace Microsoft.Transactions.Wsat.InputOutput { class RegistrationCoordinator : IRegistrationCoordinator { ProtocolState state; public RegistrationCoordinator (ProtocolState state) { this.state = state; } // // IRegistrationCoordinator // public void Register (Message message, RequestAsyncResult result) { // Unmarshal the message Register register = new Register (message, this.state.ProtocolVersion); EndpointAddress to = register.ParticipantProtocolService; WsatRegistrationHeader registrationHeader = WsatRegistrationHeader.ReadFrom(message); if (registrationHeader == null) { if (DebugTrace.Warning) { DebugTrace.Trace(TraceLevel.Warning, "Rejecting Register message with no registration header"); } this.SendFault(result, this.state.Faults.InvalidParameters); return; } switch (register.Protocol) { case ControlProtocol.Completion: // We only accept a registration for completion if we have an enlistment already TransactionEnlistment enlistment; enlistment = state.Lookup.FindEnlistment(registrationHeader.TransactionId); CompletionEnlistment completion = enlistment as CompletionEnlistment; if (completion == null) { if (DebugTrace.Warning) { DebugTrace.Trace(TraceLevel.Warning, "Rejecting uncorrelated Register message for completion"); } this.SendFault(result, this.state.Faults.UnknownCompletionEnlistment); return; } CompletionParticipantProxy completionProxy = state.TryCreateCompletionParticipantProxy (to); if (completionProxy == null) { if (DebugTrace.Warning) { DebugTrace.Trace(TraceLevel.Warning, "Rejecting Register message for completion on no completion enlistment"); } this.SendFault(result, this.state.Faults.InvalidParameters); return; } try { completion.StateMachine.Enqueue(new MsgRegisterCompletionEvent(completion, ref register, result, completionProxy)); } finally { completionProxy.Release(); } break; case ControlProtocol.Durable2PC: case ControlProtocol.Volatile2PC: // If OutboundTransactions are disabled, we don't accept new participants if (!state.TransactionManager.Settings.NetworkOutboundAccess) { if (DebugTrace.Warning) { DebugTrace.Trace(TraceLevel.Warning, "Rejecting Register message because outbound transactions are disabled"); } this.SendFault(result, this.state.Faults.ParticipantRegistrationNetAccessDisabled); return; } // Check for loopback (i.e., we sent a register message to ourselves) if (register.Loopback == state.ProcessId) { if (DebugTrace.Warning) { DebugTrace.Trace(TraceLevel.Warning, "Rejecting recursive Register message from self"); } this.SendFault(result, this.state.Faults.ParticipantRegistrationLoopback); return; } // Attempt to resolve the proxy TwoPhaseCommitParticipantProxy proxy = state.TryCreateTwoPhaseCommitParticipantProxy (to); if (proxy == null) { if (DebugTrace.Warning) { DebugTrace.Trace(TraceLevel.Warning, "Rejecting Register message because 2PC proxy could not be created"); } this.SendFault(result, this.state.Faults.InvalidParameters); return; } try { // Create a new participant enlistment ParticipantEnlistment participant = new ParticipantEnlistment(state, registrationHeader, register.Protocol, proxy); state.TransactionManagerSend.Register(participant, new MsgRegisterEvent(participant, ref register, result)); } finally { proxy.Release(); } break; default: // An invalid Enum value on this internal code path indicates // a product bug and violates assumptions about // valid values in MSDTC. DiagnosticUtility.FailFast("Registration protocol should have been validated"); break; } } // // Sending messages // public void SendRegisterResponse (TransactionEnlistment enlistment, RequestAsyncResult result, ControlProtocol protocol, EndpointAddress coordinatorService) { RegisterResponse response = new RegisterResponse(this.state.ProtocolVersion); response.CoordinatorProtocolService = coordinatorService; if (DebugTrace.Info) { DebugTrace.TxTrace ( TraceLevel.Info, enlistment.EnlistmentId, "Sending RegisterResponse for {0}", protocol ); } RegistrationProxy.SendRegisterResponse (result, ref response); } public void SendFault (RequestAsyncResult result, Fault fault) { if (DebugTrace.Warning) { DebugTrace.Trace(TraceLevel.Warning, "Sending {0} fault to registration participant", fault.Code.Name); } state.Perf.FaultsSentCountPerInterval.Increment(); RegistrationProxy.SendFaultResponse(result, fault); } } class RegistrationParticipant { ProtocolState state; AsyncCallback sendDurableRegisterComplete; AsyncCallback sendVolatileRegisterComplete; public RegistrationParticipant (ProtocolState state) { this.state = state; this.sendDurableRegisterComplete = DiagnosticUtility.ThunkAsyncCallback(new AsyncCallback(OnSendDurableRegisterComplete)); this.sendVolatileRegisterComplete = DiagnosticUtility.ThunkAsyncCallback(new AsyncCallback(OnSendVolatileRegisterComplete)); } // // Sending messages // void OnSendDurableRegisterComplete (IAsyncResult ar) { if (!ar.CompletedSynchronously) { OnSendRegisterComplete((CoordinatorEnlistment) ar.AsyncState, ControlProtocol.Durable2PC, ar); } } void OnSendVolatileRegisterComplete (IAsyncResult ar) { if (!ar.CompletedSynchronously) { VolatileCoordinatorEnlistment volatileCoordinator = (VolatileCoordinatorEnlistment) ar.AsyncState; OnSendRegisterComplete(volatileCoordinator.Coordinator, ControlProtocol.Volatile2PC, ar); } } void OnSendRegisterComplete(CoordinatorEnlistment coordinator, ControlProtocol protocol, IAsyncResult ar) { SynchronizationEvent newEvent; EndpointAddress coordinatorService = null; try { RegisterResponse response = coordinator.RegistrationProxy.EndSendRegister (ar); coordinatorService = response.CoordinatorProtocolService; TwoPhaseCommitCoordinatorProxy proxy; proxy = state.TryCreateTwoPhaseCommitCoordinatorProxy(coordinatorService); if (proxy == null) { if (RegistrationCoordinatorResponseInvalidMetadataRecord.ShouldTrace) { RegistrationCoordinatorResponseInvalidMetadataRecord.Trace( coordinator.EnlistmentId, coordinator.SuperiorContext, protocol, coordinatorService, null, this.state.ProtocolVersion ); } newEvent = new MsgRegistrationCoordinatorSendFailureEvent(coordinator); } else { try { if (protocol == ControlProtocol.Durable2PC) { newEvent = new MsgRegisterDurableResponseEvent(coordinator, response, proxy); } else { VolatileCoordinatorEnlistment volatileCoordinator = (VolatileCoordinatorEnlistment)ar.AsyncState; newEvent = new MsgRegisterVolatileResponseEvent(volatileCoordinator, response, proxy); } } finally { proxy.Release(); } } } catch (WsatFaultException e) { DiagnosticUtility.ExceptionUtility.TraceHandledException(e, TraceEventType.Warning); newEvent = new MsgRegistrationCoordinatorFaultEvent (coordinator, protocol, e.Fault); if (RegistrationCoordinatorFaultedRecord.ShouldTrace) { RegistrationCoordinatorFaultedRecord.Trace( coordinator.EnlistmentId, coordinator.SuperiorContext, protocol, e.Fault ); } } catch (WsatMessagingException e) { DiagnosticUtility.ExceptionUtility.TraceHandledException(e, TraceEventType.Warning); state.Perf.MessageSendFailureCountPerInterval.Increment(); if (RegistrationCoordinatorFailedRecord.ShouldTrace) { RegistrationCoordinatorFailedRecord.Trace( coordinator.EnlistmentId, coordinator.SuperiorContext, protocol, e ); } DebugTrace.TraceSendFailure(coordinator.EnlistmentId, e); newEvent = new MsgRegistrationCoordinatorSendFailureEvent(coordinator); } coordinator.StateMachine.Enqueue (newEvent); } public void SendDurableRegister(CoordinatorEnlistment coordinator) { SendRegister (coordinator, ControlProtocol.Durable2PC, coordinator.ParticipantService, this.sendDurableRegisterComplete, coordinator); } public void SendVolatileRegister(VolatileCoordinatorEnlistment volatileCoordinator) { SendRegister (volatileCoordinator.Coordinator, ControlProtocol.Volatile2PC, volatileCoordinator.ParticipantService, this.sendVolatileRegisterComplete, volatileCoordinator); } void SendRegister(CoordinatorEnlistment coordinator, ControlProtocol protocol, EndpointAddress protocolService, AsyncCallback callback, object callbackState) { Register register = new Register(this.state.ProtocolVersion); register.Protocol = protocol; register.Loopback = state.ProcessId; register.ParticipantProtocolService = protocolService; register.SupportingToken = coordinator.SuperiorIssuedToken; if (DebugTrace.Info) { DebugTrace.TxTrace ( TraceLevel.Info, coordinator.EnlistmentId, "Sending Register for {0} to {1}", protocol, Ports.TryGetAddress (coordinator.RegistrationProxy)); } IAsyncResult ar = coordinator.RegistrationProxy.BeginSendRegister (ref register, callback, callbackState); if (ar.CompletedSynchronously) { OnSendRegisterComplete(coordinator, protocol, ar); } } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- UpdateTranslator.cs
- DocumentsTrace.cs
- DesignerVerb.cs
- Aggregates.cs
- BitmapDownload.cs
- Window.cs
- SkipStoryboardToFill.cs
- CatalogZone.cs
- ScrollViewerAutomationPeer.cs
- KeyTimeConverter.cs
- CommunicationException.cs
- ExpressionLink.cs
- Root.cs
- HttpApplication.cs
- TabControlToolboxItem.cs
- UIPermission.cs
- SpellerStatusTable.cs
- ProcessModelSection.cs
- MaterialGroup.cs
- FlowLayoutPanel.cs
- MergablePropertyAttribute.cs
- IntranetCredentialPolicy.cs
- HandlerFactoryWrapper.cs
- RepeatButtonAutomationPeer.cs
- DescendantBaseQuery.cs
- returneventsaver.cs
- WebControlParameterProxy.cs
- ThreadPool.cs
- DataGridViewCellMouseEventArgs.cs
- CacheSection.cs
- PerformanceCounterManager.cs
- ChangeNode.cs
- Point3DAnimation.cs
- EntityObject.cs
- ClientSection.cs
- ContextMenuStrip.cs
- Utilities.cs
- rsa.cs
- Enlistment.cs
- ContextMenu.cs
- Site.cs
- PersonalizableAttribute.cs
- Input.cs
- log.cs
- StrongNamePublicKeyBlob.cs
- HtmlEmptyTagControlBuilder.cs
- FixedPage.cs
- HelpEvent.cs
- RSAPKCS1KeyExchangeFormatter.cs
- SweepDirectionValidation.cs
- SettingsProperty.cs
- CommaDelimitedStringAttributeCollectionConverter.cs
- MsmqAppDomainProtocolHandler.cs
- TimeSpanFormat.cs
- TypeUtil.cs
- XamlPathDataSerializer.cs
- InputScope.cs
- StaticContext.cs
- AsyncOperation.cs
- TypeLibConverter.cs
- StateWorkerRequest.cs
- ObjectListField.cs
- AnnotationResourceCollection.cs
- EnumType.cs
- SqlExpander.cs
- LinqDataSourceView.cs
- StorageAssociationTypeMapping.cs
- DesigntimeLicenseContextSerializer.cs
- OleAutBinder.cs
- FileEnumerator.cs
- ComponentCommands.cs
- ClientRuntimeConfig.cs
- ColumnTypeConverter.cs
- TraceContextEventArgs.cs
- WSTrustFeb2005.cs
- WebEventTraceProvider.cs
- ReferenceConverter.cs
- RoleService.cs
- RelationshipWrapper.cs
- ElementsClipboardData.cs
- ObjectPersistData.cs
- UriSection.cs
- SamlDelegatingWriter.cs
- SplitterEvent.cs
- FusionWrap.cs
- CursorInteropHelper.cs
- SqlConnectionString.cs
- EventLogInternal.cs
- TableHeaderCell.cs
- EntityDataSourceQueryBuilder.cs
- SHA384.cs
- CharConverter.cs
- TemplateParser.cs
- WebSysDefaultValueAttribute.cs
- IDictionary.cs
- BindableTemplateBuilder.cs
- AnyReturnReader.cs
- TraceFilter.cs
- StringStorage.cs
- ParserExtension.cs