private void ConfigureEnlistment(WsatRegistrationHeader header) { Enlistment enlistment = new Enlistment(); string contextId = header.ContextId; if (contextId == null) { contextId = CoordinationContext.CreateNativeIdentifier(header.TransactionId); } enlistment.LocalTransactionId = header.TransactionId; enlistment.RemoteTransactionId = contextId; Notifications twoPhaseCommit = Notifications.TwoPhaseCommit; switch (this.protocol) { case Microsoft.Transactions.Wsat.Messaging.ControlProtocol.Volatile2PC: twoPhaseCommit |= Notifications.Volatile | Notifications.Phase0; break; case Microsoft.Transactions.Wsat.Messaging.ControlProtocol.Durable2PC: break; default: Microsoft.Transactions.Bridge.DiagnosticUtility.FailFast("Invalid protocol"); break; } enlistment.NotificationMask = twoPhaseCommit; enlistment.ProtocolProviderContext = this; base.enlistment = enlistment; }
public void MarshalAsCoordinationContext(Transaction transaction, out CoordinationContext context, out RequestSecurityTokenResponse issuedToken) { uint num; IsolationFlags flags; string str2; WsatExtendedInformation information; string str3; Guid distributedIdentifier = transaction.TransactionInformation.DistributedIdentifier; string contextId = null; context = new CoordinationContext(this.protocolVersion); OleTxTransactionFormatter.GetTransactionAttributes(transaction, out num, out flags, out str2); context.IsolationFlags = flags; context.Description = str2; if (TransactionCache <Transaction, WsatExtendedInformation> .Find(transaction, out information)) { context.Expires = information.Timeout; if (!string.IsNullOrEmpty(information.Identifier)) { context.Identifier = information.Identifier; contextId = information.Identifier; } } else { context.Expires = num; if (context.Expires == 0) { context.Expires = (uint)TimeoutHelper.ToMilliseconds(this.wsatConfig.MaxTimeout); } } if (context.Identifier == null) { context.Identifier = CoordinationContext.CreateNativeIdentifier(distributedIdentifier); contextId = null; } if (!this.wsatConfig.IssuedTokensEnabled) { str3 = null; issuedToken = null; } else { CoordinationServiceSecurity.CreateIssuedToken(distributedIdentifier, context.Identifier, this.protocolVersion, out issuedToken, out str3); } AddressHeader refParam = new WsatRegistrationHeader(distributedIdentifier, contextId, str3); context.RegistrationService = this.wsatConfig.CreateRegistrationService(refParam, this.protocolVersion); context.IsolationLevel = transaction.IsolationLevel; context.LocalTransactionId = distributedIdentifier; if (this.wsatConfig.OleTxUpgradeEnabled) { context.PropagationToken = TransactionInterop.GetTransmitterPropagationToken(transaction); } }
public void OnRootTransactionCreated() { base.enlistmentId = base.enlistment.LocalTransactionId; base.enlistment.RemoteTransactionId = CoordinationContext.CreateNativeIdentifier(base.enlistmentId); EnlistmentHeader refParam = new EnlistmentHeader(base.enlistmentId); this.coordinatorService = base.state.CompletionCoordinatorListener.CreateEndpointReference(refParam); base.ourContextManager = new TransactionContextManager(base.state, base.enlistment.RemoteTransactionId); base.state.Lookup.AddTransactionContextManager(base.ourContextManager); base.ActivateTransactionContextManager(base.ourContextManager); base.AddToLookupTable(); base.VerifyAndTraceEnlistmentOptions(); base.TraceTransferEvent(); }
public override LogEntry DeserializeHeader() { string str; LogEntryHeaderv1Flags flags = (LogEntryHeaderv1Flags)SerializationUtils.ReadByte(base.mem); if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "DeserializeHeader flags: {0}", flags); } this.CheckFlags(flags); if (((byte)(flags & LogEntryHeaderv1Flags.StandardRemoteTransactionId)) == 0) { str = SerializationUtils.ReadString(base.mem); } else { str = CoordinationContext.CreateNativeIdentifier(this.localTransactionId); } return(new LogEntry(str, this.localTransactionId, SerializationUtils.ReadGuid(base.mem))); }
//======================================================================================= // The demand is not added now (in 4.5), to avoid a breaking change. To be considered in the next version. /* * // We demand full trust because we use CoordinationContext and CoordinationServiceSecurity from a non-APTCA assembly. * // The CoordinationContext constructor can call Environment.FailFast and it's recommended to not let partially trusted callers to bring down the process. * // WSATs are not supported in partial trust, so customers should not be broken by this demand. * [PermissionSet(SecurityAction.Demand, Unrestricted = true)] */ public void MarshalAsCoordinationContext(Transaction transaction, out CoordinationContext context, out RequestSecurityTokenResponse issuedToken) { Guid transactionId = transaction.TransactionInformation.DistributedIdentifier; string nonNativeContextId = null; context = new CoordinationContext(this.protocolVersion); // Get timeout, description and isolation flags uint timeout; IsolationFlags isoFlags; string description; OleTxTransactionFormatter.GetTransactionAttributes(transaction, out timeout, out isoFlags, out description); context.IsolationFlags = isoFlags; context.Description = description; // If we can, use cached extended information // Note - it may be worth using outgoing contexts more than once. // We'll let performance profiling decide that question WsatExtendedInformation info; if (WsatExtendedInformationCache.Find(transaction, out info)) { context.Expires = info.Timeout; // The extended info cache only contains an identifier when it's non-native if (!string.IsNullOrEmpty(info.Identifier)) { context.Identifier = info.Identifier; nonNativeContextId = info.Identifier; } } else { context.Expires = timeout; if (context.Expires == 0) { // If the timeout is zero, there are two possibilities: // 1) This is a root transaction with an infinite timeout. // 2) This is a subordinate transaction whose timeout was not flowed. // We have no mechanism for distinguishing between the two cases. // // We could always return zero here, instead of using the local max timeout. // The problem is that the 2004/08 WS-C spec does not specify the meaning // of a zero expires field. While we accept zero to mean "as large as possible" // it would be risky to expect others to do the same. So we only propagate // zero in the expires field if the local max timeout has been disabled. // // This is MB 34596: how can we flow the real timeout? context.Expires = (uint)TimeoutHelper.ToMilliseconds(this.wsatConfig.MaxTimeout); } } if (context.Identifier == null) { context.Identifier = CoordinationContext.CreateNativeIdentifier(transactionId); nonNativeContextId = null; } string tokenId; if (!this.wsatConfig.IssuedTokensEnabled) { tokenId = null; issuedToken = null; } else { CoordinationServiceSecurity.CreateIssuedToken(transactionId, context.Identifier, this.protocolVersion, out issuedToken, out tokenId); } AddressHeader refParam = new WsatRegistrationHeader(transactionId, nonNativeContextId, tokenId); context.RegistrationService = wsatConfig.CreateRegistrationService(refParam, this.protocolVersion); context.IsolationLevel = transaction.IsolationLevel; context.LocalTransactionId = transactionId; if (this.wsatConfig.OleTxUpgradeEnabled) { context.PropagationToken = TransactionInterop.GetTransmitterPropagationToken(transaction); } }