Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

1399 lines
55 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Description
{
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Net;
using System.Net.Mime;
using System.Runtime;
using System.Runtime.Diagnostics;
using System.Security;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Configuration;
using System.ServiceModel.Diagnostics;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using WsdlNS = System.Web.Services.Description;
using XsdNS = System.Xml.Schema;
public class MetadataExchangeClient
{
ChannelFactory<IMetadataExchange> factory;
ICredentials webRequestCredentials;
TimeSpan resolveTimeout = TimeSpan.FromMinutes(1);
int maximumResolvedReferences = 10;
bool resolveMetadataReferences = true;
long maxMessageSize;
XmlDictionaryReaderQuotas readerQuotas;
EndpointAddress ctorEndpointAddress = null;
Uri ctorUri = null;
object thisLock = new object();
internal const string MetadataExchangeClientKey = "MetadataExchangeClientKey";
public MetadataExchangeClient()
{
this.factory = new ChannelFactory<IMetadataExchange>("*");
this.maxMessageSize = GetMaxMessageSize(this.factory.Endpoint.Binding);
}
public MetadataExchangeClient(Uri address, MetadataExchangeClientMode mode)
{
Validate(address, mode);
if (mode == MetadataExchangeClientMode.HttpGet)
{
this.ctorUri = address;
}
else
{
this.ctorEndpointAddress = new EndpointAddress(address);
}
CreateChannelFactory(address.Scheme);
}
public MetadataExchangeClient(EndpointAddress address)
{
if (address == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("address");
}
this.ctorEndpointAddress = address;
CreateChannelFactory(address.Uri.Scheme);
}
public MetadataExchangeClient(string endpointConfigurationName)
{
if (endpointConfigurationName == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpointConfigurationName");
}
this.factory = new ChannelFactory<IMetadataExchange>(endpointConfigurationName);
this.maxMessageSize = GetMaxMessageSize(this.factory.Endpoint.Binding);
}
public MetadataExchangeClient(Binding mexBinding)
{
if (mexBinding == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("mexBinding");
}
this.factory = new ChannelFactory<IMetadataExchange>(mexBinding);
this.maxMessageSize = GetMaxMessageSize(this.factory.Endpoint.Binding);
}
//Configuration for credentials
public ClientCredentials SoapCredentials
{
get { return this.factory.Credentials; }
set
{
if (value == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
}
this.factory.Endpoint.Behaviors.RemoveAll<ClientCredentials>();
this.factory.Endpoint.Behaviors.Add(value);
}
}
public ICredentials HttpCredentials
{
get { return this.webRequestCredentials; }
set { this.webRequestCredentials = value; }
}
// Configuration options for the entire MetadataResolver
public TimeSpan OperationTimeout
{
get { return this.resolveTimeout; }
set
{
if (value < TimeSpan.Zero)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
SR.GetString(SR.SFxTimeoutOutOfRange0)));
}
if (TimeoutHelper.IsTooLarge(value))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
SR.GetString(SR.SFxTimeoutOutOfRangeTooBig)));
}
this.resolveTimeout = value;
}
}
public int MaximumResolvedReferences
{
get { return this.maximumResolvedReferences; }
set
{
if (value < 1)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", SR.GetString(SR.SFxMaximumResolvedReferencesOutOfRange, value)));
}
this.maximumResolvedReferences = value;
}
}
public bool ResolveMetadataReferences
{
get { return this.resolveMetadataReferences; }
set { this.resolveMetadataReferences = value; }
}
internal object ThisLock
{
get { return this.thisLock; }
}
internal long MaxMessageSize
{
get { return this.maxMessageSize; }
set { this.maxMessageSize = value; }
}
internal XmlDictionaryReaderQuotas ReaderQuotas
{
get
{
if (this.readerQuotas == null)
{
if (this.factory != null)
{
BindingElementCollection bindingElementCollection = this.factory.Endpoint.Binding.CreateBindingElements();
if (bindingElementCollection != null)
{
MessageEncodingBindingElement bindingElement = bindingElementCollection.Find<MessageEncodingBindingElement>();
if (bindingElement != null)
{
this.readerQuotas = bindingElement.GetIndividualProperty<XmlDictionaryReaderQuotas>();
}
}
}
this.readerQuotas = this.readerQuotas ?? EncoderDefaults.ReaderQuotas;
}
return this.readerQuotas;
}
}
[Fx.Tag.SecurityNote(Critical = "Uses ClientSection.UnsafeGetSection to get config in PT.",
Safe = "Does not leak config object, just calculates a bool.")]
[SecuritySafeCritical]
bool ClientEndpointExists(string name)
{
ClientSection clientSection = ClientSection.UnsafeGetSection();
if (clientSection == null)
return false;
foreach (ChannelEndpointElement endpoint in clientSection.Endpoints)
{
if (endpoint.Name == name && endpoint.Contract == ServiceMetadataBehavior.MexContractName)
return true;
}
return false;
}
bool IsHttpOrHttps(Uri address)
{
return address.Scheme == Uri.UriSchemeHttp || address.Scheme == Uri.UriSchemeHttps;
}
void CreateChannelFactory(string scheme)
{
if (ClientEndpointExists(scheme))
{
this.factory = new ChannelFactory<IMetadataExchange>(scheme);
}
else
{
Binding mexBinding = null;
if (MetadataExchangeBindings.TryGetBindingForScheme(scheme, out mexBinding))
{
this.factory = new ChannelFactory<IMetadataExchange>(mexBinding);
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("scheme", SR.GetString(SR.SFxMetadataExchangeClientCouldNotCreateChannelFactoryBadScheme, scheme));
}
}
this.maxMessageSize = GetMaxMessageSize(this.factory.Endpoint.Binding);
}
void Validate(Uri address, MetadataExchangeClientMode mode)
{
if (address == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("address");
}
if (!address.IsAbsoluteUri)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("address", SR.GetString(SR.SFxCannotGetMetadataFromRelativeAddress, address));
}
if (mode == MetadataExchangeClientMode.HttpGet && !IsHttpOrHttps(address))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("address", SR.GetString(SR.SFxCannotHttpGetMetadataFromAddress, address));
}
MetadataExchangeClientModeHelper.Validate(mode);
}
public IAsyncResult BeginGetMetadata(AsyncCallback callback, object asyncState)
{
if (ctorUri != null)
return BeginGetMetadata(ctorUri, MetadataExchangeClientMode.HttpGet, callback, asyncState);
if (ctorEndpointAddress != null)
return BeginGetMetadata(ctorEndpointAddress, callback, asyncState);
else
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxMetadataExchangeClientNoMetadataAddress)));
}
public IAsyncResult BeginGetMetadata(Uri address, MetadataExchangeClientMode mode, AsyncCallback callback, object asyncState)
{
Validate(address, mode);
if (mode == MetadataExchangeClientMode.HttpGet)
{
return this.BeginGetMetadata(new MetadataLocationRetriever(address, this), callback, asyncState);
}
else
{
return this.BeginGetMetadata(new MetadataReferenceRetriever(new EndpointAddress(address), this), callback, asyncState);
}
}
public IAsyncResult BeginGetMetadata(EndpointAddress address, AsyncCallback callback, object asyncState)
{
if (address == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("address");
}
return this.BeginGetMetadata(new MetadataReferenceRetriever(address, this), callback, asyncState);
}
IAsyncResult BeginGetMetadata(MetadataRetriever retriever, AsyncCallback callback, object asyncState)
{
ResolveCallState state = new ResolveCallState(this.maximumResolvedReferences, this.resolveMetadataReferences, new TimeoutHelper(this.OperationTimeout), this);
state.StackedRetrievers.Push(retriever);
return new AsyncMetadataResolver(state, callback, asyncState);
}
public MetadataSet EndGetMetadata(IAsyncResult result)
{
return AsyncMetadataResolver.End(result);
}
public Task<MetadataSet> GetMetadataAsync()
{
if (ctorUri != null)
return GetMetadataAsync(ctorUri, MetadataExchangeClientMode.HttpGet);
if (ctorEndpointAddress != null)
return GetMetadataAsync(ctorEndpointAddress);
else
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxMetadataExchangeClientNoMetadataAddress)));
}
public Task<MetadataSet> GetMetadataAsync(Uri address, MetadataExchangeClientMode mode)
{
Validate(address, mode);
MetadataRetriever retriever = (mode == MetadataExchangeClientMode.HttpGet)
? (MetadataRetriever) new MetadataLocationRetriever(address, this)
: (MetadataRetriever) new MetadataReferenceRetriever(new EndpointAddress(address), this);
return Task.Factory.FromAsync<MetadataRetriever, MetadataSet>(this.BeginGetMetadata, this.EndGetMetadata, retriever, /* state */ null);
}
public Task<MetadataSet> GetMetadataAsync(EndpointAddress address)
{
if (address == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("address");
}
return Task.Factory.FromAsync<MetadataRetriever, MetadataSet>(this.BeginGetMetadata, this.EndGetMetadata, new MetadataReferenceRetriever(address, this), /* state */ null);
}
public Task<MetadataSet> GetMetadataAsync(EndpointAddress address, Uri via)
{
if (address == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("address");
}
if (via == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("via");
}
return Task.Factory.FromAsync<MetadataRetriever, MetadataSet>(this.BeginGetMetadata, this.EndGetMetadata, new MetadataReferenceRetriever(address, via, this), /* state */ null);
}
public MetadataSet GetMetadata()
{
if (ctorUri != null)
return GetMetadata(ctorUri, MetadataExchangeClientMode.HttpGet);
if (ctorEndpointAddress != null)
return GetMetadata(ctorEndpointAddress);
else
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxMetadataExchangeClientNoMetadataAddress)));
}
public MetadataSet GetMetadata(Uri address, MetadataExchangeClientMode mode)
{
Validate(address, mode);
MetadataRetriever retriever;
if (mode == MetadataExchangeClientMode.HttpGet)
{
retriever = new MetadataLocationRetriever(address, this);
}
else
{
retriever = new MetadataReferenceRetriever(new EndpointAddress(address), this);
}
return GetMetadata(retriever);
}
public MetadataSet GetMetadata(EndpointAddress address)
{
if (address == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("address");
}
MetadataReferenceRetriever retriever = new MetadataReferenceRetriever(address, this);
return GetMetadata(retriever);
}
public MetadataSet GetMetadata(EndpointAddress address, Uri via)
{
if (address == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("address");
}
if (via == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("via");
}
MetadataReferenceRetriever retriever = new MetadataReferenceRetriever(address, via, this);
return GetMetadata(retriever);
}
MetadataSet GetMetadata(MetadataRetriever retriever)
{
ResolveCallState resolveCallState = new ResolveCallState(this.maximumResolvedReferences, this.resolveMetadataReferences, new TimeoutHelper(this.OperationTimeout), this);
resolveCallState.StackedRetrievers.Push(retriever);
this.ResolveNext(resolveCallState);
return resolveCallState.MetadataSet;
}
void ResolveNext(ResolveCallState resolveCallState)
{
if (resolveCallState.StackedRetrievers.Count > 0)
{
MetadataRetriever retriever = resolveCallState.StackedRetrievers.Pop();
if (resolveCallState.HasBeenUsed(retriever))
{
this.ResolveNext(resolveCallState);
}
else
{
if (resolveCallState.ResolvedMaxResolvedReferences)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxResolvedMaxResolvedReferences)));
}
resolveCallState.LogUse(retriever);
resolveCallState.HandleSection(retriever.Retrieve(resolveCallState.TimeoutHelper));
this.ResolveNext(resolveCallState);
}
}
}
protected internal virtual ChannelFactory<IMetadataExchange> GetChannelFactory(EndpointAddress metadataAddress, string dialect, string identifier)
{
return this.factory;
}
static long GetMaxMessageSize(Binding mexBinding)
{
BindingElementCollection bindingElementCollection = mexBinding.CreateBindingElements();
TransportBindingElement bindingElement = bindingElementCollection.Find<TransportBindingElement>();
if (bindingElement == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxBindingDoesNotHaveATransportBindingElement)));
}
return bindingElement.MaxReceivedMessageSize;
}
protected internal virtual HttpWebRequest GetWebRequest(Uri location, string dialect, string identifier)
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(location);
request.Method = "GET";
request.Credentials = this.HttpCredentials;
return request;
}
internal static void TraceSendRequest(Uri address)
{
TraceSendRequest(TraceCode.MetadataExchangeClientSendRequest, SR.GetString(SR.TraceCodeMetadataExchangeClientSendRequest),
address.ToString(), MetadataExchangeClientMode.HttpGet.ToString());
}
internal static void TraceSendRequest(EndpointAddress address)
{
TraceSendRequest(TraceCode.MetadataExchangeClientSendRequest, SR.GetString(SR.TraceCodeMetadataExchangeClientSendRequest),
address.ToString(), MetadataExchangeClientMode.MetadataExchange.ToString());
}
static void TraceSendRequest(int traceCode, string traceDescription, string address, string mode)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
Hashtable h = new Hashtable(2)
{
{ "Address", address },
{ "Mode", mode }
};
TraceUtility.TraceEvent(TraceEventType.Information, traceCode, traceDescription, new DictionaryTraceRecord(h), null, null);
}
}
internal static void TraceReceiveReply(string sourceUrl, Type metadataType)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
Hashtable h = new Hashtable(2);
h.Add("SourceUrl", sourceUrl);
h.Add("MetadataType", metadataType.ToString());
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.MetadataExchangeClientReceiveReply, SR.GetString(SR.TraceCodeMetadataExchangeClientReceiveReply),
new DictionaryTraceRecord(h), null, null);
}
}
class ResolveCallState
{
Dictionary<MetadataRetriever, MetadataRetriever> usedRetrievers; // to prevent looping when chasing MetadataReferences
MetadataSet metadataSet;
int maxResolvedReferences;
bool resolveMetadataReferences;
Stack<MetadataRetriever> stackedRetrievers;
MetadataExchangeClient resolver;
TimeoutHelper timeoutHelper;
internal ResolveCallState(int maxResolvedReferences, bool resolveMetadataReferences,
TimeoutHelper timeoutHelper, MetadataExchangeClient resolver)
{
this.maxResolvedReferences = maxResolvedReferences;
this.resolveMetadataReferences = resolveMetadataReferences;
this.resolver = resolver;
this.timeoutHelper = timeoutHelper;
this.metadataSet = new MetadataSet();
this.usedRetrievers = new Dictionary<MetadataRetriever, MetadataRetriever>();
this.stackedRetrievers = new Stack<MetadataRetriever>();
}
internal MetadataSet MetadataSet
{
get { return this.metadataSet; }
}
internal Stack<MetadataRetriever> StackedRetrievers
{
get { return this.stackedRetrievers; }
}
internal bool ResolvedMaxResolvedReferences
{
get { return this.usedRetrievers.Count == this.maxResolvedReferences; }
}
internal TimeoutHelper TimeoutHelper
{
get { return this.timeoutHelper; }
}
internal void HandleSection(MetadataSection section)
{
if (section.Metadata is MetadataSet)
{
foreach (MetadataSection innerSection in ((MetadataSet)section.Metadata).MetadataSections)
{
innerSection.SourceUrl = section.SourceUrl;
this.HandleSection(innerSection);
}
}
else if (section.Metadata is MetadataReference)
{
if (this.resolveMetadataReferences)
{
EndpointAddress address = ((MetadataReference)section.Metadata).Address;
MetadataRetriever retriever = new MetadataReferenceRetriever(address, this.resolver, section.Dialect, section.Identifier);
this.stackedRetrievers.Push(retriever);
}
else
{
this.metadataSet.MetadataSections.Add(section);
}
}
else if (section.Metadata is MetadataLocation)
{
if (this.resolveMetadataReferences)
{
string location = ((MetadataLocation)section.Metadata).Location;
MetadataRetriever retriever = new MetadataLocationRetriever(this.CreateUri(section.SourceUrl, location), this.resolver, section.Dialect, section.Identifier);
this.stackedRetrievers.Push(retriever);
}
else
{
this.metadataSet.MetadataSections.Add(section);
}
}
else if (section.Metadata is WsdlNS.ServiceDescription)
{
if (this.resolveMetadataReferences)
{
this.HandleWsdlImports(section);
}
this.metadataSet.MetadataSections.Add(section);
}
else if (section.Metadata is XsdNS.XmlSchema)
{
if (this.resolveMetadataReferences)
{
this.HandleSchemaImports(section);
}
this.metadataSet.MetadataSections.Add(section);
}
else
{
this.metadataSet.MetadataSections.Add(section);
}
}
void HandleSchemaImports(MetadataSection section)
{
XsdNS.XmlSchema schema = (XsdNS.XmlSchema)section.Metadata;
foreach (XsdNS.XmlSchemaExternal external in schema.Includes)
{
if (!String.IsNullOrEmpty(external.SchemaLocation))
{
EnqueueRetrieverIfShouldResolve(
new MetadataLocationRetriever(
this.CreateUri(section.SourceUrl, external.SchemaLocation),
this.resolver));
}
}
}
void HandleWsdlImports(MetadataSection section)
{
WsdlNS.ServiceDescription wsdl = (WsdlNS.ServiceDescription)section.Metadata;
foreach (WsdlNS.Import import in wsdl.Imports)
{
if (!String.IsNullOrEmpty(import.Location))
{
EnqueueRetrieverIfShouldResolve(new MetadataLocationRetriever(this.CreateUri(section.SourceUrl, import.Location), this.resolver));
}
}
foreach (XsdNS.XmlSchema schema in wsdl.Types.Schemas)
{
MetadataSection schemaSection = new MetadataSection(null, null, schema);
schemaSection.SourceUrl = section.SourceUrl;
this.HandleSchemaImports(schemaSection);
}
}
Uri CreateUri(string baseUri, string relativeUri)
{
return new Uri(new Uri(baseUri), relativeUri);
}
void EnqueueRetrieverIfShouldResolve(MetadataRetriever retriever)
{
if (this.resolveMetadataReferences)
{
this.stackedRetrievers.Push(retriever);
}
}
internal bool HasBeenUsed(MetadataRetriever retriever)
{
return this.usedRetrievers.ContainsKey(retriever);
}
internal void LogUse(MetadataRetriever retriever)
{
this.usedRetrievers.Add(retriever, retriever);
}
}
abstract class MetadataRetriever
{
protected MetadataExchangeClient resolver;
protected string dialect;
protected string identifier;
public MetadataRetriever(MetadataExchangeClient resolver, string dialect, string identifier)
{
this.resolver = resolver;
this.dialect = dialect;
this.identifier = identifier;
}
internal MetadataSection Retrieve(TimeoutHelper timeoutHelper)
{
try
{
using (XmlReader reader = this.DownloadMetadata(timeoutHelper))
{
return MetadataRetriever.CreateMetadataSection(reader, this.SourceUrl);
}
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.GetString(SR.SFxBadMetadataReference, this.SourceUrl), e));
}
}
internal abstract IAsyncResult BeginRetrieve(TimeoutHelper timeoutHelper, AsyncCallback callback, object state);
internal abstract MetadataSection EndRetrieve(IAsyncResult result);
static internal MetadataSection CreateMetadataSection(XmlReader reader, string sourceUrl)
{
MetadataSection section = null;
Type metadataType = null;
if (CanReadMetadataSet(reader))
{
MetadataSet newSet = MetadataSet.ReadFrom(reader);
section = new MetadataSection(MetadataSection.MetadataExchangeDialect, null, newSet);
metadataType = typeof(MetadataSet);
}
else if (WsdlNS.ServiceDescription.CanRead(reader))
{
WsdlNS.ServiceDescription wsdl = WsdlNS.ServiceDescription.Read(reader);
section = MetadataSection.CreateFromServiceDescription(wsdl);
metadataType = typeof(WsdlNS.ServiceDescription);
}
else if (CanReadSchema(reader))
{
XsdNS.XmlSchema schema = XsdNS.XmlSchema.Read(reader, null);
section = MetadataSection.CreateFromSchema(schema);
metadataType = typeof(XsdNS.XmlSchema);
}
else
{
XmlDocument doc = new XmlDocument();
doc.Load(reader);
section = new MetadataSection(null, null, doc.DocumentElement);
metadataType = typeof(XmlElement);
}
section.SourceUrl = sourceUrl;
TraceReceiveReply(sourceUrl, metadataType);
return section;
}
protected abstract XmlReader DownloadMetadata(TimeoutHelper timeoutHelper);
protected abstract string SourceUrl { get; }
static bool CanReadSchema(XmlReader reader)
{
return reader.LocalName == MetadataStrings.XmlSchema.Schema
&& reader.NamespaceURI == XsdNS.XmlSchema.Namespace;
}
static bool CanReadMetadataSet(XmlReader reader)
{
return reader.LocalName == MetadataStrings.MetadataExchangeStrings.Metadata
&& reader.NamespaceURI == MetadataStrings.MetadataExchangeStrings.Namespace;
}
}
class MetadataLocationRetriever : MetadataRetriever
{
Uri location;
Uri responseLocation;
internal MetadataLocationRetriever(Uri location, MetadataExchangeClient resolver)
: this(location, resolver, null, null)
{
}
internal MetadataLocationRetriever(Uri location, MetadataExchangeClient resolver, string dialect, string identifier)
: base(resolver, dialect, identifier)
{
ValidateLocation(location);
this.location = location;
this.responseLocation = location;
}
internal static void ValidateLocation(Uri location)
{
if (location == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("location");
}
if (location.Scheme != Uri.UriSchemeHttp && location.Scheme != Uri.UriSchemeHttps)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("location", SR.GetString(SR.SFxCannotGetMetadataFromLocation, location.ToString()));
}
}
public override bool Equals(object obj)
{
return obj is MetadataLocationRetriever && ((MetadataLocationRetriever)obj).location == this.location;
}
public override int GetHashCode()
{
return location.GetHashCode();
}
protected override XmlReader DownloadMetadata(TimeoutHelper timeoutHelper)
{
HttpWebResponse response;
HttpWebRequest request;
try
{
request = this.resolver.GetWebRequest(this.location, this.dialect, this.identifier);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.GetString(SR.SFxMetadataExchangeClientCouldNotCreateWebRequest, this.location, this.dialect, this.identifier), e));
}
TraceSendRequest(this.location);
request.Timeout = TimeoutHelper.ToMilliseconds(timeoutHelper.RemainingTime());
response = (HttpWebResponse)request.GetResponse();
responseLocation = request.Address;
return MetadataLocationRetriever.GetXmlReader(response, this.resolver.MaxMessageSize, this.resolver.ReaderQuotas);
}
internal static XmlReader GetXmlReader(HttpWebResponse response, long maxMessageSize, XmlDictionaryReaderQuotas readerQuotas)
{
readerQuotas = readerQuotas ?? EncoderDefaults.ReaderQuotas;
XmlReader reader = XmlDictionaryReader.CreateTextReader(
new MaxMessageSizeStream(response.GetResponseStream(), maxMessageSize),
EncodingHelper.GetDictionaryReaderEncoding(response.ContentType),
readerQuotas,
null);
reader.Read();
reader.MoveToContent();
return reader;
}
internal override IAsyncResult BeginRetrieve(TimeoutHelper timeoutHelper, AsyncCallback callback, object state)
{
AsyncMetadataLocationRetriever result;
try
{
HttpWebRequest request;
try
{
request = this.resolver.GetWebRequest(this.location, this.dialect, this.identifier);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.GetString(SR.SFxMetadataExchangeClientCouldNotCreateWebRequest, this.location, this.dialect, this.identifier), e));
}
TraceSendRequest(this.location);
result = new AsyncMetadataLocationRetriever(request, this.resolver.MaxMessageSize, this.resolver.ReaderQuotas, timeoutHelper, callback, state);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.GetString(SR.SFxBadMetadataReference, this.SourceUrl), e));
}
return result;
}
internal override MetadataSection EndRetrieve(IAsyncResult result)
{
try
{
return AsyncMetadataLocationRetriever.End(result);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.GetString(SR.SFxBadMetadataReference, this.SourceUrl), e));
}
}
protected override string SourceUrl
{
get { return this.responseLocation.ToString(); }
}
class AsyncMetadataLocationRetriever : AsyncResult
{
MetadataSection section;
long maxMessageSize;
XmlDictionaryReaderQuotas readerQuotas;
internal AsyncMetadataLocationRetriever(WebRequest request, long maxMessageSize, XmlDictionaryReaderQuotas readerQuotas, TimeoutHelper timeoutHelper, AsyncCallback callback, object state)
: base(callback, state)
{
this.maxMessageSize = maxMessageSize;
this.readerQuotas = readerQuotas;
IAsyncResult result = request.BeginGetResponse(Fx.ThunkCallback(new AsyncCallback(this.GetResponseCallback)), request);
//Register a callback to abort the request if we hit the timeout.
ThreadPool.RegisterWaitForSingleObject(result.AsyncWaitHandle,
Fx.ThunkCallback(new WaitOrTimerCallback(RetrieveTimeout)), request,
TimeoutHelper.ToMilliseconds(timeoutHelper.RemainingTime()), /* executeOnlyOnce */ true);
if (result.CompletedSynchronously)
{
HandleResult(result);
this.Complete(true);
}
}
static void RetrieveTimeout(object state, bool timedOut)
{
if (timedOut)
{
HttpWebRequest request = state as HttpWebRequest;
if (request != null)
{
request.Abort();
}
}
}
internal static MetadataSection End(IAsyncResult result)
{
AsyncMetadataLocationRetriever retrieverResult = AsyncResult.End<AsyncMetadataLocationRetriever>(result);
return retrieverResult.section;
}
internal void GetResponseCallback(IAsyncResult result)
{
if (result.CompletedSynchronously)
return;
Exception exception = null;
try
{
HandleResult(result);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
exception = e;
}
this.Complete(false, exception);
}
void HandleResult(IAsyncResult result)
{
HttpWebRequest request = (HttpWebRequest)result.AsyncState;
using (XmlReader reader =
MetadataLocationRetriever.GetXmlReader((HttpWebResponse)request.EndGetResponse(result), this.maxMessageSize, this.readerQuotas))
{
section = MetadataRetriever.CreateMetadataSection(reader, request.Address.ToString());
}
}
}
}
class MetadataReferenceRetriever : MetadataRetriever
{
EndpointAddress address;
Uri via;
public MetadataReferenceRetriever(EndpointAddress address, MetadataExchangeClient resolver)
: this(address, null, resolver, null, null)
{
}
public MetadataReferenceRetriever(EndpointAddress address, Uri via, MetadataExchangeClient resolver)
: this(address, via, resolver, null, null)
{
}
public MetadataReferenceRetriever(EndpointAddress address, MetadataExchangeClient resolver, string dialect, string identifier)
: this(address, null, resolver, dialect, identifier)
{
}
MetadataReferenceRetriever(EndpointAddress address, Uri via, MetadataExchangeClient resolver, string dialect, string identifier)
: base(resolver, dialect, identifier)
{
if (address == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("address");
}
this.address = address;
this.via = via;
}
protected override string SourceUrl
{
get { return this.address.Uri.ToString(); }
}
internal override IAsyncResult BeginRetrieve(TimeoutHelper timeoutHelper, AsyncCallback callback, object state)
{
try
{
IMetadataExchange metadataClient;
MessageVersion messageVersion;
lock (this.resolver.ThisLock)
{
ChannelFactory<IMetadataExchange> channelFactory;
try
{
channelFactory = this.resolver.GetChannelFactory(this.address, this.dialect, this.identifier);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.GetString(SR.SFxMetadataExchangeClientCouldNotCreateChannelFactory, this.address, this.dialect, this.identifier), e));
}
metadataClient = CreateChannel(channelFactory);
messageVersion = channelFactory.Endpoint.Binding.MessageVersion;
}
TraceSendRequest(this.address);
return new AsyncMetadataReferenceRetriever(metadataClient, messageVersion, timeoutHelper, callback, state);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.GetString(SR.SFxBadMetadataReference, this.SourceUrl), e));
}
}
IMetadataExchange CreateChannel(ChannelFactory<IMetadataExchange> channelFactory)
{
if (this.via != null)
{
return channelFactory.CreateChannel(this.address, this.via);
}
else
{
return channelFactory.CreateChannel(this.address);
}
}
static Message CreateGetMessage(MessageVersion messageVersion)
{
return Message.CreateMessage(messageVersion, MetadataStrings.WSTransfer.GetAction);
}
protected override XmlReader DownloadMetadata(TimeoutHelper timeoutHelper)
{
IMetadataExchange metadataClient;
MessageVersion messageVersion;
lock (this.resolver.ThisLock)
{
ChannelFactory<IMetadataExchange> channelFactory;
try
{
channelFactory = this.resolver.GetChannelFactory(this.address, this.dialect, this.identifier);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.GetString(SR.SFxMetadataExchangeClientCouldNotCreateChannelFactory, this.address, this.dialect, this.identifier), e));
}
metadataClient = CreateChannel(channelFactory);
messageVersion = channelFactory.Endpoint.Binding.MessageVersion;
}
Message response;
TraceSendRequest(this.address);
try
{
using (Message getMessage = CreateGetMessage(messageVersion))
{
((IClientChannel)metadataClient).OperationTimeout = timeoutHelper.RemainingTime();
response = metadataClient.Get(getMessage);
}
((IClientChannel)metadataClient).Close();
}
finally
{
((IClientChannel)metadataClient).Abort();
}
if (response.IsFault)
{
MessageFault fault = MessageFault.CreateFault(response, 64 * 1024);
StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
XmlWriter xmlWriter = XmlWriter.Create(stringWriter);
fault.WriteTo(xmlWriter, response.Version.Envelope);
xmlWriter.Flush();
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(stringWriter.ToString()));
}
return response.GetReaderAtBodyContents();
}
internal override MetadataSection EndRetrieve(IAsyncResult result)
{
try
{
return AsyncMetadataReferenceRetriever.End(result);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.GetString(SR.SFxBadMetadataReference, this.SourceUrl), e));
}
}
public override bool Equals(object obj)
{
return obj is MetadataReferenceRetriever && ((MetadataReferenceRetriever)obj).address == this.address;
}
public override int GetHashCode()
{
return address.GetHashCode();
}
class AsyncMetadataReferenceRetriever : AsyncResult
{
MetadataSection section;
Message message;
internal AsyncMetadataReferenceRetriever(IMetadataExchange metadataClient, MessageVersion messageVersion, TimeoutHelper timeoutHelper, AsyncCallback callback, object state)
: base(callback, state)
{
message = MetadataReferenceRetriever.CreateGetMessage(messageVersion);
((IClientChannel)metadataClient).OperationTimeout = timeoutHelper.RemainingTime();
IAsyncResult result = metadataClient.BeginGet(message, Fx.ThunkCallback(new AsyncCallback(this.RequestCallback)), metadataClient);
if (result.CompletedSynchronously)
{
HandleResult(result);
this.Complete(true);
}
}
internal static MetadataSection End(IAsyncResult result)
{
AsyncMetadataReferenceRetriever retrieverResult = AsyncResult.End<AsyncMetadataReferenceRetriever>(result);
return retrieverResult.section;
}
internal void RequestCallback(IAsyncResult result)
{
if (result.CompletedSynchronously)
return;
Exception exception = null;
try
{
HandleResult(result);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
exception = e;
}
this.Complete(false, exception);
}
void HandleResult(IAsyncResult result)
{
IMetadataExchange metadataClient = (IMetadataExchange)result.AsyncState;
Message response = metadataClient.EndGet(result);
using (this.message)
{
if (response.IsFault)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxBadMetadataReference,
((IClientChannel)metadataClient).RemoteAddress.Uri.ToString())));
}
else
{
using (XmlReader reader = response.GetReaderAtBodyContents())
{
section = MetadataRetriever.CreateMetadataSection(reader, ((IClientChannel)metadataClient).RemoteAddress.Uri.ToString());
}
}
}
}
}
}
class AsyncMetadataResolver : AsyncResult
{
ResolveCallState resolveCallState;
internal AsyncMetadataResolver(ResolveCallState resolveCallState, AsyncCallback callerCallback, object callerAsyncState)
: base(callerCallback, callerAsyncState)
{
if (resolveCallState == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("resolveCallState");
}
this.resolveCallState = resolveCallState;
Exception exception = null;
bool doneResolving = false;
try
{
doneResolving = this.ResolveNext();
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
exception = e;
doneResolving = true;
}
if (doneResolving)
{
this.Complete(true, exception);
}
}
bool ResolveNext()
{
bool doneResolving = false;
if (this.resolveCallState.StackedRetrievers.Count > 0)
{
MetadataRetriever retriever = this.resolveCallState.StackedRetrievers.Pop();
if (resolveCallState.HasBeenUsed(retriever))
{
doneResolving = this.ResolveNext();
}
else
{
if (resolveCallState.ResolvedMaxResolvedReferences)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxResolvedMaxResolvedReferences)));
}
else
{
resolveCallState.LogUse(retriever);
IAsyncResult result = retriever.BeginRetrieve(this.resolveCallState.TimeoutHelper, Fx.ThunkCallback(new AsyncCallback(this.RetrieveCallback)), retriever);
if (result.CompletedSynchronously)
{
doneResolving = HandleResult(result);
}
}
}
}
else
{
doneResolving = true;
}
return doneResolving;
}
internal static MetadataSet End(IAsyncResult result)
{
AsyncMetadataResolver resolverResult = AsyncResult.End<AsyncMetadataResolver>(result);
return resolverResult.resolveCallState.MetadataSet;
}
internal void RetrieveCallback(IAsyncResult result)
{
if (result.CompletedSynchronously)
return;
Exception exception = null;
bool doneResolving = false;
try
{
doneResolving = HandleResult(result);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception e)
{
if (Fx.IsFatal(e))
throw;
exception = e;
doneResolving = true;
}
if (doneResolving)
{
this.Complete(false, exception);
}
}
bool HandleResult(IAsyncResult result)
{
MetadataRetriever retriever = (MetadataRetriever)result.AsyncState;
MetadataSection section = retriever.EndRetrieve(result);
this.resolveCallState.HandleSection(section);
return this.ResolveNext();
}
}
internal class EncodingHelper
{
internal const string ApplicationBase = "application";
internal static Encoding GetRfcEncoding(string contentTypeStr)
{
Encoding e = null;
ContentType contentType = null;
try
{
contentType = new ContentType(contentTypeStr);
string charset = contentType == null ? string.Empty : contentType.CharSet;
if (charset != null && charset.Length > 0)
e = Encoding.GetEncoding(charset);
}
#pragma warning suppress 56500 // covered by FxCOP
catch (Exception ex)
{
if (Fx.IsFatal(ex))
throw;
}
// default to ASCII encoding per RFC 2376/3023
if (IsApplication(contentType))
return e == null ? new ASCIIEncoding() : e;
else
return e;
}
internal static bool IsApplication(ContentType contentType)
{
return string.Compare(contentType == null ? string.Empty : contentType.MediaType,
ApplicationBase, StringComparison.OrdinalIgnoreCase) == 0;
}
internal static Encoding GetDictionaryReaderEncoding(string contentTypeStr)
{
if (String.IsNullOrEmpty(contentTypeStr))
return TextEncoderDefaults.Encoding;
Encoding encoding = GetRfcEncoding(contentTypeStr);
if (encoding == null)
return TextEncoderDefaults.Encoding;
string charSet = encoding.WebName;
Encoding[] supportedEncodings = TextEncoderDefaults.SupportedEncodings;
for (int i = 0; i < supportedEncodings.Length; i++)
{
if (charSet == supportedEncodings[i].WebName)
return encoding;
}
return TextEncoderDefaults.Encoding;
}
}
}
public enum MetadataExchangeClientMode
{
MetadataExchange,
HttpGet,
}
static class MetadataExchangeClientModeHelper
{
static public bool IsDefined(MetadataExchangeClientMode x)
{
return
x == MetadataExchangeClientMode.MetadataExchange ||
x == MetadataExchangeClientMode.HttpGet ||
false;
}
public static void Validate(MetadataExchangeClientMode value)
{
if (!IsDefined(value))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidEnumArgumentException("value", (int)value,
typeof(MetadataExchangeClientMode)));
}
}
}
}