1281 lines
58 KiB
C#
1281 lines
58 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Description
|
|
{
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Runtime;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Channels;
|
|
using System.Xml;
|
|
using System.Xml.Schema;
|
|
using System.Xml.Serialization;
|
|
using WsdlNS = System.Web.Services.Description;
|
|
|
|
public class WsdlExporter : MetadataExporter
|
|
{
|
|
static XmlDocument xmlDocument;
|
|
bool isFaulted = false;
|
|
|
|
|
|
WsdlNS.ServiceDescriptionCollection wsdlDocuments = new WsdlNS.ServiceDescriptionCollection();
|
|
XmlSchemaSet xmlSchemas = WsdlExporter.GetEmptySchemaSet();
|
|
|
|
Dictionary<ContractDescription, WsdlContractConversionContext> exportedContracts
|
|
= new Dictionary<ContractDescription, WsdlContractConversionContext>();
|
|
Dictionary<BindingDictionaryKey, WsdlEndpointConversionContext> exportedBindings = new Dictionary<BindingDictionaryKey, WsdlEndpointConversionContext>();
|
|
Dictionary<EndpointDictionaryKey, ServiceEndpoint> exportedEndpoints = new Dictionary<EndpointDictionaryKey, ServiceEndpoint>();
|
|
|
|
public override void ExportContract(ContractDescription contract)
|
|
{
|
|
if (this.isFaulted)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.WsdlExporterIsFaulted)));
|
|
|
|
if (contract == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contract");
|
|
|
|
if (!this.exportedContracts.ContainsKey(contract))
|
|
{
|
|
try
|
|
{
|
|
WsdlNS.PortType wsdlPortType = CreateWsdlPortType(contract);
|
|
WsdlContractConversionContext contractContext;
|
|
|
|
|
|
contractContext = new WsdlContractConversionContext(contract, wsdlPortType);
|
|
|
|
foreach (OperationDescription operation in contract.Operations)
|
|
{
|
|
bool isWildcardAction;
|
|
if (!OperationIsExportable(operation, out isWildcardAction))
|
|
{
|
|
string warningMsg = isWildcardAction ? SR.GetString(SR.WarnSkippingOpertationWithWildcardAction, contract.Name, contract.Namespace, operation.Name)
|
|
: SR.GetString(SR.WarnSkippingOpertationWithSessionOpenNotificationEnabled, "Action", OperationDescription.SessionOpenedAction, contract.Name, contract.Namespace, operation.Name);
|
|
|
|
LogExportWarning(warningMsg);
|
|
continue;
|
|
}
|
|
|
|
WsdlNS.Operation wsdlOperation = CreateWsdlOperation(operation, contract);
|
|
wsdlPortType.Operations.Add(wsdlOperation);
|
|
|
|
contractContext.AddOperation(operation, wsdlOperation);
|
|
|
|
foreach (MessageDescription message in operation.Messages)
|
|
{
|
|
//Create Operation Message
|
|
WsdlNS.OperationMessage wsdlOperationMessage = CreateWsdlOperationMessage(message);
|
|
wsdlOperation.Messages.Add(wsdlOperationMessage);
|
|
contractContext.AddMessage(message, wsdlOperationMessage);
|
|
}
|
|
|
|
foreach (FaultDescription fault in operation.Faults)
|
|
{
|
|
//Create Operation Fault
|
|
WsdlNS.OperationFault wsdlOperationFault = CreateWsdlOperationFault(fault);
|
|
wsdlOperation.Faults.Add(wsdlOperationFault);
|
|
contractContext.AddFault(fault, wsdlOperationFault);
|
|
}
|
|
}
|
|
|
|
CallExportContract(contractContext);
|
|
|
|
exportedContracts.Add(contract, contractContext);
|
|
}
|
|
catch
|
|
{
|
|
isFaulted = true;
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void ExportEndpoint(ServiceEndpoint endpoint)
|
|
{
|
|
if (this.isFaulted)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.WsdlExporterIsFaulted)));
|
|
|
|
if (endpoint == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpoint");
|
|
|
|
ExportEndpoint(endpoint, new XmlQualifiedName(NamingHelper.DefaultServiceName, NamingHelper.DefaultNamespace), null);
|
|
}
|
|
|
|
public void ExportEndpoints(IEnumerable<ServiceEndpoint> endpoints, XmlQualifiedName wsdlServiceQName)
|
|
{
|
|
this.ExportEndpoints(endpoints, wsdlServiceQName, null);
|
|
}
|
|
|
|
internal void ExportEndpoints(IEnumerable<ServiceEndpoint> endpoints, XmlQualifiedName wsdlServiceQName, BindingParameterCollection bindingParameters)
|
|
{
|
|
if (this.isFaulted)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.WsdlExporterIsFaulted)));
|
|
|
|
if (endpoints == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpoints");
|
|
if (wsdlServiceQName == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("wsdlServiceQName");
|
|
|
|
foreach (ServiceEndpoint endpoint in endpoints)
|
|
{
|
|
ExportEndpoint(endpoint, wsdlServiceQName, bindingParameters);
|
|
}
|
|
}
|
|
|
|
public override MetadataSet GetGeneratedMetadata()
|
|
{
|
|
MetadataSet set = new MetadataSet();
|
|
|
|
foreach (WsdlNS.ServiceDescription wsdl in wsdlDocuments)
|
|
set.MetadataSections.Add(MetadataSection.CreateFromServiceDescription(wsdl));
|
|
|
|
foreach (XmlSchema schema in xmlSchemas.Schemas())
|
|
set.MetadataSections.Add(MetadataSection.CreateFromSchema(schema));
|
|
|
|
return set;
|
|
}
|
|
|
|
public WsdlNS.ServiceDescriptionCollection GeneratedWsdlDocuments { get { return wsdlDocuments; } }
|
|
public XmlSchemaSet GeneratedXmlSchemas { get { return xmlSchemas; } }
|
|
|
|
void ExportEndpoint(ServiceEndpoint endpoint, XmlQualifiedName wsdlServiceQName, BindingParameterCollection bindingParameters)
|
|
{
|
|
if (endpoint.Binding == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.EndpointsMustHaveAValidBinding1, endpoint.Name)));
|
|
|
|
EndpointDictionaryKey endpointKey = new EndpointDictionaryKey(endpoint, wsdlServiceQName);
|
|
|
|
try
|
|
{
|
|
if (exportedEndpoints.ContainsKey(endpointKey))
|
|
return;
|
|
|
|
this.ExportContract(endpoint.Contract);
|
|
|
|
// Retreive Conversion Context for Contract;
|
|
// Note: Contract must have already been exported at this point.
|
|
WsdlContractConversionContext contractContext = this.exportedContracts[endpoint.Contract];
|
|
|
|
|
|
bool newWsdlBinding, bindingNameWasUniquified;
|
|
WsdlNS.Port wsdlPort;
|
|
WsdlNS.Binding wsdlBinding;
|
|
wsdlBinding = CreateWsdlBindingAndPort(endpoint, wsdlServiceQName, out wsdlPort, out newWsdlBinding, out bindingNameWasUniquified);
|
|
|
|
|
|
if (!newWsdlBinding && wsdlPort == null)
|
|
return;
|
|
|
|
// Create an Endpoint conversion context based on
|
|
// the contract's conversion context (reuse contract correlation information)
|
|
WsdlEndpointConversionContext endpointContext;
|
|
if (newWsdlBinding)
|
|
{
|
|
endpointContext = new WsdlEndpointConversionContext(contractContext, endpoint, wsdlBinding, wsdlPort);
|
|
|
|
foreach (OperationDescription operation in endpoint.Contract.Operations)
|
|
{
|
|
if (!WsdlExporter.OperationIsExportable(operation))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
WsdlNS.OperationBinding wsdlOperationBinding = CreateWsdlOperationBinding(endpoint.Contract, operation);
|
|
wsdlBinding.Operations.Add(wsdlOperationBinding);
|
|
|
|
endpointContext.AddOperationBinding(operation, wsdlOperationBinding);
|
|
|
|
foreach (MessageDescription message in operation.Messages)
|
|
{
|
|
WsdlNS.MessageBinding wsdlMessageBinding = CreateWsdlMessageBinding(message, endpoint.Binding, wsdlOperationBinding);
|
|
endpointContext.AddMessageBinding(message, wsdlMessageBinding);
|
|
}
|
|
|
|
foreach (FaultDescription fault in operation.Faults)
|
|
{
|
|
WsdlNS.FaultBinding wsdlFaultBinding = CreateWsdlFaultBinding(fault, endpoint.Binding, wsdlOperationBinding);
|
|
endpointContext.AddFaultBinding(fault, wsdlFaultBinding);
|
|
}
|
|
}
|
|
|
|
// CSDMain 180381: Added internal functionality for passing BindingParameters into the ExportPolicy process via PolicyConversionContext.
|
|
// However, in order to not change existing behavior, we only call the internal ExportPolicy method which accepts BindingParameters if they are not null
|
|
// (non-null binding parameters can only be passed in via internal code paths). Otherwise, we call the existing ExportPolicy method, just like before.
|
|
PolicyConversionContext policyContext;
|
|
if (bindingParameters == null)
|
|
{
|
|
policyContext = this.ExportPolicy(endpoint);
|
|
}
|
|
else
|
|
{
|
|
policyContext = this.ExportPolicy(endpoint, bindingParameters);
|
|
}
|
|
// consider factoring this out of wsdl exporter
|
|
new WSPolicyAttachmentHelper(this.PolicyVersion).AttachPolicy(endpoint, endpointContext, policyContext);
|
|
exportedBindings.Add(new BindingDictionaryKey(endpoint.Contract, endpoint.Binding), endpointContext);
|
|
}
|
|
else
|
|
{
|
|
endpointContext = new WsdlEndpointConversionContext(exportedBindings[new BindingDictionaryKey(endpoint.Contract, endpoint.Binding)], endpoint, wsdlPort);
|
|
}
|
|
|
|
CallExportEndpoint(endpointContext);
|
|
exportedEndpoints.Add(endpointKey, endpoint);
|
|
if (bindingNameWasUniquified)
|
|
Errors.Add(new MetadataConversionError(SR.GetString(SR.WarnDuplicateBindingQNameNameOnExport, endpoint.Binding.Name, endpoint.Binding.Namespace, endpoint.Contract.Name), true /*isWarning*/));
|
|
}
|
|
catch
|
|
{
|
|
isFaulted = true;
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void CallExportEndpoint(WsdlEndpointConversionContext endpointContext)
|
|
{
|
|
foreach (IWsdlExportExtension extension in endpointContext.ExportExtensions)
|
|
{
|
|
CallExtension(endpointContext, extension);
|
|
}
|
|
}
|
|
|
|
void CallExportContract(WsdlContractConversionContext contractContext)
|
|
{
|
|
foreach (IWsdlExportExtension extension in contractContext.ExportExtensions)
|
|
{
|
|
CallExtension(contractContext, extension);
|
|
}
|
|
}
|
|
|
|
WsdlNS.PortType CreateWsdlPortType(ContractDescription contract)
|
|
{
|
|
XmlQualifiedName wsdlPortTypeQName = WsdlNamingHelper.GetPortTypeQName(contract);
|
|
|
|
WsdlNS.ServiceDescription wsdl = GetOrCreateWsdl(wsdlPortTypeQName.Namespace);
|
|
WsdlNS.PortType wsdlPortType = new WsdlNS.PortType();
|
|
wsdlPortType.Name = wsdlPortTypeQName.Name;
|
|
if (wsdl.PortTypes[wsdlPortType.Name] != null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.DuplicateContractQNameNameOnExport, contract.Name, contract.Namespace)));
|
|
NetSessionHelper.AddUsingSessionAttributeIfNeeded(wsdlPortType, contract);
|
|
wsdl.PortTypes.Add(wsdlPortType);
|
|
|
|
return wsdlPortType;
|
|
}
|
|
|
|
WsdlNS.Operation CreateWsdlOperation(OperationDescription operation, ContractDescription contract)
|
|
{
|
|
WsdlNS.Operation wsdlOperation = new WsdlNS.Operation();
|
|
wsdlOperation.Name = WsdlNamingHelper.GetWsdlOperationName(operation, contract);
|
|
NetSessionHelper.AddInitiatingTerminatingAttributesIfNeeded(wsdlOperation, operation, contract);
|
|
return wsdlOperation;
|
|
}
|
|
|
|
WsdlNS.OperationMessage CreateWsdlOperationMessage(MessageDescription message)
|
|
{
|
|
WsdlNS.OperationMessage wsdlOperationMessage;
|
|
|
|
if (message.Direction == MessageDirection.Input)
|
|
wsdlOperationMessage = new WsdlNS.OperationInput();
|
|
else
|
|
wsdlOperationMessage = new WsdlNS.OperationOutput();
|
|
|
|
if (!XmlName.IsNullOrEmpty(message.MessageName))
|
|
wsdlOperationMessage.Name = message.MessageName.EncodedName;
|
|
|
|
// consider factoring this out of wslExporter
|
|
WSAddressingHelper.AddActionAttribute(message.Action, wsdlOperationMessage, this.PolicyVersion);
|
|
return wsdlOperationMessage;
|
|
}
|
|
|
|
WsdlNS.OperationFault CreateWsdlOperationFault(FaultDescription fault)
|
|
{
|
|
WsdlNS.OperationFault wsdlOperationFault;
|
|
wsdlOperationFault = new WsdlNS.OperationFault();
|
|
|
|
// operation fault name must not be empty (FaultDescription checks this)
|
|
wsdlOperationFault.Name = fault.Name;
|
|
|
|
// consider factoring this out of wslExporter
|
|
WSAddressingHelper.AddActionAttribute(fault.Action, wsdlOperationFault, this.PolicyVersion);
|
|
return wsdlOperationFault;
|
|
}
|
|
|
|
WsdlNS.Binding CreateWsdlBindingAndPort(ServiceEndpoint endpoint, XmlQualifiedName wsdlServiceQName, out WsdlNS.Port wsdlPort, out bool newBinding, out bool bindingNameWasUniquified)
|
|
{
|
|
WsdlNS.ServiceDescription bindingWsdl;
|
|
WsdlNS.Binding wsdlBinding;
|
|
WsdlEndpointConversionContext bindingConversionContext;
|
|
XmlQualifiedName wsdlBindingQName;
|
|
XmlQualifiedName wsdlPortTypeQName;
|
|
bool printWsdlDeclaration = IsWsdlExportable(endpoint.Binding);
|
|
|
|
if (!exportedBindings.TryGetValue(new BindingDictionaryKey(endpoint.Contract, endpoint.Binding), out bindingConversionContext))
|
|
{
|
|
wsdlBindingQName = WsdlNamingHelper.GetBindingQName(endpoint, this, out bindingNameWasUniquified);
|
|
bindingWsdl = GetOrCreateWsdl(wsdlBindingQName.Namespace);
|
|
wsdlBinding = new WsdlNS.Binding();
|
|
wsdlBinding.Name = wsdlBindingQName.Name;
|
|
newBinding = true;
|
|
|
|
WsdlNS.PortType wsdlPortType = exportedContracts[endpoint.Contract].WsdlPortType;
|
|
wsdlPortTypeQName = new XmlQualifiedName(wsdlPortType.Name, wsdlPortType.ServiceDescription.TargetNamespace);
|
|
wsdlBinding.Type = wsdlPortTypeQName;
|
|
if (printWsdlDeclaration)
|
|
{
|
|
bindingWsdl.Bindings.Add(wsdlBinding);
|
|
}
|
|
WsdlExporter.EnsureWsdlContainsImport(bindingWsdl, wsdlPortTypeQName.Namespace);
|
|
}
|
|
else
|
|
{
|
|
wsdlBindingQName = new XmlQualifiedName(bindingConversionContext.WsdlBinding.Name, bindingConversionContext.WsdlBinding.ServiceDescription.TargetNamespace);
|
|
bindingNameWasUniquified = false;
|
|
bindingWsdl = wsdlDocuments[wsdlBindingQName.Namespace];
|
|
wsdlBinding = bindingWsdl.Bindings[wsdlBindingQName.Name];
|
|
wsdlPortTypeQName = wsdlBinding.Type;
|
|
newBinding = false;
|
|
}
|
|
|
|
|
|
//We can only create a Port if there is an address
|
|
if (endpoint.Address != null)
|
|
{
|
|
WsdlNS.Service wsdlService = GetOrCreateWsdlService(wsdlServiceQName);
|
|
|
|
wsdlPort = new WsdlNS.Port();
|
|
string wsdlPortName = WsdlNamingHelper.GetPortName(endpoint, wsdlService);
|
|
wsdlPort.Name = wsdlPortName;
|
|
wsdlPort.Binding = wsdlBindingQName;
|
|
|
|
WsdlNS.SoapAddressBinding addressBinding = SoapHelper.GetOrCreateSoapAddressBinding(wsdlBinding, wsdlPort, this);
|
|
|
|
if (addressBinding != null)
|
|
{
|
|
addressBinding.Location = endpoint.Address.Uri.AbsoluteUri;
|
|
}
|
|
|
|
WsdlExporter.EnsureWsdlContainsImport(wsdlService.ServiceDescription, wsdlBindingQName.Namespace);
|
|
if (printWsdlDeclaration)
|
|
{
|
|
wsdlService.Ports.Add(wsdlPort);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wsdlPort = null;
|
|
}
|
|
|
|
return wsdlBinding;
|
|
}
|
|
|
|
WsdlNS.OperationBinding CreateWsdlOperationBinding(ContractDescription contract, OperationDescription operation)
|
|
{
|
|
WsdlNS.OperationBinding wsdlOperationBinding = new WsdlNS.OperationBinding();
|
|
wsdlOperationBinding.Name = WsdlNamingHelper.GetWsdlOperationName(operation, contract);
|
|
return wsdlOperationBinding;
|
|
}
|
|
|
|
WsdlNS.MessageBinding CreateWsdlMessageBinding(MessageDescription messageDescription, Binding binding, WsdlNS.OperationBinding wsdlOperationBinding)
|
|
{
|
|
WsdlNS.MessageBinding wsdlMessageBinding;
|
|
if (messageDescription.Direction == MessageDirection.Input)
|
|
{
|
|
wsdlOperationBinding.Input = new WsdlNS.InputBinding();
|
|
wsdlMessageBinding = wsdlOperationBinding.Input;
|
|
}
|
|
else
|
|
{
|
|
wsdlOperationBinding.Output = new WsdlNS.OutputBinding();
|
|
wsdlMessageBinding = wsdlOperationBinding.Output;
|
|
}
|
|
|
|
if (!XmlName.IsNullOrEmpty(messageDescription.MessageName))
|
|
wsdlMessageBinding.Name = messageDescription.MessageName.EncodedName;
|
|
|
|
return wsdlMessageBinding;
|
|
}
|
|
|
|
WsdlNS.FaultBinding CreateWsdlFaultBinding(FaultDescription faultDescription, Binding binding, WsdlNS.OperationBinding wsdlOperationBinding)
|
|
{
|
|
WsdlNS.FaultBinding wsdlFaultBinding = new WsdlNS.FaultBinding();
|
|
wsdlOperationBinding.Faults.Add(wsdlFaultBinding);
|
|
if (faultDescription.Name != null)
|
|
wsdlFaultBinding.Name = faultDescription.Name;
|
|
|
|
return wsdlFaultBinding;
|
|
}
|
|
|
|
internal static bool OperationIsExportable(OperationDescription operation)
|
|
{
|
|
bool isWildcardAction;
|
|
return OperationIsExportable(operation, out isWildcardAction);
|
|
}
|
|
|
|
internal static bool OperationIsExportable(OperationDescription operation, out bool isWildcardAction)
|
|
{
|
|
isWildcardAction = false;
|
|
|
|
if (operation.IsSessionOpenNotificationEnabled)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for (int i = 0; i < operation.Messages.Count; i++)
|
|
{
|
|
if (operation.Messages[i].Action == MessageHeaders.WildcardAction)
|
|
{
|
|
isWildcardAction = true;
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
internal static bool IsBuiltInOperationBehavior(IWsdlExportExtension extension)
|
|
{
|
|
DataContractSerializerOperationBehavior dcsob = extension as DataContractSerializerOperationBehavior;
|
|
if (dcsob != null)
|
|
{
|
|
return dcsob.IsBuiltInOperationBehavior;
|
|
}
|
|
|
|
XmlSerializerOperationBehavior xsob = extension as XmlSerializerOperationBehavior;
|
|
if (xsob != null)
|
|
{
|
|
return xsob.IsBuiltInOperationBehavior;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static XmlDocument XmlDoc
|
|
{
|
|
get
|
|
{
|
|
if (xmlDocument == null)
|
|
{
|
|
NameTable nameTable = new NameTable();
|
|
nameTable.Add(MetadataStrings.WSPolicy.Elements.Policy);
|
|
nameTable.Add(MetadataStrings.WSPolicy.Elements.All);
|
|
nameTable.Add(MetadataStrings.WSPolicy.Elements.ExactlyOne);
|
|
nameTable.Add(MetadataStrings.WSPolicy.Attributes.PolicyURIs);
|
|
nameTable.Add(MetadataStrings.Wsu.Attributes.Id);
|
|
nameTable.Add(MetadataStrings.Addressing200408.Policy.UsingAddressing);
|
|
nameTable.Add(MetadataStrings.Addressing10.WsdlBindingPolicy.UsingAddressing);
|
|
nameTable.Add(MetadataStrings.Addressing10.MetadataPolicy.Addressing);
|
|
nameTable.Add(MetadataStrings.Addressing10.MetadataPolicy.AnonymousResponses);
|
|
nameTable.Add(MetadataStrings.Addressing10.MetadataPolicy.NonAnonymousResponses);
|
|
xmlDocument = new XmlDocument(nameTable);
|
|
}
|
|
return xmlDocument;
|
|
}
|
|
}
|
|
|
|
// Generate WSDL Document if it doesn't already exist otherwise, return the appropriate WSDL document
|
|
internal WsdlNS.ServiceDescription GetOrCreateWsdl(string ns)
|
|
{
|
|
// NOTE: this method is not thread safe
|
|
WsdlNS.ServiceDescriptionCollection wsdlCollection = this.wsdlDocuments;
|
|
WsdlNS.ServiceDescription wsdl = wsdlCollection[ns];
|
|
|
|
// Look for wsdl in service descriptions that have been created. If we cannot find it then we create it
|
|
if (wsdl == null)
|
|
{
|
|
wsdl = new WsdlNS.ServiceDescription();
|
|
wsdl.TargetNamespace = ns;
|
|
|
|
XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces(new WsdlNamespaceHelper(this.PolicyVersion).SerializerNamespaces);
|
|
if (!string.IsNullOrEmpty(wsdl.TargetNamespace))
|
|
namespaces.Add("tns", wsdl.TargetNamespace);
|
|
wsdl.Namespaces = namespaces;
|
|
|
|
wsdlCollection.Add(wsdl);
|
|
}
|
|
|
|
return wsdl;
|
|
}
|
|
|
|
WsdlNS.Service GetOrCreateWsdlService(XmlQualifiedName wsdlServiceQName)
|
|
{
|
|
// NOTE: this method is not thread safe
|
|
|
|
WsdlNS.ServiceDescription wsdl = GetOrCreateWsdl(wsdlServiceQName.Namespace);
|
|
|
|
WsdlNS.Service wsdlService = wsdl.Services[wsdlServiceQName.Name];
|
|
if (wsdlService == null)
|
|
{
|
|
//Service not found. Create service.
|
|
wsdlService = new WsdlNS.Service();
|
|
wsdlService.Name = wsdlServiceQName.Name;
|
|
|
|
if (string.IsNullOrEmpty(wsdl.Name))
|
|
wsdl.Name = wsdlService.Name;
|
|
|
|
wsdl.Services.Add(wsdlService);
|
|
}
|
|
return wsdlService;
|
|
}
|
|
|
|
static void EnsureWsdlContainsImport(WsdlNS.ServiceDescription srcWsdl, string target)
|
|
{
|
|
if (srcWsdl.TargetNamespace == target)
|
|
return;
|
|
// FindImport
|
|
foreach (WsdlNS.Import import in srcWsdl.Imports)
|
|
{
|
|
if (import.Namespace == target)
|
|
return;
|
|
}
|
|
{
|
|
WsdlNS.Import import = new WsdlNS.Import();
|
|
import.Location = null;
|
|
import.Namespace = target;
|
|
srcWsdl.Imports.Add(import);
|
|
WsdlNamespaceHelper.FindOrCreatePrefix("i", target, srcWsdl);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void LogExportWarning(string warningMessage)
|
|
{
|
|
this.Errors.Add(new MetadataConversionError(warningMessage, true));
|
|
}
|
|
|
|
static internal XmlSchemaSet GetEmptySchemaSet()
|
|
{
|
|
XmlSchemaSet schemaSet = new XmlSchemaSet();
|
|
schemaSet.XmlResolver = null;
|
|
return schemaSet;
|
|
}
|
|
|
|
static bool IsWsdlExportable(Binding binding)
|
|
{
|
|
BindingElementCollection bindingElements = binding.CreateBindingElements();
|
|
if (bindingElements == null)
|
|
{
|
|
return true;
|
|
}
|
|
foreach (BindingElement bindingElement in bindingElements)
|
|
{
|
|
MessageEncodingBindingElement messageEncodingBindingElement = bindingElement as MessageEncodingBindingElement;
|
|
if (messageEncodingBindingElement != null && !messageEncodingBindingElement.IsWsdlExportable)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
internal static class WSAddressingHelper
|
|
{
|
|
internal static void AddActionAttribute(string actionUri, WsdlNS.OperationMessage wsdlOperationMessage, PolicyVersion policyVersion)
|
|
{
|
|
XmlAttribute attribute;
|
|
if (policyVersion == PolicyVersion.Policy12)
|
|
{
|
|
attribute = WsdlExporter.XmlDoc.CreateAttribute(MetadataStrings.AddressingWsdl.Prefix,
|
|
MetadataStrings.AddressingWsdl.Action,
|
|
MetadataStrings.AddressingWsdl.NamespaceUri);
|
|
}
|
|
else
|
|
{
|
|
attribute = WsdlExporter.XmlDoc.CreateAttribute(MetadataStrings.AddressingMetadata.Prefix,
|
|
MetadataStrings.AddressingMetadata.Action,
|
|
MetadataStrings.AddressingMetadata.NamespaceUri);
|
|
}
|
|
|
|
attribute.Value = actionUri;
|
|
wsdlOperationMessage.ExtensibleAttributes = new XmlAttribute[] { attribute };
|
|
}
|
|
|
|
internal static void AddAddressToWsdlPort(WsdlNS.Port wsdlPort, EndpointAddress addr, AddressingVersion addressing)
|
|
{
|
|
if (addressing == AddressingVersion.None)
|
|
{
|
|
return;
|
|
}
|
|
|
|
MemoryStream stream = new MemoryStream();
|
|
XmlWriter xw = XmlWriter.Create(stream);
|
|
xw.WriteStartElement("temp");
|
|
|
|
if (addressing == AddressingVersion.WSAddressing10)
|
|
{
|
|
xw.WriteAttributeString("xmlns", MetadataStrings.Addressing10.Prefix, null, MetadataStrings.Addressing10.NamespaceUri);
|
|
}
|
|
else if (addressing == AddressingVersion.WSAddressingAugust2004)
|
|
{
|
|
xw.WriteAttributeString("xmlns", MetadataStrings.Addressing200408.Prefix, null, MetadataStrings.Addressing200408.NamespaceUri);
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new InvalidOperationException(SR.GetString(SR.AddressingVersionNotSupported, addressing)));
|
|
}
|
|
|
|
addr.WriteTo(addressing, xw);
|
|
xw.WriteEndElement();
|
|
|
|
xw.Flush();
|
|
stream.Seek(0, SeekOrigin.Begin);
|
|
|
|
XmlReader xr = XmlReader.Create(stream);
|
|
xr.MoveToContent();
|
|
XmlElement endpointRef = (XmlElement)XmlDoc.ReadNode(xr).ChildNodes[0];
|
|
|
|
wsdlPort.Extensions.Add(endpointRef);
|
|
}
|
|
|
|
internal static void AddWSAddressingAssertion(MetadataExporter exporter, PolicyConversionContext context, AddressingVersion addressVersion)
|
|
{
|
|
XmlElement addressingAssertion;
|
|
if (addressVersion == AddressingVersion.WSAddressingAugust2004)
|
|
{
|
|
addressingAssertion = XmlDoc.CreateElement(MetadataStrings.Addressing200408.Policy.Prefix,
|
|
MetadataStrings.Addressing200408.Policy.UsingAddressing,
|
|
MetadataStrings.Addressing200408.Policy.NamespaceUri);
|
|
}
|
|
else if (addressVersion == AddressingVersion.WSAddressing10)
|
|
{
|
|
if (exporter.PolicyVersion == PolicyVersion.Policy12)
|
|
{
|
|
addressingAssertion = XmlDoc.CreateElement(MetadataStrings.Addressing10.WsdlBindingPolicy.Prefix,
|
|
MetadataStrings.Addressing10.WsdlBindingPolicy.UsingAddressing,
|
|
MetadataStrings.Addressing10.WsdlBindingPolicy.NamespaceUri);
|
|
}
|
|
else
|
|
{
|
|
addressingAssertion = XmlDoc.CreateElement(MetadataStrings.Addressing10.MetadataPolicy.Prefix,
|
|
MetadataStrings.Addressing10.MetadataPolicy.Addressing,
|
|
MetadataStrings.Addressing10.MetadataPolicy.NamespaceUri);
|
|
|
|
// All of our existing transports are anonymous, so default to it.
|
|
SupportedAddressingMode mode = SupportedAddressingMode.Anonymous;
|
|
string key = typeof(SupportedAddressingMode).Name;
|
|
|
|
if (exporter.State.ContainsKey(key) && exporter.State[key] is SupportedAddressingMode)
|
|
{
|
|
mode = (SupportedAddressingMode)exporter.State[key];
|
|
if (!SupportedAddressingModeHelper.IsDefined(mode))
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SupportedAddressingModeNotSupported, mode)));
|
|
}
|
|
|
|
if (mode != SupportedAddressingMode.Mixed)
|
|
{
|
|
string responsesAssertionLocalName;
|
|
if (mode == SupportedAddressingMode.Anonymous)
|
|
{
|
|
responsesAssertionLocalName = MetadataStrings.Addressing10.MetadataPolicy.AnonymousResponses;
|
|
}
|
|
else
|
|
{
|
|
responsesAssertionLocalName = MetadataStrings.Addressing10.MetadataPolicy.NonAnonymousResponses;
|
|
}
|
|
|
|
XmlElement innerPolicyElement = XmlDoc.CreateElement(MetadataStrings.WSPolicy.Prefix,
|
|
MetadataStrings.WSPolicy.Elements.Policy,
|
|
MetadataStrings.WSPolicy.NamespaceUri15);
|
|
|
|
XmlElement responsesAssertion = XmlDoc.CreateElement(MetadataStrings.Addressing10.MetadataPolicy.Prefix,
|
|
responsesAssertionLocalName,
|
|
MetadataStrings.Addressing10.MetadataPolicy.NamespaceUri);
|
|
|
|
innerPolicyElement.AppendChild(responsesAssertion);
|
|
addressingAssertion.AppendChild(innerPolicyElement);
|
|
}
|
|
}
|
|
}
|
|
else if (addressVersion == AddressingVersion.None)
|
|
{
|
|
// do nothing
|
|
addressingAssertion = null;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new InvalidOperationException(SR.GetString(SR.AddressingVersionNotSupported, addressVersion)));
|
|
}
|
|
|
|
if (addressingAssertion != null)
|
|
{
|
|
context.GetBindingAssertions().Add(addressingAssertion);
|
|
}
|
|
}
|
|
}
|
|
|
|
class WSPolicyAttachmentHelper
|
|
{
|
|
PolicyVersion policyVersion;
|
|
internal WSPolicyAttachmentHelper(PolicyVersion policyVersion)
|
|
{
|
|
this.policyVersion = policyVersion;
|
|
}
|
|
|
|
internal void AttachPolicy(ServiceEndpoint endpoint, WsdlEndpointConversionContext endpointContext, PolicyConversionContext policyContext)
|
|
{
|
|
SortedList<string, string> policyKeys = new SortedList<string, string>();
|
|
NamingHelper.DoesNameExist policyKeyIsUnique
|
|
= delegate(string name, object nameCollection)
|
|
{
|
|
return policyKeys.ContainsKey(name);
|
|
};
|
|
|
|
string key, keyBase;
|
|
ICollection<XmlElement> assertions;
|
|
|
|
WsdlNS.ServiceDescription policyWsdl = endpointContext.WsdlBinding.ServiceDescription;
|
|
|
|
assertions = policyContext.GetBindingAssertions();
|
|
|
|
// Add [wsdl:Binding] level Policy
|
|
WsdlNS.Binding wsdlBinding = endpointContext.WsdlBinding;
|
|
if (assertions.Count > 0)
|
|
{
|
|
keyBase = CreateBindingPolicyKey(wsdlBinding);
|
|
key = NamingHelper.GetUniqueName(keyBase, policyKeyIsUnique, null);
|
|
policyKeys.Add(key, key);
|
|
AttachItemPolicy(assertions, key, policyWsdl, wsdlBinding);
|
|
}
|
|
|
|
foreach (OperationDescription operation in endpoint.Contract.Operations)
|
|
{
|
|
if (!WsdlExporter.OperationIsExportable(operation))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
assertions = policyContext.GetOperationBindingAssertions(operation);
|
|
|
|
// Add [wsdl:Binding/wsdl:operation] policy
|
|
if (assertions.Count > 0)
|
|
{
|
|
WsdlNS.OperationBinding wsdlOperationBinding = endpointContext.GetOperationBinding(operation);
|
|
keyBase = CreateOperationBindingPolicyKey(wsdlOperationBinding);
|
|
key = NamingHelper.GetUniqueName(keyBase, policyKeyIsUnique, null);
|
|
policyKeys.Add(key, key);
|
|
AttachItemPolicy(assertions, key, policyWsdl, wsdlOperationBinding);
|
|
}
|
|
|
|
//
|
|
// Add [wsdl:Binding/wsdl:operation] child policy
|
|
//
|
|
|
|
foreach (MessageDescription message in operation.Messages)
|
|
{
|
|
assertions = policyContext.GetMessageBindingAssertions(message);
|
|
|
|
// Add [wsdl:Binding/wsdl:operation/wsdl:(input, output, message)] policy
|
|
if (assertions.Count > 0)
|
|
{
|
|
WsdlNS.MessageBinding wsdlMessageBinding = endpointContext.GetMessageBinding(message);
|
|
keyBase = CreateMessageBindingPolicyKey(wsdlMessageBinding, message.Direction);
|
|
key = NamingHelper.GetUniqueName(keyBase, policyKeyIsUnique, null);
|
|
policyKeys.Add(key, key);
|
|
AttachItemPolicy(assertions, key, policyWsdl, wsdlMessageBinding);
|
|
}
|
|
}
|
|
|
|
foreach (FaultDescription fault in operation.Faults)
|
|
{
|
|
assertions = policyContext.GetFaultBindingAssertions(fault);
|
|
|
|
// Add [wsdl:Binding/wsdl:operation/wsdl:fault] policy
|
|
if (assertions.Count > 0)
|
|
{
|
|
WsdlNS.FaultBinding wsdlFaultBinding = endpointContext.GetFaultBinding(fault);
|
|
keyBase = CreateFaultBindingPolicyKey(wsdlFaultBinding);
|
|
key = NamingHelper.GetUniqueName(keyBase, policyKeyIsUnique, null);
|
|
policyKeys.Add(key, key);
|
|
AttachItemPolicy(assertions, key, policyWsdl, wsdlFaultBinding);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void AttachItemPolicy(ICollection<XmlElement> assertions, string key, WsdlNS.ServiceDescription policyWsdl, WsdlNS.DocumentableItem item)
|
|
{
|
|
string policyKey = InsertPolicy(key, policyWsdl, assertions);
|
|
InsertPolicyReference(policyKey, item);
|
|
}
|
|
|
|
void InsertPolicyReference(string policyKey, WsdlNS.DocumentableItem item)
|
|
{
|
|
//Create wsp:PolicyReference Element On DocumentableItem
|
|
//---------------------------------------------------------------------------------------------------------
|
|
XmlElement policyReferenceElement = XmlDoc.CreateElement(MetadataStrings.WSPolicy.Prefix,
|
|
MetadataStrings.WSPolicy.Elements.PolicyReference,
|
|
policyVersion.Namespace);
|
|
|
|
//Create wsp:PolicyURIs Attribute On DocumentableItem
|
|
//---------------------------------------------------------------------------------------------------------
|
|
XmlAttribute uriAttribute = XmlDoc.CreateAttribute(MetadataStrings.WSPolicy.Attributes.URI);
|
|
|
|
uriAttribute.Value = policyKey;
|
|
policyReferenceElement.Attributes.Append(uriAttribute);
|
|
item.Extensions.Add(policyReferenceElement);
|
|
}
|
|
|
|
string InsertPolicy(string key, WsdlNS.ServiceDescription policyWsdl, ICollection<XmlElement> assertions)
|
|
{
|
|
// Create [wsp:Policy]
|
|
XmlElement policyElement = CreatePolicyElement(assertions);
|
|
|
|
//Create [wsp:Policy/@wsu:Id]
|
|
XmlAttribute idAttribute = XmlDoc.CreateAttribute(MetadataStrings.Wsu.Prefix,
|
|
MetadataStrings.Wsu.Attributes.Id,
|
|
MetadataStrings.Wsu.NamespaceUri);
|
|
idAttribute.Value = key;
|
|
policyElement.SetAttributeNode(idAttribute);
|
|
|
|
// Add wsp:Policy To WSDL
|
|
if (policyWsdl != null)
|
|
{
|
|
policyWsdl.Extensions.Add(policyElement);
|
|
}
|
|
|
|
return string.Format(CultureInfo.InvariantCulture, "#{0}", key);
|
|
}
|
|
|
|
XmlElement CreatePolicyElement(ICollection<XmlElement> assertions)
|
|
{
|
|
// Create [wsp:Policy]
|
|
XmlElement policyElement = XmlDoc.CreateElement(MetadataStrings.WSPolicy.Prefix,
|
|
MetadataStrings.WSPolicy.Elements.Policy,
|
|
policyVersion.Namespace);
|
|
|
|
// Create [wsp:Policy/wsp:ExactlyOne]
|
|
XmlElement exactlyOneElement = XmlDoc.CreateElement(MetadataStrings.WSPolicy.Prefix,
|
|
MetadataStrings.WSPolicy.Elements.ExactlyOne,
|
|
policyVersion.Namespace);
|
|
policyElement.AppendChild(exactlyOneElement);
|
|
|
|
// Create [wsp:Policy/wsp:ExactlyOne/wsp:All]
|
|
XmlElement allElement = XmlDoc.CreateElement(MetadataStrings.WSPolicy.Prefix,
|
|
MetadataStrings.WSPolicy.Elements.All,
|
|
policyVersion.Namespace);
|
|
exactlyOneElement.AppendChild(allElement);
|
|
|
|
// Add [wsp:Policy/wsp:ExactlyOne/wsp:All/*]
|
|
foreach (XmlElement assertion in assertions)
|
|
{
|
|
XmlNode iNode = XmlDoc.ImportNode(assertion, true);
|
|
allElement.AppendChild(iNode);
|
|
}
|
|
|
|
return policyElement;
|
|
}
|
|
|
|
static string CreateBindingPolicyKey(WsdlNS.Binding wsdlBinding)
|
|
{
|
|
return string.Format(CultureInfo.InvariantCulture, "{0}_policy", wsdlBinding.Name);
|
|
}
|
|
|
|
static string CreateOperationBindingPolicyKey(WsdlNS.OperationBinding wsdlOperationBinding)
|
|
{
|
|
return string.Format(CultureInfo.InvariantCulture, "{0}_{1}_policy",
|
|
wsdlOperationBinding.Binding.Name,
|
|
wsdlOperationBinding.Name);
|
|
}
|
|
|
|
static string CreateMessageBindingPolicyKey(WsdlNS.MessageBinding wsdlMessageBinding, MessageDirection direction)
|
|
{
|
|
WsdlNS.OperationBinding wsdlOperationBinding = wsdlMessageBinding.OperationBinding;
|
|
WsdlNS.Binding wsdlBinding = wsdlOperationBinding.Binding;
|
|
|
|
if (direction == MessageDirection.Input)
|
|
return string.Format(CultureInfo.InvariantCulture, "{0}_{1}_Input_policy", wsdlBinding.Name, wsdlOperationBinding.Name);
|
|
else
|
|
return string.Format(CultureInfo.InvariantCulture, "{0}_{1}_output_policy", wsdlBinding.Name, wsdlOperationBinding.Name);
|
|
}
|
|
|
|
static string CreateFaultBindingPolicyKey(WsdlNS.FaultBinding wsdlFaultBinding)
|
|
{
|
|
WsdlNS.OperationBinding wsdlOperationBinding = wsdlFaultBinding.OperationBinding;
|
|
WsdlNS.Binding wsdlBinding = wsdlOperationBinding.Binding;
|
|
if (string.IsNullOrEmpty(wsdlFaultBinding.Name))
|
|
{
|
|
return string.Format(CultureInfo.InvariantCulture, "{0}_{1}_Fault", wsdlBinding.Name, wsdlOperationBinding.Name);
|
|
}
|
|
else
|
|
{
|
|
return string.Format(CultureInfo.InvariantCulture, "{0}_{1}_{2}_Fault", wsdlBinding.Name, wsdlOperationBinding.Name, wsdlFaultBinding.Name);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
class WsdlNamespaceHelper
|
|
{
|
|
XmlSerializerNamespaces xmlSerializerNamespaces;
|
|
PolicyVersion policyVersion;
|
|
internal XmlSerializerNamespaces SerializerNamespaces
|
|
{
|
|
get
|
|
{
|
|
if (xmlSerializerNamespaces == null)
|
|
{
|
|
XmlSerializerNamespaceWrapper namespaces = new XmlSerializerNamespaceWrapper();
|
|
namespaces.Add("wsdl", WsdlNS.ServiceDescription.Namespace);
|
|
namespaces.Add("xsd", XmlSchema.Namespace);
|
|
namespaces.Add(MetadataStrings.WSPolicy.Prefix, policyVersion.Namespace);
|
|
namespaces.Add(MetadataStrings.Wsu.Prefix, MetadataStrings.Wsu.NamespaceUri);
|
|
namespaces.Add(MetadataStrings.Addressing200408.Prefix, MetadataStrings.Addressing200408.NamespaceUri);
|
|
namespaces.Add(MetadataStrings.Addressing200408.Policy.Prefix, MetadataStrings.Addressing200408.Policy.NamespaceUri);
|
|
namespaces.Add(MetadataStrings.Addressing10.Prefix, MetadataStrings.Addressing10.NamespaceUri);
|
|
namespaces.Add(MetadataStrings.Addressing10.WsdlBindingPolicy.Prefix, MetadataStrings.Addressing10.WsdlBindingPolicy.NamespaceUri);
|
|
namespaces.Add(MetadataStrings.Addressing10.MetadataPolicy.Prefix, MetadataStrings.Addressing10.MetadataPolicy.NamespaceUri);
|
|
namespaces.Add(MetadataStrings.MetadataExchangeStrings.Prefix, MetadataStrings.MetadataExchangeStrings.Namespace);
|
|
namespaces.Add(NetSessionHelper.Prefix, NetSessionHelper.NamespaceUri);
|
|
|
|
namespaces.Add("soapenc", "http://schemas.xmlsoap.org/soap/encoding/");
|
|
namespaces.Add("soap12", "http://schemas.xmlsoap.org/wsdl/soap12/");
|
|
namespaces.Add("soap", "http://schemas.xmlsoap.org/wsdl/soap/");
|
|
|
|
xmlSerializerNamespaces = namespaces.GetNamespaces();
|
|
}
|
|
return xmlSerializerNamespaces;
|
|
}
|
|
}
|
|
|
|
internal WsdlNamespaceHelper(PolicyVersion policyVersion)
|
|
{
|
|
this.policyVersion = policyVersion;
|
|
}
|
|
|
|
// doesn't care if you add a duplicate prefix
|
|
class XmlSerializerNamespaceWrapper
|
|
{
|
|
readonly XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces();
|
|
readonly Dictionary<string, string> lookup = new Dictionary<string, string>();
|
|
|
|
internal void Add(string prefix, string namespaceUri)
|
|
{
|
|
if (!lookup.ContainsKey(prefix))
|
|
{
|
|
namespaces.Add(prefix, namespaceUri);
|
|
lookup.Add(prefix, namespaceUri);
|
|
}
|
|
}
|
|
|
|
internal XmlSerializerNamespaces GetNamespaces()
|
|
{
|
|
return namespaces;
|
|
}
|
|
}
|
|
|
|
internal static string FindOrCreatePrefix(string prefixBase, string ns, params WsdlNS.DocumentableItem[] scopes)
|
|
{
|
|
if (!(scopes.Length > 0))
|
|
{
|
|
Fx.Assert("You must pass at least one namespaceScope");
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "You must pass at least one namespaceScope")));
|
|
}
|
|
string prefix = null;
|
|
|
|
if (string.IsNullOrEmpty(ns))
|
|
{
|
|
prefix = string.Empty;
|
|
}
|
|
else
|
|
{
|
|
//See if a prefix for the namespace has already been defined at one of the scopes
|
|
for (int j = 0; j < scopes.Length; j++)
|
|
if (TryMatchNamespace(scopes[j].Namespaces.ToArray(), ns, out prefix))
|
|
return prefix;
|
|
|
|
// Create prefix definition at the nearest scope.
|
|
int i = 0;
|
|
prefix = prefixBase + i.ToString(CultureInfo.InvariantCulture);
|
|
|
|
//[....], consider do we need to check at higher scopes as well?
|
|
while (PrefixExists(scopes[0].Namespaces.ToArray(), prefix))
|
|
prefix = prefixBase + (++i).ToString(CultureInfo.InvariantCulture);
|
|
}
|
|
scopes[0].Namespaces.Add(prefix, ns);
|
|
|
|
return prefix;
|
|
}
|
|
|
|
static bool PrefixExists(XmlQualifiedName[] prefixDefinitions, string prefix)
|
|
{
|
|
return Array.Exists<XmlQualifiedName>(prefixDefinitions,
|
|
delegate(XmlQualifiedName prefixDef)
|
|
{
|
|
if (prefixDef.Name == prefix)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
|
|
}
|
|
|
|
static bool TryMatchNamespace(XmlQualifiedName[] prefixDefinitions, string ns, out string prefix)
|
|
{
|
|
string foundPrefix = null;
|
|
Array.Find<XmlQualifiedName>(prefixDefinitions,
|
|
delegate(XmlQualifiedName prefixDef)
|
|
{
|
|
if (prefixDef.Namespace == ns)
|
|
{
|
|
foundPrefix = prefixDef.Name;
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
|
|
prefix = foundPrefix;
|
|
return foundPrefix != null;
|
|
}
|
|
}
|
|
|
|
internal static class WsdlNamingHelper
|
|
{
|
|
internal static XmlQualifiedName GetPortTypeQName(ContractDescription contract)
|
|
{
|
|
return new XmlQualifiedName(contract.Name, contract.Namespace);
|
|
}
|
|
|
|
internal static XmlQualifiedName GetBindingQName(ServiceEndpoint endpoint, WsdlExporter exporter, out bool wasUniquified)
|
|
{
|
|
// due to problems in Sysytem.Web.Services.Descriprion.ServiceDescription.Write() (double encoding) method we cannot use encoded names for
|
|
// wsdl:binding item: we need to make sure that XmlConvert.EncodeLocalName will not find any problems with the name, and leave it unchanged.
|
|
// consider changing the name here to something that will not be encoded by XmlSerializer (GenerateSimpleXmlName()?)
|
|
string localName = endpoint.Name;
|
|
|
|
string bindingWsdlNamespace = endpoint.Binding.Namespace;
|
|
string uniquifiedLocalName = NamingHelper.GetUniqueName(localName, WsdlBindingQNameExists(exporter, bindingWsdlNamespace), null);
|
|
wasUniquified = localName != uniquifiedLocalName;
|
|
|
|
return new XmlQualifiedName(uniquifiedLocalName, bindingWsdlNamespace);
|
|
}
|
|
|
|
static NamingHelper.DoesNameExist WsdlBindingQNameExists(WsdlExporter exporter, string bindingWsdlNamespace)
|
|
{
|
|
return delegate(string localName, object nameCollection)
|
|
{
|
|
XmlQualifiedName wsdlBindingQName = new XmlQualifiedName(localName, bindingWsdlNamespace);
|
|
WsdlNS.ServiceDescription wsdl = exporter.wsdlDocuments[bindingWsdlNamespace];
|
|
if (wsdl != null && wsdl.Bindings[localName] != null)
|
|
return true;
|
|
|
|
return false;
|
|
};
|
|
}
|
|
|
|
|
|
|
|
internal static string GetPortName(ServiceEndpoint endpoint, WsdlNS.Service wsdlService)
|
|
{
|
|
return NamingHelper.GetUniqueName(endpoint.Name, ServiceContainsPort(wsdlService), null);
|
|
}
|
|
|
|
static NamingHelper.DoesNameExist ServiceContainsPort(WsdlNS.Service service)
|
|
{
|
|
return delegate(string portName, object nameCollection)
|
|
{
|
|
foreach (WsdlNS.Port port in service.Ports)
|
|
if (port.Name == portName)
|
|
return true;
|
|
return false;
|
|
};
|
|
}
|
|
|
|
internal static string GetWsdlOperationName(OperationDescription operationDescription, ContractDescription parentContractDescription)
|
|
{
|
|
return operationDescription.Name;
|
|
}
|
|
}
|
|
|
|
internal static class NetSessionHelper
|
|
{
|
|
internal const string NamespaceUri = "http://schemas.microsoft.com/ws/2005/12/wsdl/contract";
|
|
internal const string Prefix = "msc";
|
|
internal const string UsingSession = "usingSession";
|
|
internal const string IsInitiating = "isInitiating";
|
|
internal const string IsTerminating = "isTerminating";
|
|
internal const string True = "true";
|
|
internal const string False = "false";
|
|
|
|
internal static void AddUsingSessionAttributeIfNeeded(WsdlNS.PortType wsdlPortType, ContractDescription contract)
|
|
{
|
|
bool sessionValue;
|
|
|
|
if (contract.SessionMode == SessionMode.Required)
|
|
{
|
|
sessionValue = true;
|
|
}
|
|
else if (contract.SessionMode == SessionMode.NotAllowed)
|
|
{
|
|
sessionValue = false;
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
|
|
wsdlPortType.ExtensibleAttributes = CloneAndAddToAttributes(wsdlPortType.ExtensibleAttributes, NetSessionHelper.Prefix,
|
|
NetSessionHelper.UsingSession, NetSessionHelper.NamespaceUri, ToValue(sessionValue));
|
|
}
|
|
|
|
internal static void AddInitiatingTerminatingAttributesIfNeeded(WsdlNS.Operation wsdlOperation,
|
|
OperationDescription operation, ContractDescription contract)
|
|
{
|
|
if (contract.SessionMode == SessionMode.Required)
|
|
{
|
|
AddInitiatingAttribute(wsdlOperation, operation.IsInitiating);
|
|
AddTerminatingAttribute(wsdlOperation, operation.IsTerminating);
|
|
}
|
|
}
|
|
|
|
static void AddInitiatingAttribute(System.Web.Services.Description.Operation wsdlOperation, bool isInitiating)
|
|
{
|
|
wsdlOperation.ExtensibleAttributes = CloneAndAddToAttributes(wsdlOperation.ExtensibleAttributes, NetSessionHelper.Prefix,
|
|
NetSessionHelper.IsInitiating, NetSessionHelper.NamespaceUri, ToValue(isInitiating));
|
|
}
|
|
|
|
static void AddTerminatingAttribute(System.Web.Services.Description.Operation wsdlOperation, bool isTerminating)
|
|
{
|
|
wsdlOperation.ExtensibleAttributes = CloneAndAddToAttributes(wsdlOperation.ExtensibleAttributes, NetSessionHelper.Prefix,
|
|
NetSessionHelper.IsTerminating, NetSessionHelper.NamespaceUri, ToValue(isTerminating));
|
|
}
|
|
|
|
static XmlAttribute[] CloneAndAddToAttributes(XmlAttribute[] originalAttributes, string prefix, string localName, string ns, string value)
|
|
{
|
|
XmlAttribute newAttribute = XmlDoc.CreateAttribute(prefix, localName, ns);
|
|
newAttribute.Value = value;
|
|
|
|
int originalAttributeCount = 0;
|
|
if (originalAttributes != null)
|
|
originalAttributeCount = originalAttributes.Length;
|
|
|
|
XmlAttribute[] attributes = new XmlAttribute[originalAttributeCount + 1];
|
|
|
|
if (originalAttributes != null)
|
|
originalAttributes.CopyTo(attributes, 0);
|
|
|
|
attributes[attributes.Length - 1] = newAttribute;
|
|
|
|
return attributes;
|
|
}
|
|
|
|
static string ToValue(bool b)
|
|
{
|
|
return b ? NetSessionHelper.True : NetSessionHelper.False;
|
|
}
|
|
}
|
|
|
|
void CallExtension(WsdlContractConversionContext contractContext, IWsdlExportExtension extension)
|
|
{
|
|
try
|
|
{
|
|
extension.ExportContract(this, contractContext);
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
throw;
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ThrowExtensionException(contractContext.Contract, extension, e));
|
|
}
|
|
}
|
|
|
|
void CallExtension(WsdlEndpointConversionContext endpointContext, IWsdlExportExtension extension)
|
|
{
|
|
try
|
|
{
|
|
extension.ExportEndpoint(this, endpointContext);
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
throw;
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ThrowExtensionException(endpointContext.Endpoint, extension, e));
|
|
}
|
|
}
|
|
|
|
Exception ThrowExtensionException(ContractDescription contract, IWsdlExportExtension exporter, Exception e)
|
|
{
|
|
string contractIdentifier = new XmlQualifiedName(contract.Name, contract.Namespace).ToString();
|
|
string errorMessage = SR.GetString(SR.WsdlExtensionContractExportError, exporter.GetType(), contractIdentifier);
|
|
|
|
return new InvalidOperationException(errorMessage, e);
|
|
}
|
|
|
|
Exception ThrowExtensionException(ServiceEndpoint endpoint, IWsdlExportExtension exporter, Exception e)
|
|
{
|
|
string endpointIdentifier;
|
|
if (endpoint.Address != null && endpoint.Address.Uri != null)
|
|
endpointIdentifier = endpoint.Address.Uri.ToString();
|
|
else
|
|
endpointIdentifier = String.Format(CultureInfo.InvariantCulture,
|
|
"Contract={1}:{0} ,Binding={3}:{2}",
|
|
endpoint.Contract.Name,
|
|
endpoint.Contract.Namespace,
|
|
endpoint.Binding.Name,
|
|
endpoint.Binding.Namespace);
|
|
|
|
string errorMessage = SR.GetString(SR.WsdlExtensionEndpointExportError, exporter.GetType(), endpointIdentifier);
|
|
|
|
return new InvalidOperationException(errorMessage, e);
|
|
}
|
|
|
|
sealed class BindingDictionaryKey
|
|
{
|
|
public readonly ContractDescription Contract;
|
|
public readonly Binding Binding;
|
|
|
|
public BindingDictionaryKey(ContractDescription contract, Binding binding)
|
|
{
|
|
this.Contract = contract;
|
|
this.Binding = binding;
|
|
}
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
BindingDictionaryKey key = obj as BindingDictionaryKey;
|
|
if (key != null && key.Binding == this.Binding && key.Contract == this.Contract)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return this.Contract.GetHashCode() ^ this.Binding.GetHashCode();
|
|
}
|
|
}
|
|
|
|
sealed class EndpointDictionaryKey
|
|
{
|
|
public readonly ServiceEndpoint Endpoint;
|
|
public readonly XmlQualifiedName ServiceQName;
|
|
|
|
public EndpointDictionaryKey(ServiceEndpoint endpoint, XmlQualifiedName serviceQName)
|
|
{
|
|
this.Endpoint = endpoint;
|
|
this.ServiceQName = serviceQName;
|
|
}
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
EndpointDictionaryKey key = obj as EndpointDictionaryKey;
|
|
if (key != null && key.Endpoint == this.Endpoint && key.ServiceQName == this.ServiceQName)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return this.Endpoint.GetHashCode() ^ this.ServiceQName.GetHashCode();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|