public static bool IsDefined(TransactionFlowOption option) { return(option == TransactionFlowOption.NotAllowed || option == TransactionFlowOption.Allowed || option == TransactionFlowOption.Mandatory); //option == TransactionFlowOption.Ignore); }
internal static void ValidateOption(TransactionFlowOption opt) { if (!TransactionFlowOptionHelper.IsDefined(opt)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(System.ServiceModel.SR.GetString("TransactionFlowBadOption"))); } }
public static bool IsDefined(TransactionFlowOption option) { return (option == TransactionFlowOption.NotAllowed || option == TransactionFlowOption.Allowed || option == TransactionFlowOption.Mandatory); //option == TransactionFlowOption.Ignore); }
private XmlElement GetAssertion(XmlDocument doc, TransactionFlowOption option, string prefix, string name, string ns, string policyNs) { if (doc == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("doc"); } XmlElement element = null; switch (option) { case TransactionFlowOption.NotAllowed: return(element); case TransactionFlowOption.Allowed: { element = doc.CreateElement(prefix, name, ns); System.Xml.XmlAttribute node = doc.CreateAttribute("wsp", "Optional", policyNs); node.Value = "true"; element.Attributes.Append(node); if ((this.transactionProtocol == System.ServiceModel.TransactionProtocol.OleTransactions) || (this.transactionProtocol == System.ServiceModel.TransactionProtocol.WSAtomicTransactionOctober2004)) { System.Xml.XmlAttribute attribute2 = doc.CreateAttribute("wsp1", "Optional", "http://schemas.xmlsoap.org/ws/2002/12/policy"); attribute2.Value = "true"; element.Attributes.Append(attribute2); } return(element); } case TransactionFlowOption.Mandatory: return(doc.CreateElement(prefix, name, ns)); } return(element); }
internal static void ValidateOption(TransactionFlowOption opt) { if (!TransactionFlowOptionHelper.IsDefined(opt)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(string.Format(SRServiceModel.TransactionFlowBadOption))); } }
internal static bool AllowedOrRequired(TransactionFlowOption option) { if (option != TransactionFlowOption.Allowed) { return(option == TransactionFlowOption.Mandatory); } return(true); }
public static bool IsDefined(TransactionFlowOption option) { if ((option != TransactionFlowOption.NotAllowed) && (option != TransactionFlowOption.Allowed)) { return (option == TransactionFlowOption.Mandatory); } return true; }
internal static bool AllowedOrRequired(TransactionFlowOption option) { if (option != TransactionFlowOption.Allowed) { return (option == TransactionFlowOption.Mandatory); } return true; }
public static bool IsDefined(TransactionFlowOption option) { if ((option != TransactionFlowOption.NotAllowed) && (option != TransactionFlowOption.Allowed)) { return(option == TransactionFlowOption.Mandatory); } return(true); }
public virtual void ReadTransactionDataFromMessage(Message message, MessageDirection direction) { this.ReadIssuedTokens(message, direction); TransactionFlowOption transaction = this.factory.GetTransaction(direction, message.Headers.Action); if (TransactionFlowOptionHelper.AllowedOrRequired(transaction)) { this.ReadTransactionFromMessage(message, transaction); } }
internal TransactionFlowBindingElement(bool transactions, System.ServiceModel.TransactionProtocol transactionProtocol) { this.transactions = transactions; this.issuedTokens = transactions ? TransactionFlowOption.Allowed : TransactionFlowOption.NotAllowed; if (!System.ServiceModel.TransactionProtocol.IsDefined(transactionProtocol)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(System.ServiceModel.SR.GetString("ConfigInvalidTransactionFlowProtocolValue", new object[] { transactionProtocol.ToString() })); } this.transactionProtocol = transactionProtocol; }
private TransactionFlowBindingElement(TransactionFlowBindingElement elementToBeCloned) : base(elementToBeCloned) { this.transactions = elementToBeCloned.transactions; this.issuedTokens = elementToBeCloned.issuedTokens; if (!System.ServiceModel.TransactionProtocol.IsDefined(elementToBeCloned.transactionProtocol)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(System.ServiceModel.SR.GetString("ConfigInvalidTransactionFlowProtocolValue", new object[] { elementToBeCloned.transactionProtocol.ToString() })); } this.transactionProtocol = elementToBeCloned.transactionProtocol; this.AllowWildcardAction = elementToBeCloned.AllowWildcardAction; }
internal TransactionFlowBindingElement(bool transactions, TransactionProtocol transactionProtocol) { _transactions = transactions; _issuedTokens = transactions ? TransactionFlowOption.Allowed : TransactionFlowOption.NotAllowed; if (!TransactionProtocol.IsDefined(transactionProtocol)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(string.Format(SRServiceModel.ConfigInvalidTransactionFlowProtocolValue, transactionProtocol.ToString())); } _transactionProtocol = transactionProtocol; }
private static void TrackAgreement(ref bool everyoneAgrees, TransactionFlowOption option, ref TransactionFlowOption agreedOption, ref bool anOperationCares) { if (!anOperationCares) { agreedOption = option; anOperationCares = true; } else if (option != agreedOption) { everyoneAgrees = false; } }
internal TransactionFlowBindingElement(bool transactions, TransactionProtocol transactionProtocol) { this.transactions = transactions; this.issuedTokens = transactions ? TransactionFlowOption.Allowed : TransactionFlowOption.NotAllowed; if (!TransactionProtocol.IsDefined(transactionProtocol)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.ConfigInvalidTransactionFlowProtocolValue, transactionProtocol.ToString())); } this.transactionProtocol = transactionProtocol; }
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { if (exporter == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exporter"); } if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } TransactionFlowBindingElement bindingElement = context.BindingElements.Find <TransactionFlowBindingElement>(); if (bindingElement == null || !bindingElement.Transactions) { return; } XmlDocument doc = new XmlDocument(); XmlElement assertion = null; foreach (OperationDescription operation in context.Contract.Operations) { TransactionFlowAttribute contextParam = operation.Behaviors.Find <TransactionFlowAttribute>(); TransactionFlowOption txFlowOption = contextParam == null ? TransactionFlowOption.NotAllowed : contextParam.Transactions; // Transactions if (bindingElement.TransactionProtocol == TransactionProtocol.OleTransactions) { assertion = GetAssertion(doc, txFlowOption, TransactionPolicyStrings.OleTxTransactionsPrefix, TransactionPolicyStrings.OleTxTransactionsLocal, TransactionPolicyStrings.OleTxTransactionsNamespace, exporter.PolicyVersion.Namespace); } else if (bindingElement.TransactionProtocol == TransactionProtocol.WSAtomicTransactionOctober2004) { assertion = GetAssertion(doc, txFlowOption, TransactionPolicyStrings.WsatTransactionsPrefix, TransactionPolicyStrings.WsatTransactionsLocal, TransactionPolicyStrings.WsatTransactionsNamespace10, exporter.PolicyVersion.Namespace); } else if (bindingElement.TransactionProtocol == TransactionProtocol.WSAtomicTransaction11) { assertion = GetAssertion(doc, txFlowOption, TransactionPolicyStrings.WsatTransactionsPrefix, TransactionPolicyStrings.WsatTransactionsLocal, TransactionPolicyStrings.WsatTransactionsNamespace11, exporter.PolicyVersion.Namespace); } if (assertion != null) { context.GetOperationBindingAssertions(operation).Add(assertion); } } }
public void WriteTransactionDataToMessage(Message message, MessageDirection direction) { TransactionFlowOption transaction = this.factory.GetTransaction(direction, message.Headers.Action); if (TransactionFlowOptionHelper.AllowedOrRequired(transaction)) { this.WriteTransactionToMessage(message, transaction); } if (TransactionFlowOptionHelper.AllowedOrRequired(this.factory.FlowIssuedTokens)) { this.WriteIssuedTokens(message, direction); } }
internal static void OverrideFlow(BindingParameterCollection parameters, string action, MessageDirection direction, TransactionFlowOption option) { Dictionary<DirectionalAction, TransactionFlowOption> dictionary = EnsureDictionary(parameters); DirectionalAction key = new DirectionalAction(direction, action); if (dictionary.ContainsKey(key)) { dictionary[key] = option; } else { dictionary.Add(key, option); } }
TransactionFlowBindingElement(TransactionFlowBindingElement elementToBeCloned) : base(elementToBeCloned) { this.transactions = elementToBeCloned.transactions; this.issuedTokens = elementToBeCloned.issuedTokens; if (!TransactionProtocol.IsDefined(elementToBeCloned.transactionProtocol)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.ConfigInvalidTransactionFlowProtocolValue, elementToBeCloned.transactionProtocol.ToString())); } this.transactionProtocol = elementToBeCloned.transactionProtocol; this.AllowWildcardAction = elementToBeCloned.AllowWildcardAction; }
private TransactionFlowBindingElement(TransactionFlowBindingElement elementToBeCloned) : base(elementToBeCloned) { _transactions = elementToBeCloned._transactions; _issuedTokens = elementToBeCloned._issuedTokens; if (!TransactionProtocol.IsDefined(elementToBeCloned._transactionProtocol)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(string.Format(SRServiceModel.ConfigInvalidTransactionFlowProtocolValue, elementToBeCloned._transactionProtocol.ToString())); } _transactionProtocol = elementToBeCloned._transactionProtocol; this.AllowWildcardAction = elementToBeCloned.AllowWildcardAction; }
internal static void OverrideFlow(BindingParameterCollection parameters, string action, MessageDirection direction, TransactionFlowOption option) { Dictionary <DirectionalAction, TransactionFlowOption> dictionary = EnsureDictionary(parameters); DirectionalAction key = new DirectionalAction(direction, action); if (dictionary.ContainsKey(key)) { dictionary[key] = option; } else { dictionary.Add(key, option); } }
void SetTransactionFlow(OperationDescription operation) { TransactionFlowOption option = TransactionFlowOption.NotAllowed; foreach (IOperationBehavior behavior in operation.Behaviors) { if (behavior is TransactionFlowAttribute) { TransactionFlowAttribute attribute = behavior as TransactionFlowAttribute; option = attribute.Transactions; break; } } m_AllowedRadioButton.Checked = option == TransactionFlowOption.Allowed; m_NotAllowedRadioButton.Checked = option == TransactionFlowOption.NotAllowed; m_MandatoryRadioButton.Checked = option == TransactionFlowOption.Mandatory; }
public void ReadIssuedTokens(Message message, MessageDirection direction) { TransactionFlowOption flowIssuedTokens = this.factory.FlowIssuedTokens; ICollection <RequestSecurityTokenResponse> issuedTokens = this.GetIssuedTokens(message); if ((issuedTokens != null) && (issuedTokens.Count != 0)) { if (flowIssuedTokens == TransactionFlowOption.NotAllowed) { this.FaultOnMessage(message, System.ServiceModel.SR.GetString("IssuedTokenFlowNotAllowed"), "IssuedTokenFlowNotAllowed"); } foreach (RequestSecurityTokenResponse response in issuedTokens) { TransactionFlowProperty.Ensure(message).IssuedTokens.Add(response); } } }
static void TrackAgreement(ref bool everyoneAgrees, TransactionFlowOption option, ref TransactionFlowOption agreedOption, ref bool anOperationCares) { if (!anOperationCares) { // this is the first operation to express a preference agreedOption = option; anOperationCares = true; // everyoneAgrees is still true } else { if (option != agreedOption) { everyoneAgrees = false; } } }
public void ReadIssuedTokens(Message message, MessageDirection direction) { TransactionFlowOption option = this.factory.FlowIssuedTokens; ICollection <RequestSecurityTokenResponse> issuances = this.GetIssuedTokens(message); if (issuances != null && issuances.Count != 0) { if (option == TransactionFlowOption.NotAllowed) { FaultOnMessage(message, SR.GetString(SR.IssuedTokenFlowNotAllowed), FaultCodeConstants.Codes.IssuedTokenFlowNotAllowed); } foreach (RequestSecurityTokenResponse rstr in issuances) { TransactionFlowProperty.Ensure(message).IssuedTokens.Add(rstr); } } }
void WriteTransactionToMessage(Message message, TransactionFlowOption txFlowOption) { Transaction transaction = TransactionFlowProperty.TryGetTransaction(message); if (transaction != null) { try { this.formatter.WriteTransaction(transaction, message); } catch (TransactionException e) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(e.Message, e)); } } else if (txFlowOption == TransactionFlowOption.Mandatory) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(SR.GetString(SR.SFxTransactionFlowRequired))); } }
XmlElement GetAssertion(XmlDocument doc, TransactionFlowOption option, string prefix, string name, string ns, string policyNs) { if (doc == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("doc"); } XmlElement result = null; switch (option) { case TransactionFlowOption.NotAllowed: // Don't generate an assertion break; case TransactionFlowOption.Allowed: result = doc.CreateElement(prefix, name, ns); // Always insert the real wsp:Optional attribute XmlAttribute attr = doc.CreateAttribute(TransactionPolicyStrings.OptionalPrefix11, TransactionPolicyStrings.OptionalLocal, policyNs); attr.Value = TransactionPolicyStrings.TrueValue; result.Attributes.Append(attr); // For legacy protocols, also insert the legacy attribute for backward compat if (this.transactionProtocol == TransactionProtocol.OleTransactions || this.transactionProtocol == TransactionProtocol.WSAtomicTransactionOctober2004) { XmlAttribute attrLegacy = doc.CreateAttribute(TransactionPolicyStrings.OptionalPrefix10, TransactionPolicyStrings.OptionalLocal, TransactionPolicyStrings.OptionalNamespaceLegacy); attrLegacy.Value = TransactionPolicyStrings.TrueValue; result.Attributes.Append(attrLegacy); } break; case TransactionFlowOption.Mandatory: result = doc.CreateElement(prefix, name, ns); break; } return(result); }
private void WriteTransactionToMessage(Message message, TransactionFlowOption txFlowOption) { Transaction transaction = TransactionFlowProperty.TryGetTransaction(message); if (transaction != null) { try { this.formatter.WriteTransaction(transaction, message); return; } catch (TransactionException exception) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(exception.Message, exception)); } } if (txFlowOption == TransactionFlowOption.Mandatory) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(System.ServiceModel.SR.GetString("SFxTransactionFlowRequired"))); } }
private void ReadTransactionFromMessage(Message message, TransactionFlowOption txFlowOption) { TransactionInfo transactionInfo = null; try { transactionInfo = this.formatter.ReadTransaction(message); } catch (TransactionException exception) { DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Error); this.FaultOnMessage(message, System.ServiceModel.SR.GetString("SFxTransactionDeserializationFailed", new object[] { exception.Message }), "TransactionHeaderMalformed"); } if (transactionInfo != null) { TransactionMessageProperty.Set(transactionInfo, message); } else if (txFlowOption == TransactionFlowOption.Mandatory) { this.FaultOnMessage(message, System.ServiceModel.SR.GetString("SFxTransactionFlowRequired"), "TransactionHeaderMissing"); } }
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { if (exporter == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exporter"); } if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } TransactionFlowBindingElement element = context.BindingElements.Find <TransactionFlowBindingElement>(); if ((element != null) && element.Transactions) { XmlDocument doc = new XmlDocument(); XmlElement item = null; foreach (OperationDescription description in context.Contract.Operations) { TransactionFlowAttribute attribute = description.Behaviors.Find <TransactionFlowAttribute>(); TransactionFlowOption option = (attribute == null) ? TransactionFlowOption.NotAllowed : attribute.Transactions; if (element.TransactionProtocol == System.ServiceModel.TransactionProtocol.OleTransactions) { item = this.GetAssertion(doc, option, "oletx", "OleTxAssertion", "http://schemas.microsoft.com/ws/2006/02/tx/oletx", exporter.PolicyVersion.Namespace); } else if (element.TransactionProtocol == System.ServiceModel.TransactionProtocol.WSAtomicTransactionOctober2004) { item = this.GetAssertion(doc, option, "wsat", "ATAssertion", "http://schemas.xmlsoap.org/ws/2004/10/wsat", exporter.PolicyVersion.Namespace); } else if (element.TransactionProtocol == System.ServiceModel.TransactionProtocol.WSAtomicTransaction11) { item = this.GetAssertion(doc, option, "wsat", "ATAssertion", "http://docs.oasis-open.org/ws-tx/wsat/2006/06", exporter.PolicyVersion.Namespace); } if (item != null) { context.GetOperationBindingAssertions(description).Add(item); } } } }
void ReadTransactionFromMessage(Message message, TransactionFlowOption txFlowOption) { TransactionInfo transactionInfo = null; try { transactionInfo = this.formatter.ReadTransaction(message); } catch (TransactionException e) { DiagnosticUtility.TraceHandledException(e, TraceEventType.Error); FaultOnMessage(message, SR.GetString(SR.SFxTransactionDeserializationFailed, e.Message), FaultCodeConstants.Codes.TransactionHeaderMalformed); } if (transactionInfo != null) { TransactionMessageProperty.Set(transactionInfo, message); } else if (txFlowOption == TransactionFlowOption.Mandatory) { FaultOnMessage(message, SR.GetString(SR.SFxTransactionFlowRequired), FaultCodeConstants.Codes.TransactionHeaderMissing); } }
public TransactionFlowAttribute(TransactionFlowOption transactions) { Transactions = transactions; }
public XmlElement GetAssertion (XmlDocument doc, TransactionFlowOption option, string prefix, string name, string ns) { throw new NotImplementedException (); }
public TransactionFlowAttribute(TransactionFlowOption transactions) { TransactionFlowBindingElement.ValidateOption(transactions); this.transactions = transactions; }
public TransactionFlowAttribute (TransactionFlowOption transactions) { Transactions = transactions; }
public GenericTransactionFlowAttribute(TransactionFlowOption flowOption) { this.transactionFlowAttribute = new TransactionFlowAttribute(flowOption); }
void UpdateTransactionFlowAtribute(OperationDescription operation, TransactionFlowOption txFlow) { operation.Behaviors.Remove<TransactionFlowAttribute>(); operation.Behaviors.Add(new TransactionFlowAttribute(txFlow)); }
static void TrackAgreement(ref bool everyoneAgrees, TransactionFlowOption option, ref TransactionFlowOption agreedOption, ref bool anOperationCares) { if (!anOperationCares) { // this is the first operation to express a preference agreedOption = option; anOperationCares = true; // everyoneAgrees is still true } else { if (option != agreedOption) everyoneAgrees = false; } }
public TransactionFlowAttribute(TransactionFlowOption transactions) { TransactionFlowBindingElement.ValidateOption(transactions); _transactions = transactions; }