public static CoordinationContext ReadFrom(XmlDictionaryReader reader, XmlDictionaryString localName, XmlDictionaryString ns, Microsoft.Transactions.Wsat.Protocol.ProtocolVersion protocolVersion) { CoordinationContext that = new CoordinationContext(protocolVersion); ReadFrom(that, reader, localName, ns, protocolVersion); return(that); }
// 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 call into CoordinationStrings.Version(..), which is defined in a non-APTCA assembly and does an Environment.FailFast // if the argument is invalid. 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 WsatTransactionHeader(CoordinationContext context, ProtocolVersion protocolVersion) { this.context = context; CoordinationStrings coordinationStrings = CoordinationStrings.Version(protocolVersion); this.wsatHeaderElement = coordinationStrings.CoordinationContext; this.wsatNamespace = coordinationStrings.Namespace; }
// 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 call into CoordinationContext and CoordinationStrings, which are defined in a non-APTCA assembly. Also, CoordinationStrings.Version(..) // does an Environment.FailFast if the argument is invalid. 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 static CoordinationContext GetCoordinationContext(Message message, ProtocolVersion protocolVersion) { CoordinationStrings coordinationStrings = CoordinationStrings.Version(protocolVersion); string locWsatHeaderElement = coordinationStrings.CoordinationContext; string locWsatNamespace = coordinationStrings.Namespace; int index; try { index = message.Headers.FindHeader(locWsatHeaderElement, locWsatNamespace); } catch (MessageHeaderException e) { DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning); return null; } if (index < 0) return null; CoordinationContext context; XmlDictionaryReader reader = message.Headers.GetReaderAtHeader(index); using (reader) { context = GetCoordinationContext(reader, protocolVersion); } MessageHeaderInfo header = message.Headers[index]; if (!message.Headers.UnderstoodHeaders.Contains(header)) { message.Headers.UnderstoodHeaders.Add(header); } return context; }
public static CoordinationContext GetCoordinationContext(Message message, ProtocolVersion protocolVersion) { int num; CoordinationContext context; CoordinationStrings strings = CoordinationStrings.Version(protocolVersion); string coordinationContext = strings.CoordinationContext; string ns = strings.Namespace; try { num = message.Headers.FindHeader(coordinationContext, ns); } catch (MessageHeaderException exception) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); return null; } if (num < 0) { return null; } XmlDictionaryReader readerAtHeader = message.Headers.GetReaderAtHeader(num); using (readerAtHeader) { context = GetCoordinationContext(readerAtHeader, protocolVersion); } MessageHeaderInfo headerInfo = message.Headers[num]; if (!message.Headers.UnderstoodHeaders.Contains(headerInfo)) { message.Headers.UnderstoodHeaders.Add(headerInfo); } return context; }
public RegisterCoordinatorRecordSchema10(CoordinationContext context, ControlProtocol protocol, EndpointAddress coordinatorService) : base(context, protocol) { base.schemaId = "http://schemas.microsoft.com/2006/08/ServiceModel/RegisterCoordinatorTraceRecord"; if (coordinatorService != null) { this.coordinatorService = EndpointAddressAugust2004.FromEndpointAddress(coordinatorService); } }
public RegistrationCoordinatorResponseInvalidMetadataSchema11(CoordinationContext context, ControlProtocol protocol, EndpointAddress coordinatorService) : base(context, protocol) { base.schemaId = "http://schemas.microsoft.com/2006/08/ServiceModel/RegistrationCoordinatorResponseInvalidMetadata11TraceRecord"; if (coordinatorService != null) { this.coordinatorService = EndpointAddress10.FromEndpointAddress(coordinatorService); } }
public static void Trace(Guid enlistmentId, CoordinationContext context) { CoordinationContextRecordSchema extendedData = new CoordinationContextRecordSchema(context); if (DiagnosticUtility.ShouldTraceInformation) { TxTraceUtility.Trace(TraceEventType.Information, 0xb000b, Microsoft.Transactions.SR.GetString("EnlistTransaction"), extendedData, null, enlistmentId, null); } }
public WsatTransactionInfo(WsatProxy wsatProxy, CoordinationContext context, RequestSecurityTokenResponse issuedToken) { this.wsatProxy = wsatProxy; this.context = context; this.issuedToken = issuedToken; }
public CoordinatorEnlistment(ProtocolState state, TransactionContextManager contextManager, CoordinationContext context, RequestSecurityTokenResponse rstr) : base(state) { base.ourContextManager = contextManager; this.superiorContext = context; this.superiorRstr = rstr; this.ConfigureEnlistment(context); base.stateMachine = new CoordinatorStateMachine(this); base.stateMachine.ChangeState(state.States.CoordinatorInitializing); }
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); } }
private void ReadFrom(XmlDictionaryReader reader) { try { reader.ReadFullStartElement(this.coordinationXmlDictionaryStrings.CreateCoordinationContext, this.coordinationXmlDictionaryStrings.Namespace); if (reader.IsStartElement(this.coordinationXmlDictionaryStrings.Expires, this.coordinationXmlDictionaryStrings.Namespace)) { int num = reader.ReadElementContentAsInt(); if (num < 0) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"))); } this.expiration = (uint)num; this.expiresPresent = true; } if (reader.IsStartElement(this.coordinationXmlDictionaryStrings.CurrentContext, this.coordinationXmlDictionaryStrings.Namespace)) { this.CurrentContext = CoordinationContext.ReadFrom(reader, this.coordinationXmlDictionaryStrings.CurrentContext, this.coordinationXmlDictionaryStrings.Namespace, this.protocolVersion); } reader.MoveToStartElement(this.coordinationXmlDictionaryStrings.CoordinationType, this.coordinationXmlDictionaryStrings.Namespace); if (reader.ReadElementContentAsString().Trim() != this.atomicTransactionStrings.Namespace) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"))); } if (!reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.IsolationLevel, XD.DotNetAtomicTransactionExternalDictionary.Namespace)) { goto Label_016B; } this.IsolationLevel = (System.Transactions.IsolationLevel)reader.ReadElementContentAsInt(); if (((this.IsolationLevel >= System.Transactions.IsolationLevel.Serializable) && (this.IsolationLevel <= System.Transactions.IsolationLevel.Unspecified)) && (this.IsolationLevel != System.Transactions.IsolationLevel.Snapshot)) { goto Label_016B; } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"))); Label_0165: reader.Skip(); Label_016B: if (reader.IsStartElement()) { goto Label_0165; } reader.ReadEndElement(); } catch (XmlException exception) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"), exception)); } catch (InvalidCoordinationContextException exception2) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"), exception2)); } }
public CreateCoordinationContext(Microsoft.Transactions.Wsat.Protocol.ProtocolVersion protocolVersion) { this.expiration = 0; this.expiresPresent = false; this.CurrentContext = null; this.IssuedToken = null; this.IsolationLevel = System.Transactions.IsolationLevel.Serializable; this.protocolVersion = protocolVersion; this.coordinationXmlDictionaryStrings = CoordinationXmlDictionaryStrings.Version(protocolVersion); this.atomicTransactionXmlDictionaryStrings = AtomicTransactionXmlDictionaryStrings.Version(protocolVersion); this.atomicTransactionStrings = AtomicTransactionStrings.Version(protocolVersion); this.coordinationStrings = CoordinationStrings.Version(protocolVersion); }
private void ConfigureEnlistment(CoordinationContext context) { Enlistment enlistment = new Enlistment(); string identifier = context.Identifier; if (identifier == null) { Microsoft.Transactions.Bridge.DiagnosticUtility.FailFast("Need transactionId to create enlistment"); } enlistment.RemoteTransactionId = identifier; enlistment.LocalTransactionId = Ports.GetGuidFromTransactionId(identifier); enlistment.ProtocolProviderContext = this; base.enlistment = enlistment; }
public CreateCoordinationContext(Microsoft.Transactions.Wsat.Protocol.ProtocolVersion protocolVersion) { this.expiration = 0; this.expiresPresent = false; this.CurrentContext = null; this.IssuedToken = null; this.IsolationLevel = System.Transactions.IsolationLevel.Serializable; this.protocolVersion = protocolVersion; this.coordinationXmlDictionaryStrings = CoordinationXmlDictionaryStrings.Version(protocolVersion); this.atomicTransactionXmlDictionaryStrings = AtomicTransactionXmlDictionaryStrings.Version(protocolVersion); this.atomicTransactionStrings = AtomicTransactionStrings.Version(protocolVersion); this.coordinationStrings = CoordinationStrings.Version(protocolVersion); }
public static RegisterCoordinatorRecordSchema Instance(CoordinationContext context, ControlProtocol protocol, EndpointAddress coordinatorService, ProtocolVersion protocolVersion) { ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(RegisterCoordinatorRecordSchema), "Instance"); switch (protocolVersion) { case ProtocolVersion.Version10: return new RegisterCoordinatorRecordSchema10(context, protocol, coordinatorService); case ProtocolVersion.Version11: return new RegisterCoordinatorRecordSchema11(context, protocol, coordinatorService); } return null; }
public static CoordinationContext GetCoordinationContext(XmlDictionaryReader reader, ProtocolVersion protocolVersion) { CoordinationContext context; CoordinationXmlDictionaryStrings strings = CoordinationXmlDictionaryStrings.Version(protocolVersion); try { context = CoordinationContext.ReadFrom(reader, strings.CoordinationContext, strings.Namespace, protocolVersion); } catch (InvalidCoordinationContextException exception) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Error); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TransactionException(System.ServiceModel.SR.GetString("WsatHeaderCorrupt"), exception)); } return context; }
public static void CreateIssuedToken(Guid transactionId, string coordinationContextId, ProtocolVersion protocolVersion, out RequestSecurityTokenResponse issuedToken, out string sctId) { sctId = CoordinationContext.CreateNativeIdentifier(Guid.NewGuid()); byte[] key = DeriveIssuedTokenKey(transactionId, sctId); DateTime utcNow = DateTime.UtcNow; SecurityContextSecurityToken token = new SecurityContextSecurityToken(new UniqueId(sctId), key, utcNow, utcNow + TimeSpan.FromDays(36500.0)); BinarySecretSecurityToken token2 = new BinarySecretSecurityToken(key); SecurityStandardsManager standardsManager = CreateStandardsManager(protocolVersion); RequestSecurityTokenResponse response = new RequestSecurityTokenResponse(standardsManager) { TokenType = standardsManager.SecureConversationDriver.TokenTypeUri, RequestedUnattachedReference = SecurityContextSecurityTokenParameters.CreateKeyIdentifierClause(token, SecurityTokenReferenceStyle.External), RequestedAttachedReference = SecurityContextSecurityTokenParameters.CreateKeyIdentifierClause(token, SecurityTokenReferenceStyle.Internal), RequestedSecurityToken = token, RequestedProofToken = token2 }; DataContractSerializer serializer = IdentifierElementSerializer(protocolVersion); ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, typeof(CoordinationServiceSecurity), "CreateIssuedToken"); switch (protocolVersion) { case ProtocolVersion.Version10: response.SetAppliesTo <IdentifierElement10>(new IdentifierElement10(coordinationContextId), serializer); break; case ProtocolVersion.Version11: response.SetAppliesTo <IdentifierElement11>(new IdentifierElement11(coordinationContextId), serializer); break; } response.MakeReadOnly(); if (DebugTrace.Verbose) { DebugTrace.Trace(TraceLevel.Verbose, "Created issued token with id {0} for transaction {1}", sctId, transactionId); } issuedToken = response; }
private static void ReadFrom(CoordinationContext that, XmlDictionaryReader reader, XmlDictionaryString localName, XmlDictionaryString ns, Microsoft.Transactions.Wsat.Protocol.ProtocolVersion protocolVersion) { try { Uri uri; CoordinationXmlDictionaryStrings strings = CoordinationXmlDictionaryStrings.Version(protocolVersion); AtomicTransactionStrings strings2 = AtomicTransactionStrings.Version(protocolVersion); reader.ReadFullStartElement(localName, strings.Namespace); reader.MoveToStartElement(strings.Identifier, strings.Namespace); that.unknownIdentifierAttributes = ReadOtherAttributes(reader, strings.Namespace); that.contextId = reader.ReadElementContentAsString().Trim(); if ((that.contextId.Length == 0) || (that.contextId.Length > 0x100)) { throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext"))); } if (!Uri.TryCreate(that.contextId, UriKind.Absolute, out uri)) { throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext"))); } if (reader.IsStartElement(strings.Expires, strings.Namespace)) { that.unknownExpiresAttributes = ReadOtherAttributes(reader, strings.Namespace); int num = reader.ReadElementContentAsInt(); if (num < 0) { throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext"))); } that.expiration = (uint)num; that.expiresPresent = true; } reader.MoveToStartElement(strings.CoordinationType, strings.Namespace); if (reader.ReadElementContentAsString().Trim() != strings2.Namespace) { throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext"))); } that.registrationRef = EndpointAddress.ReadFrom(MessagingVersionHelper.AddressingVersion(protocolVersion), reader, strings.RegistrationService, strings.Namespace); if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.IsolationLevel, XD.DotNetAtomicTransactionExternalDictionary.Namespace)) { that.isoLevel = (System.Transactions.IsolationLevel)reader.ReadElementContentAsInt(); if (((that.IsolationLevel < System.Transactions.IsolationLevel.Serializable) || (that.IsolationLevel > System.Transactions.IsolationLevel.Unspecified)) || (that.IsolationLevel == System.Transactions.IsolationLevel.Snapshot)) { throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext"))); } } if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.IsolationFlags, XD.DotNetAtomicTransactionExternalDictionary.Namespace)) { that.isoFlags = (System.ServiceModel.Transactions.IsolationFlags)reader.ReadElementContentAsInt(); } if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.Description, XD.DotNetAtomicTransactionExternalDictionary.Namespace)) { that.description = reader.ReadElementContentAsString().Trim(); } if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.LocalTransactionId, XD.DotNetAtomicTransactionExternalDictionary.Namespace)) { that.localTxId = reader.ReadElementContentAsGuid(); } if (OleTxTransactionHeader.IsStartPropagationTokenElement(reader)) { that.propToken = OleTxTransactionHeader.ReadPropagationTokenElement(reader); } if (reader.IsStartElement()) { XmlDocument document = new XmlDocument(); that.unknownData = new List <System.Xml.XmlNode>(5); while (reader.IsStartElement()) { System.Xml.XmlNode item = document.ReadNode(reader); that.unknownData.Add(item); } } reader.ReadEndElement(); } catch (XmlException exception) { throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext"), exception)); } }
public TransactionContext(Microsoft.Transactions.Wsat.Messaging.CoordinationContext context, RequestSecurityTokenResponse issuedToken) { this.context = context; this.issuedToken = issuedToken; }
public static void Trace(Guid enlistmentId, CoordinationContext context, ControlProtocol protocol, Exception e) { RegistrationCoordinatorFailedSchema extendedData = new RegistrationCoordinatorFailedSchema(context, protocol); TxTraceUtility.Trace(TraceEventType.Warning, 0xb0007, Microsoft.Transactions.SR.GetString("RegistrationCoordinatorFailed"), extendedData, null, enlistmentId, null); }
public static void Trace(Guid enlistmentId, CoordinationContext context, ControlProtocol protocol, EndpointAddress coordinatorService, ProtocolVersion protocolVersion) { RegisterCoordinatorRecordSchema extendedData = RegisterCoordinatorRecordSchema.Instance(context, protocol, coordinatorService, protocolVersion); TxTraceUtility.Trace(TraceEventType.Information, GetCode(protocolVersion), Microsoft.Transactions.SR.GetString("RegisterCoordinator"), extendedData, null, enlistmentId, null); }
private static void ReadFrom(CoordinationContext that, XmlDictionaryReader reader, XmlDictionaryString localName, XmlDictionaryString ns, Microsoft.Transactions.Wsat.Protocol.ProtocolVersion protocolVersion) { try { Uri uri; CoordinationXmlDictionaryStrings strings = CoordinationXmlDictionaryStrings.Version(protocolVersion); AtomicTransactionStrings strings2 = AtomicTransactionStrings.Version(protocolVersion); reader.ReadFullStartElement(localName, strings.Namespace); reader.MoveToStartElement(strings.Identifier, strings.Namespace); that.unknownIdentifierAttributes = ReadOtherAttributes(reader, strings.Namespace); that.contextId = reader.ReadElementContentAsString().Trim(); if ((that.contextId.Length == 0) || (that.contextId.Length > 0x100)) { throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext"))); } if (!Uri.TryCreate(that.contextId, UriKind.Absolute, out uri)) { throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext"))); } if (reader.IsStartElement(strings.Expires, strings.Namespace)) { that.unknownExpiresAttributes = ReadOtherAttributes(reader, strings.Namespace); int num = reader.ReadElementContentAsInt(); if (num < 0) { throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext"))); } that.expiration = (uint) num; that.expiresPresent = true; } reader.MoveToStartElement(strings.CoordinationType, strings.Namespace); if (reader.ReadElementContentAsString().Trim() != strings2.Namespace) { throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext"))); } that.registrationRef = EndpointAddress.ReadFrom(MessagingVersionHelper.AddressingVersion(protocolVersion), reader, strings.RegistrationService, strings.Namespace); if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.IsolationLevel, XD.DotNetAtomicTransactionExternalDictionary.Namespace)) { that.isoLevel = (System.Transactions.IsolationLevel) reader.ReadElementContentAsInt(); if (((that.IsolationLevel < System.Transactions.IsolationLevel.Serializable) || (that.IsolationLevel > System.Transactions.IsolationLevel.Unspecified)) || (that.IsolationLevel == System.Transactions.IsolationLevel.Snapshot)) { throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext"))); } } if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.IsolationFlags, XD.DotNetAtomicTransactionExternalDictionary.Namespace)) { that.isoFlags = (System.ServiceModel.Transactions.IsolationFlags) reader.ReadElementContentAsInt(); } if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.Description, XD.DotNetAtomicTransactionExternalDictionary.Namespace)) { that.description = reader.ReadElementContentAsString().Trim(); } if (reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.LocalTransactionId, XD.DotNetAtomicTransactionExternalDictionary.Namespace)) { that.localTxId = reader.ReadElementContentAsGuid(); } if (OleTxTransactionHeader.IsStartPropagationTokenElement(reader)) { that.propToken = OleTxTransactionHeader.ReadPropagationTokenElement(reader); } if (reader.IsStartElement()) { XmlDocument document = new XmlDocument(); that.unknownData = new List<System.Xml.XmlNode>(5); while (reader.IsStartElement()) { System.Xml.XmlNode item = document.ReadNode(reader); that.unknownData.Add(item); } } reader.ReadEndElement(); } catch (XmlException exception) { throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidCoordinationContextException(Microsoft.Transactions.SR.GetString("InvalidCoordinationContext"), exception)); } }
public static CoordinationContext ReadFrom(XmlDictionaryReader reader, XmlDictionaryString localName, XmlDictionaryString ns, Microsoft.Transactions.Wsat.Protocol.ProtocolVersion protocolVersion) { CoordinationContext that = new CoordinationContext(protocolVersion); ReadFrom(that, reader, localName, ns, protocolVersion); return that; }
public static void Trace(Guid enlistmentId, CoordinationContext context, ControlProtocol protocol, EndpointAddress coordinatorService, Exception e, ProtocolVersion protocolVersion) { RegistrationCoordinatorResponseInvalidMetadataSchema extendedData = RegistrationCoordinatorResponseInvalidMetadataSchema.Instance(context, protocol, coordinatorService, protocolVersion); TxTraceUtility.Trace(TraceEventType.Warning, GetCode(protocolVersion), Microsoft.Transactions.SR.GetString("RegistrationCoordinatorResponseInvalidMetadata"), extendedData, e, enlistmentId, null); }
public TransactionContext(Microsoft.Transactions.Wsat.Messaging.CoordinationContext context, RequestSecurityTokenResponse issuedToken) { this.context = context; this.issuedToken = issuedToken; }
//======================================================================================= public WsatTransactionInfo CreateTransactionInfo(CoordinationContext context, RequestSecurityTokenResponse issuedToken) { return new WsatTransactionInfo(this.wsatProxy, context, issuedToken); }
public RegistrationCoordinatorFaultedSchema(CoordinationContext context, ControlProtocol protocol, MessageFault fault) { this.context = context; this.protocol = protocol; this.fault = fault; }
protected RegistrationCoordinatorResponseInvalidMetadataSchema(CoordinationContext context, ControlProtocol protocol) { this.context = context; this.protocol = protocol; }
public CoordinationContextRecordSchema(CoordinationContext context) { this.context = context; }
private TransactionContext CreateTransactionContext() { Microsoft.Transactions.Bridge.EnlistmentOptions enlistmentOptions = this.enlistment.EnlistmentOptions; string remoteTransactionId = this.enlistment.RemoteTransactionId; Guid localTransactionId = this.enlistment.LocalTransactionId; CoordinationContext context = new CoordinationContext(this.state.ProtocolVersion) { Expires = (enlistmentOptions.Expires == TimeSpan.MaxValue) ? uint.MaxValue : ((uint) ((int) enlistmentOptions.Expires.TotalMilliseconds)), Identifier = remoteTransactionId, LocalTransactionId = localTransactionId, IsolationLevel = enlistmentOptions.IsoLevel, IsolationFlags = enlistmentOptions.IsolationFlags, Description = enlistmentOptions.Description }; string contextId = CoordinationContext.IsNativeIdentifier(remoteTransactionId, localTransactionId) ? null : remoteTransactionId; string sctId = null; RequestSecurityTokenResponse issuedToken = null; if (this.state.Config.PortConfiguration.SupportingTokensEnabled) { CoordinationServiceSecurity.CreateIssuedToken(localTransactionId, remoteTransactionId, this.state.ProtocolVersion, out issuedToken, out sctId); } AddressHeader refParam = new WsatRegistrationHeader(localTransactionId, contextId, sctId); context.RegistrationService = this.state.RegistrationCoordinatorListener.CreateEndpointReference(refParam); return new TransactionContext(context, issuedToken); }
//======================================================================================= // 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); } }
protected RegisterCoordinatorRecordSchema(CoordinationContext context, ControlProtocol protocol) { this.context = context; this.protocol = protocol; }
public static void WriteElement(XmlDictionaryWriter writer, CoordinationContext context, ProtocolVersion protocolVersion) { CoordinationXmlDictionaryStrings strings = CoordinationXmlDictionaryStrings.Version(protocolVersion); context.WriteTo(writer, strings.CoordinationContext, strings.Namespace); }
private void ReadFrom(XmlDictionaryReader reader) { try { reader.ReadFullStartElement(this.coordinationXmlDictionaryStrings.CreateCoordinationContext, this.coordinationXmlDictionaryStrings.Namespace); if (reader.IsStartElement(this.coordinationXmlDictionaryStrings.Expires, this.coordinationXmlDictionaryStrings.Namespace)) { int num = reader.ReadElementContentAsInt(); if (num < 0) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"))); } this.expiration = (uint) num; this.expiresPresent = true; } if (reader.IsStartElement(this.coordinationXmlDictionaryStrings.CurrentContext, this.coordinationXmlDictionaryStrings.Namespace)) { this.CurrentContext = CoordinationContext.ReadFrom(reader, this.coordinationXmlDictionaryStrings.CurrentContext, this.coordinationXmlDictionaryStrings.Namespace, this.protocolVersion); } reader.MoveToStartElement(this.coordinationXmlDictionaryStrings.CoordinationType, this.coordinationXmlDictionaryStrings.Namespace); if (reader.ReadElementContentAsString().Trim() != this.atomicTransactionStrings.Namespace) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"))); } if (!reader.IsStartElement(XD.DotNetAtomicTransactionExternalDictionary.IsolationLevel, XD.DotNetAtomicTransactionExternalDictionary.Namespace)) { goto Label_016B; } this.IsolationLevel = (System.Transactions.IsolationLevel) reader.ReadElementContentAsInt(); if (((this.IsolationLevel >= System.Transactions.IsolationLevel.Serializable) && (this.IsolationLevel <= System.Transactions.IsolationLevel.Unspecified)) && (this.IsolationLevel != System.Transactions.IsolationLevel.Snapshot)) { goto Label_016B; } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"))); Label_0165: reader.Skip(); Label_016B: if (reader.IsStartElement()) { goto Label_0165; } reader.ReadEndElement(); } catch (XmlException exception) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"), exception)); } catch (InvalidCoordinationContextException exception2) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidMessageException(Microsoft.Transactions.SR.GetString("InvalidMessageBody"), exception2)); } }