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
- UnsafeNativeMethods.cs
- StateFinalizationActivity.cs
- MetafileHeaderWmf.cs
- XmlParser.cs
- IsolatedStorage.cs
- ApplicationServiceHelper.cs
- ILGenerator.cs
- FolderBrowserDialogDesigner.cs
- HostExecutionContextManager.cs
- TileBrush.cs
- DataRowView.cs
- AttributeAction.cs
- BackgroundFormatInfo.cs
- RectAnimation.cs
- Parser.cs
- HierarchicalDataBoundControl.cs
- CompModHelpers.cs
- SchemaImporterExtensionElement.cs
- PerformanceCounterManager.cs
- LayoutSettings.cs
- ScriptingSectionGroup.cs
- ExpressionDumper.cs
- ModelItemExtensions.cs
- InvokeWebServiceDesigner.cs
- RawStylusInputCustomDataList.cs
- SendMailErrorEventArgs.cs
- CommandID.cs
- SmtpNetworkElement.cs
- RangeValuePattern.cs
- HttpAsyncResult.cs
- ShutDownListener.cs
- XmlSchemaInclude.cs
- ConnectionStringsExpressionBuilder.cs
- PasswordDeriveBytes.cs
- CommunicationException.cs
- ReservationNotFoundException.cs
- localization.cs
- BreakRecordTable.cs
- TypeValidationEventArgs.cs
- PrintController.cs
- FormsAuthenticationConfiguration.cs
- DataListItem.cs
- EventWaitHandle.cs
- Drawing.cs
- IntranetCredentialPolicy.cs
- DoubleCollectionValueSerializer.cs
- MdiWindowListStrip.cs
- XPathExpr.cs
- SqlDependency.cs
- EdmToObjectNamespaceMap.cs
- AccessedThroughPropertyAttribute.cs
- ISSmlParser.cs
- DoubleLinkList.cs
- GradientBrush.cs
- FrameworkRichTextComposition.cs
- QilValidationVisitor.cs
- TextElementCollection.cs
- HitTestParameters3D.cs
- WebEventTraceProvider.cs
- VBIdentifierName.cs
- MD5.cs
- GroupByExpressionRewriter.cs
- RequestCacheEntry.cs
- RuleSettings.cs
- AuthenticationServiceManager.cs
- ToolStripContentPanelRenderEventArgs.cs
- RectAnimation.cs
- WindowsPen.cs
- Substitution.cs
- DocumentPaginator.cs
- InvalidPrinterException.cs
- ManagementQuery.cs
- TabItem.cs
- TextComposition.cs
- XmlSerializerNamespaces.cs
- ApplicationInterop.cs
- HttpModuleCollection.cs
- TreeViewEvent.cs
- IsolatedStorage.cs
- MetadataItemEmitter.cs
- TdsParserSafeHandles.cs
- CheckBoxStandardAdapter.cs
- Label.cs
- CodeArrayIndexerExpression.cs
- BitmapMetadataBlob.cs
- TransactionProtocolConverter.cs
- AttributedMetaModel.cs
- EnumType.cs
- PointAnimationUsingKeyFrames.cs
- AgileSafeNativeMemoryHandle.cs
- __TransparentProxy.cs
- EntityTemplateFactory.cs
- SqlDataReader.cs
- HandleValueEditor.cs
- GetPolicyDetailsRequest.cs
- BinaryObjectReader.cs
- List.cs
- RankException.cs
- TransportReplyChannelAcceptor.cs
- ActivationServices.cs