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
- MemberPathMap.cs
- HWStack.cs
- RequestTimeoutManager.cs
- XmlNamespaceManager.cs
- DesignerSerializationManager.cs
- ProfessionalColors.cs
- UnsafeNativeMethods.cs
- XpsFontSubsetter.cs
- DataGridViewDataConnection.cs
- SortKey.cs
- FixedPosition.cs
- WebPartZoneCollection.cs
- DesignTimeResourceProviderFactoryAttribute.cs
- SizeFConverter.cs
- DashStyle.cs
- SqlFacetAttribute.cs
- FormatConvertedBitmap.cs
- DbProviderFactory.cs
- ClientCredentials.cs
- Binding.cs
- HtmlElementEventArgs.cs
- EventTrigger.cs
- CacheForPrimitiveTypes.cs
- WinFormsSecurity.cs
- HttpProtocolImporter.cs
- EmptyEnumerator.cs
- PhoneCall.cs
- SlipBehavior.cs
- PointCollection.cs
- CqlParser.cs
- Automation.cs
- AspCompat.cs
- _Win32.cs
- HuffModule.cs
- PointLight.cs
- Authorization.cs
- WebReferencesBuildProvider.cs
- DefaultBinder.cs
- RSAPKCS1KeyExchangeDeformatter.cs
- MsmqReceiveHelper.cs
- OutputWindow.cs
- VisemeEventArgs.cs
- PropertyInformationCollection.cs
- WindowsScrollBarBits.cs
- MemberInfoSerializationHolder.cs
- GlyphTypeface.cs
- QilParameter.cs
- ProfessionalColors.cs
- QueryReaderSettings.cs
- Setter.cs
- KeyConverter.cs
- ToolStripRenderer.cs
- HwndTarget.cs
- OleDbErrorCollection.cs
- exports.cs
- ClientTargetSection.cs
- SortDescription.cs
- ReaderContextStackData.cs
- HttpCookieCollection.cs
- UserUseLicenseDictionaryLoader.cs
- RotationValidation.cs
- ResourceReferenceKeyNotFoundException.cs
- DataContractFormatAttribute.cs
- AspCompat.cs
- BeginGetFileNameFromUserRequest.cs
- NotFiniteNumberException.cs
- ExceptionUtil.cs
- AssemblyCacheEntry.cs
- OrderedDictionary.cs
- ReflectionPermission.cs
- HScrollBar.cs
- CommonObjectSecurity.cs
- CustomAttributeFormatException.cs
- RsaKeyGen.cs
- SRGSCompiler.cs
- ObjectItemConventionAssemblyLoader.cs
- LabelEditEvent.cs
- CFStream.cs
- LabelLiteral.cs
- EtwTrackingParticipant.cs
- SystemNetHelpers.cs
- ListManagerBindingsCollection.cs
- ImmComposition.cs
- EntityViewGenerationConstants.cs
- GridLength.cs
- VersionValidator.cs
- shaperfactory.cs
- ChangeNode.cs
- BaseCollection.cs
- DataBoundControlAdapter.cs
- DataGridViewAutoSizeModeEventArgs.cs
- XmlSchemaObject.cs
- ConnectionProviderAttribute.cs
- RTTrackingProfile.cs
- HttpPostedFile.cs
- LocalIdKeyIdentifierClause.cs
- Pair.cs
- PictureBoxDesigner.cs
- NavigationProgressEventArgs.cs
- SoapServerMethod.cs