/// <include file='doc\DiscoveryReference.uex' path='docs/doc[@for="DiscoveryReference.Resolve"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public void Resolve()
{
if (ClientProtocol == null)
{
throw new InvalidOperationException(Res.GetString(Res.WebResolveMissingClientProtocol));
}
if (ClientProtocol.Documents[Url] != null)
{
return;
}
string newUrl = Url;
string oldUrl = Url;
string contentType = null;
Stream stream = ClientProtocol.Download(ref newUrl, ref contentType);
if (ClientProtocol.Documents[newUrl] != null)
{
Url = newUrl;
return;
}
try {
Url = newUrl;
Resolve(contentType, stream);
}
catch {
Url = oldUrl;
throw;
}
finally {
stream.Close();
}
}
/// <include file='doc\ContractReference.uex' path='docs/doc[@for="ContractReference.Resolve"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected internal override void Resolve(string contentType, Stream stream)
{
if (ContentType.IsHtml(contentType))
{
throw new InvalidContentTypeException(Res.GetString(Res.WebInvalidContentType, contentType), contentType);
}
ServiceDescription serviceDescription = ClientProtocol.Documents[Url] as ServiceDescription;
if (serviceDescription == null)
{
serviceDescription = ServiceDescription.Read(stream, true);
serviceDescription.RetrievalUrl = Url;
ClientProtocol.Documents[Url] = serviceDescription;
}
ClientProtocol.References[Url] = this;
ArrayList importUrls = new ArrayList();
foreach (Import import in serviceDescription.Imports)
{
if (import.Location != null)
{
importUrls.Add(import.Location);
}
}
foreach (XmlSchema schema in serviceDescription.Types.Schemas)
{
foreach (XmlSchemaExternal external in schema.Includes)
{
if (external.SchemaLocation != null && external.SchemaLocation.Length > 0)
{
importUrls.Add(external.SchemaLocation);
}
}
}
foreach (string urlFromImport in importUrls)
{
// make the (possibly) relative Uri in the contract fully qualified with respect to the contract URL
string importUrl = UriToString(Url, urlFromImport);
if (ClientProtocol.Documents[importUrl] != null)
{
continue;
}
string oldUrl = importUrl;
try {
stream = ClientProtocol.Download(ref importUrl, ref contentType);
try {
//Proceed only if not been here before
if (ClientProtocol.Documents[importUrl] == null)
{
XmlTextReader reader = new XmlTextReader(new StreamReader(stream, RequestResponseUtils.GetEncoding(contentType)));
reader.WhitespaceHandling = WhitespaceHandling.Significant;
reader.XmlResolver = null;
reader.DtdProcessing = DtdProcessing.Prohibit;
//Resolve on WSDL and XSD will go recursivelly
if (ServiceDescription.CanRead(reader))
{
ServiceDescription doc = ServiceDescription.Read(reader, true);
doc.RetrievalUrl = importUrl;
ClientProtocol.Documents[importUrl] = doc;
ContractReference contractReference = new ContractReference(importUrl, null);
contractReference.ClientProtocol = ClientProtocol;
try {
contractReference.Resolve(contentType, stream);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
contractReference.Url = oldUrl;
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Warning, this, "Resolve", e);
}
}
}
else if (reader.IsStartElement("schema", XmlSchema.Namespace))
{
ClientProtocol.Documents[importUrl] = XmlSchema.Read(reader, null);
SchemaReference schemaReference = new SchemaReference(importUrl);
schemaReference.ClientProtocol = ClientProtocol;
try {
schemaReference.Resolve(contentType, stream);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
schemaReference.Url = oldUrl;
if (Tracing.On)
{
Tracing.ExceptionCatch(TraceEventType.Warning, this, "Resolve", e);
}
}
}
// If it's not XML, or we don't know what kind of XML it is, skip the file. The user
// will have to download the dependent file(s) manually, but at least we will continue
// to discover files instead of throwing an exception.
}
}
finally {
stream.Close();
}
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
throw new InvalidDocumentContentsException(Res.GetString(Res.TheWSDLDocumentContainsLinksThatCouldNotBeResolved, importUrl), e);
}
}
}
