private void EnsureNoOneWayTransactions(ServiceEndpoint endpoint) { CustomBinding binding = new CustomBinding(endpoint.Binding); if (binding.Elements.Find <TransactionFlowBindingElement>() != null) { for (int i = 0; i < endpoint.Contract.Operations.Count; i++) { OperationDescription description = endpoint.Contract.Operations[i]; if (description.IsOneWay) { TransactionFlowOption transactions; TransactionFlowAttribute attribute = description.Behaviors.Find <TransactionFlowAttribute>(); if (attribute != null) { transactions = attribute.Transactions; } else { transactions = TransactionFlowOption.NotAllowed; } if (TransactionFlowOptionHelper.AllowedOrRequired(transactions)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxOneWayAndTransactionsIncompatible", new object[] { endpoint.Contract.Name, description.Name }))); } } } } }
void EnsureNoOneWayTransactions(ServiceEndpoint endpoint) { CustomBinding binding = new CustomBinding(endpoint.Binding); TransactionFlowBindingElement txFlowBindingElement = binding.Elements.Find <TransactionFlowBindingElement>(); if (txFlowBindingElement != null) { for (int i = 0; i < endpoint.Contract.Operations.Count; i++) { OperationDescription operation = endpoint.Contract.Operations[i]; if (operation.IsOneWay) { TransactionFlowAttribute tfbp = operation.Behaviors.Find <TransactionFlowAttribute>(); TransactionFlowOption transactions; if (tfbp != null) { transactions = tfbp.Transactions; } else { transactions = TransactionFlowOption.NotAllowed; } if (TransactionFlowOptionHelper.AllowedOrRequired(transactions)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException( SR.GetString(SR.SFxOneWayAndTransactionsIncompatible, endpoint.Contract.Name, operation.Name))); } } } } }
internal bool IsFlowEnabled(ContractDescription contract) { if (this.issuedTokens != TransactionFlowOption.NotAllowed) { return(true); } if (!this.transactions) { return(false); } foreach (OperationDescription operation in contract.Operations) { TransactionFlowAttribute parameter = operation.Behaviors.Find <TransactionFlowAttribute>(); if (parameter != null) { if (parameter.Transactions != TransactionFlowOption.NotAllowed) { return(true); } } } return(false); }
void ValidateTransactionFlowRequired(string resource, string name, ServiceEndpoint endpoint) { bool anOperationRequiresTxFlow = false; for (int i = 0; i < endpoint.Contract.Operations.Count; i++) { OperationDescription operationDescription = endpoint.Contract.Operations[i]; TransactionFlowAttribute transactionFlow = operationDescription.Behaviors.Find <TransactionFlowAttribute>(); if (transactionFlow != null && transactionFlow.Transactions == TransactionFlowOption.Mandatory) { anOperationRequiresTxFlow = true; break; } } if (anOperationRequiresTxFlow) { CustomBinding binding = new CustomBinding(endpoint.Binding); TransactionFlowBindingElement transactionFlowBindingElement = binding.Elements.Find <TransactionFlowBindingElement>(); if (transactionFlowBindingElement == null || !transactionFlowBindingElement.Transactions) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException( String.Format(Globalization.CultureInfo.CurrentCulture, SR.GetString(resource), name, binding.Name))); } } }
private static void EnableTransactionBehavior(OperationDescription operationDescription) { OperationBehaviorAttribute attribute = operationDescription.Behaviors.Find <OperationBehaviorAttribute>(); if (attribute != null) { attribute.TransactionScopeRequired = true; attribute.TransactionAutoComplete = false; } else { OperationBehaviorAttribute item = new OperationBehaviorAttribute { TransactionAutoComplete = false, TransactionScopeRequired = true }; operationDescription.Behaviors.Add(item); } TransactionFlowAttribute attribute4 = operationDescription.Behaviors.Find <TransactionFlowAttribute>(); if (attribute4 != null) { if (attribute4.Transactions != TransactionFlowOption.Allowed) { throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new InvalidOperationException(System.ServiceModel.Activities.SR.ContractInferenceValidationForTransactionFlowBehavior)); } } else if (!operationDescription.IsOneWay) { operationDescription.Behaviors.Add(new TransactionFlowAttribute(TransactionFlowOption.Allowed)); } }
static void ValidateTransactionFlow(ServiceEndpoint endpoint) { Exception exception = new InvalidOperationException("BindingRequirementAttribute requires transaction flow enabled, but binding for the endpoint with contract " + endpoint.Contract.ContractType + " has it disabled"); foreach (OperationDescription operation in endpoint.Contract.Operations) { TransactionFlowAttribute attribute = operation.Behaviors.Find <TransactionFlowAttribute>(); if (attribute != null) { if (attribute.Transactions == TransactionFlowOption.Allowed) { try { dynamic binding = endpoint.Binding; if (binding.TransactionFlow == false) { throw exception; } continue; } catch (RuntimeBinderException) { throw new InvalidOperationException("BindingRequirementAttribute requires transaction flow enabled, but binding for the endpoint with contract " + endpoint.Contract.ContractType + " does not support transaction flow"); } } } } }
static void FillBehaviorInfo(IOperationBehavior behavior, IWmiInstance existingInstance, out IWmiInstance instance) { Fx.Assert(null != existingInstance, ""); Fx.Assert(null != behavior, ""); instance = null; if (behavior is DataContractSerializerOperationBehavior) { instance = existingInstance.NewInstance("DataContractSerializerOperationBehavior"); DataContractSerializerOperationBehavior specificBehavior = (DataContractSerializerOperationBehavior)behavior; instance.SetProperty(AdministrationStrings.IgnoreExtensionDataObject, specificBehavior.IgnoreExtensionDataObject); instance.SetProperty(AdministrationStrings.MaxItemsInObjectGraph, specificBehavior.MaxItemsInObjectGraph); if (null != specificBehavior.DataContractFormatAttribute) { instance.SetProperty(AdministrationStrings.Style, specificBehavior.DataContractFormatAttribute.Style.ToString()); } } else if (behavior is OperationBehaviorAttribute) { instance = existingInstance.NewInstance("OperationBehaviorAttribute"); OperationBehaviorAttribute specificBehavior = (OperationBehaviorAttribute)behavior; instance.SetProperty(AdministrationStrings.AutoDisposeParameters, specificBehavior.AutoDisposeParameters); instance.SetProperty(AdministrationStrings.Impersonation, specificBehavior.Impersonation.ToString()); instance.SetProperty(AdministrationStrings.ReleaseInstanceMode, specificBehavior.ReleaseInstanceMode.ToString()); instance.SetProperty(AdministrationStrings.TransactionAutoComplete, specificBehavior.TransactionAutoComplete); instance.SetProperty(AdministrationStrings.TransactionScopeRequired, specificBehavior.TransactionScopeRequired); } else if (behavior is TransactionFlowAttribute) { instance = existingInstance.NewInstance("TransactionFlowAttribute"); TransactionFlowAttribute specificBehavior = (TransactionFlowAttribute)behavior; instance.SetProperty(AdministrationStrings.TransactionFlowOption, specificBehavior.Transactions.ToString()); } else if (behavior is XmlSerializerOperationBehavior) { instance = existingInstance.NewInstance("XmlSerializerOperationBehavior"); XmlSerializerOperationBehavior specificBehavior = (XmlSerializerOperationBehavior)behavior; if (null != specificBehavior.XmlSerializerFormatAttribute) { instance.SetProperty(AdministrationStrings.Style, specificBehavior.XmlSerializerFormatAttribute.Style.ToString()); instance.SetProperty(AdministrationStrings.Use, specificBehavior.XmlSerializerFormatAttribute.Use.ToString()); instance.SetProperty(AdministrationStrings.SupportFaults, specificBehavior.XmlSerializerFormatAttribute.SupportFaults.ToString()); } } else if (behavior is IWmiInstanceProvider) { IWmiInstanceProvider instanceProvider = (IWmiInstanceProvider)behavior; instance = existingInstance.NewInstance(instanceProvider.GetInstanceType()); instanceProvider.FillInstance(instance); } else { instance = existingInstance.NewInstance("Behavior"); } if (null != instance) { instance.SetProperty(AdministrationStrings.Type, behavior.GetType().FullName); } }
private static void FillBehaviorInfo(IOperationBehavior behavior, IWmiInstance existingInstance, out IWmiInstance instance) { instance = null; if (behavior is DataContractSerializerOperationBehavior) { instance = existingInstance.NewInstance("DataContractSerializerOperationBehavior"); DataContractSerializerOperationBehavior behavior2 = (DataContractSerializerOperationBehavior)behavior; instance.SetProperty("IgnoreExtensionDataObject", behavior2.IgnoreExtensionDataObject); instance.SetProperty("MaxItemsInObjectGraph", behavior2.MaxItemsInObjectGraph); if (behavior2.DataContractFormatAttribute != null) { instance.SetProperty("Style", behavior2.DataContractFormatAttribute.Style.ToString()); } } else if (behavior is OperationBehaviorAttribute) { instance = existingInstance.NewInstance("OperationBehaviorAttribute"); OperationBehaviorAttribute attribute = (OperationBehaviorAttribute)behavior; instance.SetProperty("AutoDisposeParameters", attribute.AutoDisposeParameters); instance.SetProperty("Impersonation", attribute.Impersonation.ToString()); instance.SetProperty("ReleaseInstanceMode", attribute.ReleaseInstanceMode.ToString()); instance.SetProperty("TransactionAutoComplete", attribute.TransactionAutoComplete); instance.SetProperty("TransactionScopeRequired", attribute.TransactionScopeRequired); } else if (behavior is TransactionFlowAttribute) { instance = existingInstance.NewInstance("TransactionFlowAttribute"); TransactionFlowAttribute attribute2 = (TransactionFlowAttribute)behavior; instance.SetProperty("TransactionFlowOption", attribute2.Transactions.ToString()); } else if (behavior is XmlSerializerOperationBehavior) { instance = existingInstance.NewInstance("XmlSerializerOperationBehavior"); XmlSerializerOperationBehavior behavior3 = (XmlSerializerOperationBehavior)behavior; if (behavior3.XmlSerializerFormatAttribute != null) { instance.SetProperty("Style", behavior3.XmlSerializerFormatAttribute.Style.ToString()); instance.SetProperty("Use", behavior3.XmlSerializerFormatAttribute.Use.ToString()); instance.SetProperty("SupportFaults", behavior3.XmlSerializerFormatAttribute.SupportFaults.ToString()); } } else if (behavior is IWmiInstanceProvider) { IWmiInstanceProvider provider = (IWmiInstanceProvider)behavior; instance = existingInstance.NewInstance(provider.GetInstanceType()); provider.FillInstance(instance); } else { instance = existingInstance.NewInstance("Behavior"); } if (instance != null) { instance.SetProperty("Type", behavior.GetType().FullName); } }
void IOperationContractGenerationExtension.GenerateOperation(OperationContractGenerationContext context) { TransactionFlowAttribute attr = context.Operation.Behaviors.Find <TransactionFlowAttribute>(); if ((attr != null) && (attr.Transactions != TransactionFlowOption.NotAllowed)) { CodeMemberMethod method = context.SyncMethod ?? context.BeginMethod; method.CustomAttributes.Add(CreateAttrDecl(context, attr)); } }
static void ValidateTransactionFlow(ServiceEndpoint endpoint) { Exception exception = new InvalidOperationException("BindingRequirementAttribute requires transaction flow enabled, but binding for the endpoint with contract " + endpoint.Contract.ContractType + " has it disabled"); foreach (OperationDescription operation in endpoint.Contract.Operations) { foreach (IOperationBehavior behavior in operation.Behaviors) { if (behavior is TransactionFlowAttribute) { TransactionFlowAttribute attribute = behavior as TransactionFlowAttribute; if (attribute.Transactions == TransactionFlowOption.Allowed) { if (endpoint.Binding is NetTcpBinding) { NetTcpBinding tcpBinding = endpoint.Binding as NetTcpBinding; if (tcpBinding.TransactionFlow == false) { throw exception; } break; } if (endpoint.Binding is NetNamedPipeBinding) { NetNamedPipeBinding ipcBinding = endpoint.Binding as NetNamedPipeBinding; if (ipcBinding.TransactionFlow == false) { throw exception; } break; } if (endpoint.Binding is WSHttpBindingBase) { WSHttpBindingBase wsBinding = endpoint.Binding as WSHttpBindingBase; if (wsBinding.TransactionFlow == false) { throw exception; } break; } if (endpoint.Binding is WSDualHttpBinding) { WSDualHttpBinding wsDualBinding = endpoint.Binding as WSDualHttpBinding; if (wsDualBinding.TransactionFlow == false) { throw exception; } break; } throw new InvalidOperationException("BindingRequirementAttribute requires transaction flow enabled, but binding for the endpoint with contract " + endpoint.Contract.ContractType + " does not support transaction flow"); } } } } }
static bool ContractAllowsTransactionFlow(ContractDescription contract) { foreach (OperationDescription operation in contract.Operations) { TransactionFlowAttribute flowAttr = operation.Behaviors.Find <TransactionFlowAttribute>(); if (flowAttr != null && flowAttr.Transactions != TransactionFlowOption.NotAllowed) { return(true); } } return(false); }
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); } } }
protected WorkflowHostingEndpoint(System.Type contractType, Binding binding, EndpointAddress address) : base(ContractDescription.GetContract(contractType), binding, address) { base.IsSystemEndpoint = true; base.Contract.Behaviors.Add(new ServiceMetadataContractBehavior(false)); base.Contract.Behaviors.Add(new WorkflowHostingContractBehavior()); this.correlationQueries = new Collection <CorrelationQuery>(); base.Behaviors.Add(new CorrelationQueryBehavior(this.correlationQueries)); foreach (OperationDescription description in base.Contract.Operations) { TransactionFlowAttribute attribute = description.Behaviors.Find <TransactionFlowAttribute>(); if ((attribute != null) && (attribute.Transactions != TransactionFlowOption.NotAllowed)) { description.Behaviors.Find <OperationBehaviorAttribute>().TransactionScopeRequired = true; } } }
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; }
internal bool IsFlowEnabled(ContractDescription contract) { if (this.issuedTokens != TransactionFlowOption.NotAllowed) { return(true); } if (this.transactions) { foreach (OperationDescription description in contract.Operations) { TransactionFlowAttribute attribute = description.Behaviors.Find <TransactionFlowAttribute>(); if ((attribute != null) && (attribute.Transactions != TransactionFlowOption.NotAllowed)) { return(true); } } } return(false); }
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); } } } }
static void EnableTransactionBehavior(OperationDescription operationDescription) { Fx.Assert(operationDescription != null, "OperationDescription is null"); OperationBehaviorAttribute attribute = operationDescription.Behaviors.Find <OperationBehaviorAttribute>(); if (attribute != null) { attribute.TransactionScopeRequired = true; attribute.TransactionAutoComplete = false; } else { OperationBehaviorAttribute attr = new OperationBehaviorAttribute { TransactionAutoComplete = false, TransactionScopeRequired = true }; operationDescription.Behaviors.Add(attr); } TransactionFlowAttribute transactionFlowAttribute = operationDescription.Behaviors.Find <TransactionFlowAttribute>(); if (transactionFlowAttribute != null) { if (transactionFlowAttribute.Transactions != TransactionFlowOption.Allowed) { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.ContractInferenceValidationForTransactionFlowBehavior)); } } else { if (!operationDescription.IsOneWay) { operationDescription.Behaviors.Add(new TransactionFlowAttribute(TransactionFlowOption.Allowed)); } } }
protected WorkflowHostingEndpoint(Type contractType, Binding binding, EndpointAddress address) : base(ContractDescription.GetContract(contractType), binding, address) { this.IsSystemEndpoint = true; this.Contract.Behaviors.Add(new ServiceMetadataContractBehavior(false)); this.Contract.Behaviors.Add(new WorkflowHostingContractBehavior()); Fx.Assert(!this.Behaviors.Contains(typeof(CorrelationQueryBehavior)), "Must not contain correlation query!"); this.correlationQueries = new Collection <CorrelationQuery>(); this.Behaviors.Add(new CorrelationQueryBehavior(this.correlationQueries)); // If TransactionFlowOption.Allowed or TransactionFlowOption.Mandatory is defined on an operation, we will set // TransactionScopeRequired = true for that operation. The operation will become transacted (use transaction flow, // or create one locally). For usability reason, we assume this is the majority usage. User could opt out by // setting TransactionScopeRequired to false or remove the TransactionFlowAttribute from the operation. foreach (OperationDescription operationDescription in this.Contract.Operations) { TransactionFlowAttribute transactionFlow = operationDescription.Behaviors.Find <TransactionFlowAttribute>(); if (transactionFlow != null && transactionFlow.Transactions != TransactionFlowOption.NotAllowed) { OperationBehaviorAttribute operationAttribute = operationDescription.Behaviors.Find <OperationBehaviorAttribute>(); operationAttribute.TransactionScopeRequired = true; } } }
private void ValidateTransactionFlowRequired(string resource, string name, ServiceEndpoint endpoint) { bool flag = false; for (int i = 0; i < endpoint.Contract.Operations.Count; i++) { OperationDescription description = endpoint.Contract.Operations[i]; TransactionFlowAttribute attribute = description.Behaviors.Find <TransactionFlowAttribute>(); if ((attribute != null) && (attribute.Transactions == TransactionFlowOption.Mandatory)) { flag = true; break; } } if (flag) { CustomBinding binding = new CustomBinding(endpoint.Binding); TransactionFlowBindingElement element = binding.Elements.Find <TransactionFlowBindingElement>(); if ((element == null) || !element.Transactions) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, System.ServiceModel.SR.GetString(resource), new object[] { name, binding.Name }))); } } }
private static CodeAttributeDeclaration CreateAttrDecl(OperationContractGenerationContext context, TransactionFlowAttribute attr) { CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(context.Contract.ServiceContractGenerator.GetCodeTypeReference(typeof(TransactionFlowAttribute))); declaration.Arguments.Add(new CodeAttributeArgument(ServiceContractGenerator.GetEnumReferenceTransactionFlowOption(attr.Transactions))); return declaration; }
public void Validate(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase) { if (serviceDescription == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serviceDescription"); } ContextBindingElement.ValidateContextBindingElementOnAllEndpointsWithSessionfulContract(serviceDescription, this); if (serviceDescription.Behaviors != null) { ServiceBehaviorAttribute serviceBehavior = serviceDescription.Behaviors.Find <ServiceBehaviorAttribute>(); if (serviceBehavior != null) { if (serviceBehavior.InstanceContextMode != InstanceContextMode.PerSession) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException( SR2.GetString(SR2.InstanceContextModeMustBePerSession, serviceBehavior.InstanceContextMode))); } if (serviceBehavior.ConcurrencyMode == ConcurrencyMode.Multiple) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException( SR2.GetString(SR2.ConcurrencyMultipleNotSupported))); } if (serviceBehavior.ConcurrencyMode == ConcurrencyMode.Reentrant && this.UnknownExceptionAction == UnknownExceptionAction.AbortInstance) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException( SR2.GetString(SR2.ConcurrencyReentrantAndAbortNotSupported))); } } } bool foundSessionfulContract = false; foreach (ServiceEndpoint serviceEndpoint in serviceDescription.Endpoints) { if (serviceEndpoint != null && !serviceEndpoint.InternalIsSystemEndpoint(serviceDescription)) { if (serviceEndpoint.Contract.SessionMode != SessionMode.NotAllowed) { foundSessionfulContract = true; } foreach (OperationDescription operation in serviceEndpoint.Contract.Operations) { DurableOperationAttribute durableBehavior = operation.Behaviors.Find <DurableOperationAttribute>(); if (durableBehavior == null) { durableBehavior = defaultDurableOperationBehavior; } if (serviceEndpoint.Contract.SessionMode == SessionMode.NotAllowed) { if (!durableBehavior.CanCreateInstanceForOperation(operation.IsOneWay)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException( SR2.GetString( SR2.CanCreateInstanceMustBeTrue, serviceEndpoint.Contract.Name, operation.Name))); } } else { if (operation.IsOneWay && durableBehavior.CanCreateInstanceForOperation(operation.IsOneWay)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException( SR2.GetString( SR2.CanCreateInstanceMustBeTwoWay, serviceEndpoint.Contract.Name, serviceEndpoint.Contract.SessionMode, operation.Name))); } } if (this.saveStateInOperationTransaction) { bool hasTransaction = false; OperationBehaviorAttribute operationBehavior = operation.Behaviors.Find <OperationBehaviorAttribute>(); if (operationBehavior != null) { if (operationBehavior.TransactionScopeRequired) { hasTransaction = true; } } TransactionFlowAttribute transactionBehavior = operation.Behaviors.Find <TransactionFlowAttribute>(); if (transactionBehavior != null) { if (transactionBehavior.Transactions == TransactionFlowOption.Mandatory) { hasTransaction = true; } } if (!hasTransaction) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException( SR2.GetString( SR2.SaveStateInTransactionValidationFailed, operation.Name, serviceEndpoint.ListenUri))); } } } } } if (!foundSessionfulContract) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidOperationException( SR2.GetString(SR2.SessionfulContractNotFound))); } }
static CodeAttributeDeclaration CreateAttrDecl(OperationContractGenerationContext context, TransactionFlowAttribute attr) { CodeAttributeDeclaration attrDecl = new CodeAttributeDeclaration(context.Contract.ServiceContractGenerator.GetCodeTypeReference(typeof(TransactionFlowAttribute))); attrDecl.Arguments.Add(new CodeAttributeArgument(ServiceContractGenerator.GetEnumReference <TransactionFlowOption>(attr.Transactions))); return(attrDecl); }
internal static void DemandTransactionPermissions(ServiceEndpoint endpoint, string operationName) { bool transactionFlow = false; bool flowOptionAllowed = false; if (endpoint.Binding is NetMsmqBinding) { NetMsmqBinding msmqBinding = endpoint.Binding as NetMsmqBinding; if (msmqBinding.Durable) { transactionFlow = true; if (Transaction.Current != null) { flowOptionAllowed = true; } } } if (endpoint.Binding is NetTcpBinding) { NetTcpBinding tcpBinding = endpoint.Binding as NetTcpBinding; transactionFlow = tcpBinding.TransactionFlow; } if (endpoint.Binding is NetNamedPipeBinding) { NetNamedPipeBinding ipcBinding = endpoint.Binding as NetNamedPipeBinding; transactionFlow = ipcBinding.TransactionFlow; } if (endpoint.Binding is WSHttpBinding) { WSHttpBinding wsBinding = endpoint.Binding as WSHttpBinding; transactionFlow = wsBinding.TransactionFlow; } if (endpoint.Binding is WSDualHttpBinding) { WSDualHttpBinding wsDualBinding = endpoint.Binding as WSDualHttpBinding; transactionFlow = wsDualBinding.TransactionFlow; } if (transactionFlow) { if (Transaction.Current != null) { //If operationName is null, then at least one operation needs to allow flow foreach (OperationDescription operation in endpoint.Contract.Operations) { string name = operationName ?? operation.Name; if (name != operation.Name) { continue; } foreach (IOperationBehavior behavior in operation.Behaviors) { if (behavior is TransactionFlowAttribute) { TransactionFlowAttribute attribute = behavior as TransactionFlowAttribute; if (attribute.Transactions != TransactionFlowOption.NotAllowed) { flowOptionAllowed = true; break; } } } if (flowOptionAllowed) { break; } } if (flowOptionAllowed) { IPermission distributedTransactionPermission = new DistributedTransactionPermission(PermissionState.Unrestricted); distributedTransactionPermission.Demand(); } } } }
public GenericTransactionFlowAttribute(TransactionFlowOption flowOption) { this.transactionFlowAttribute = new TransactionFlowAttribute(flowOption); }