Files
mono/mcs/class/referencesource/System.Web.Extensions/Compilation/WCFModel/MetadataFile.cs
T
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

885 lines
27 KiB
C#

#region Copyright (c) Microsoft Corporation
/// <copyright company='Microsoft Corporation'>
/// Copyright (c) Microsoft Corporation. All Rights Reserved.
/// Information Contained Herein is Proprietary and Confidential.
/// </copyright>
#endregion
using System;
using System.Diagnostics;
using System.IO;
using System.Xml;
using System.Xml.Schema;
using Discovery = System.Web.Services.Discovery;
using Description = System.Web.Services.Description;
using MetadataSection = System.ServiceModel.Description.MetadataSection;
using XmlSerialization = System.Xml.Serialization;
#if WEB_EXTENSIONS_CODE
using System.Web.Resources;
#else
using Microsoft.VSDesigner.WCF.Resources;
#endif
#if WEB_EXTENSIONS_CODE
namespace System.Web.Compilation.WCFModel
#else
namespace Microsoft.VSDesigner.WCFModel
#endif
{
/// <summary>
/// This class presents a single metadata file in the ReferenceGroup
/// </summary>
/// <remarks></remarks>
#if WEB_EXTENSIONS_CODE
internal class MetadataFile : ExternalFile
#else
[CLSCompliant(true)]
public class MetadataFile : ExternalFile
#endif
{
// Default File Name
public const string DEFAULT_FILE_NAME = "service";
private MetadataType m_MetadataType;
private string m_SourceUrl;
// A GUID string
private string m_ID;
private int m_SourceId;
// properties to merge metadata
private bool m_Ignore;
private bool m_IsMergeResult;
private int SOURCE_ID_NOT_SPECIFIED = 0;
private MetadataContent m_CachedMetadata;
// Content of the metadata file, one of them must be
private byte[] m_BinaryContent;
/// <summary>
/// Constructor
/// </summary>
/// <remarks> Must support a default construct for XmlSerializer</remarks>
public MetadataFile()
{
m_ID = Guid.NewGuid().ToString();
m_BinaryContent = new byte[] { };
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="Name">File Name</param>
/// <param name="Url">SourceUrl</param>
/// <param name="Content">File Content</param>
/// <remarks></remarks>
public MetadataFile(string name, string url, string content)
: base(name)
{
m_ID = Guid.NewGuid().ToString();
m_SourceUrl = url;
if (content == null)
{
throw new ArgumentNullException("content");
}
LoadContent(content);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="Name">File Name</param>
/// <param name="Url">SourceUrl</param>
/// <param name="byteContent">File Content</param>
/// <remarks></remarks>
public MetadataFile(string name, string url, byte[] byteContent)
: base(name)
{
m_ID = Guid.NewGuid().ToString();
m_SourceUrl = url;
if (byteContent == null)
{
throw new ArgumentNullException("byteContent");
}
LoadContent(byteContent);
}
/// <summary>
/// Retrieves the file content in binary format
/// </summary>
/// <value></value>
/// <remarks></remarks>
public byte[] BinaryContent
{
get
{
return m_BinaryContent;
}
}
/// <summary>
/// Cached state
/// </summary>
/// <value></value>
/// <remarks></remarks>
private MetadataContent CachedMetadata
{
get
{
if (m_CachedMetadata == null)
{
m_CachedMetadata = LoadMetadataContent(m_MetadataType);
}
return m_CachedMetadata;
}
}
/// <summary>
/// Retrieves the file content
/// </summary>
/// <value></value>
/// <remarks></remarks>
public string Content
{
get
{
StreamReader memReader = new StreamReader(new MemoryStream(m_BinaryContent));
return memReader.ReadToEnd();
}
}
/// <summary>
/// The Type of Metadata
/// </summary>
/// <value></value>
/// <remarks></remarks>
[XmlSerialization.XmlAttribute("MetadataType")]
public MetadataType FileType
{
get
{
return m_MetadataType;
}
set
{
m_MetadataType = value;
}
}
/// <summary>
/// GUID string, it is used to track a metadata item (when it is updated)
/// </summary>
/// <value></value>
/// <remarks></remarks>
[XmlSerialization.XmlAttribute()]
public string ID
{
get
{
return m_ID;
}
set
{
m_ID = value;
}
}
/// <summary>
/// If it is true, the metadata file will be ignored by the code generator
/// </summary>
/// <value></value>
/// <remarks></remarks>
[XmlSerialization.XmlAttribute()]
public bool Ignore
{
get
{
return m_Ignore;
}
set
{
m_Ignore = value;
}
}
/// <summary>
/// A special attribute used by XmlSerializer to decide whether Ignore attribute exists
/// </summary>
/// <value></value>
/// <remarks></remarks>
[XmlSerialization.XmlIgnore()]
public bool IgnoreSpecified
{
get
{
return m_Ignore;
}
set
{
if (!value)
{
m_Ignore = false;
}
}
}
/// <summary>
/// whether the metadata file is a result of merging
/// </summary>
/// <value></value>
/// <remarks></remarks>
[XmlSerialization.XmlAttribute()]
public bool IsMergeResult
{
get
{
return m_IsMergeResult;
}
set
{
m_IsMergeResult = value;
}
}
/// <summary>
/// A special attribute used by XmlSerializer to decide whether IsMergeResult attribute exists
/// </summary>
/// <value></value>
/// <remarks></remarks>
[XmlSerialization.XmlIgnore()]
public bool IsMergeResultSpecified
{
get
{
return m_IsMergeResult;
}
set
{
if (!value)
{
m_IsMergeResult = false;
}
}
}
/// <summary>
/// Retrieves the content of a discovery file
/// </summary>
/// <value></value>
/// <remarks></remarks>
public Discovery.DiscoveryDocument MetadataDiscoveryDocument
{
get
{
return CachedMetadata.MetadataDiscoveryDocument;
}
}
/// <summary>
/// format error
/// </summary>
/// <value></value>
/// <remarks></remarks>
[XmlSerialization.XmlIgnore()]
public Exception MetadataFormatError
{
get
{
return CachedMetadata.MetadataFormatError;
}
}
/// <summary>
/// Retrieves the content of a WSDL file
/// </summary>
/// <value></value>
/// <remarks></remarks>
public Description.ServiceDescription MetadataServiceDescription
{
get
{
return CachedMetadata.MetadataServiceDescription;
}
}
/// <summary>
/// Retrieves the content of a schema file
/// </summary>
/// <value></value>
/// <remarks></remarks>
public XmlSchema MetadataXmlSchema
{
get
{
return CachedMetadata.MetadataXmlSchema;
}
}
/// <summary>
/// Retrieves the content of an Xml file
/// </summary>
/// <value></value>
/// <remarks></remarks>
public XmlDocument MetadataXmlDocument
{
get
{
return CachedMetadata.MetadataXmlDocument;
}
}
/// <summary>
/// the SourceId links the the SourceId in the MetadataSource table
/// </summary>
/// <value></value>
/// <remarks></remarks>
[XmlSerialization.XmlAttribute()]
public int SourceId
{
get
{
return m_SourceId;
}
set
{
if (value < 0)
{
Debug.Fail("Source ID shouldn't be a nagtive number");
throw new ArgumentException(WCFModelStrings.ReferenceGroup_InvalidSourceId);
}
m_SourceId = value;
}
}
/// <summary>
/// A special attribute used by XmlSerializer to decide whether SourceId attribute exists
/// </summary>
/// <value></value>
/// <remarks></remarks>
[XmlSerialization.XmlIgnore()]
public bool SourceIdSpecified
{
get
{
return m_SourceId != SOURCE_ID_NOT_SPECIFIED;
}
set
{
if (!value)
{
m_SourceId = SOURCE_ID_NOT_SPECIFIED;
}
}
}
/// <summary>
/// The sourceUrl of the metadata file
/// </summary>
/// <value></value>
/// <remarks></remarks>
[XmlSerialization.XmlAttribute()]
public string SourceUrl
{
get
{
return m_SourceUrl;
}
set
{
m_SourceUrl = value;
}
}
/// <summary>
/// Retrieves the TargetNamespace when it is a schema item or a WSDL item
/// </summary>
/// <value></value>
/// <remarks></remarks>
public string TargetNamespace
{
get
{
return CachedMetadata.TargetNamespace;
}
}
/// <summary>
/// Detemine the type of a metadata item
/// </summary>
/// <param name="reader"></param>
/// <returns>File Type</returns>
/// <remarks></remarks>
private MetadataType DetermineFileType(XmlReader reader)
{
try
{
if (reader.IsStartElement(XmlStrings.WSDL.Elements.Root, XmlStrings.WSDL.NamespaceUri))
{
return MetadataType.Wsdl;
}
else if (reader.IsStartElement(XmlStrings.XmlSchema.Elements.Root, XmlStrings.XmlSchema.NamespaceUri))
{
return MetadataType.Schema;
}
else if (reader.IsStartElement(XmlStrings.WSPolicy.Elements.Policy, XmlStrings.WSPolicy.NamespaceUri)
|| reader.IsStartElement(XmlStrings.WSPolicy.Elements.Policy, XmlStrings.WSPolicy.NamespaceUri15))
{
return MetadataType.Policy;
}
else if (reader.IsStartElement(XmlStrings.DISCO.Elements.Root, XmlStrings.DISCO.NamespaceUri))
{
return MetadataType.Disco;
}
else if (reader.IsStartElement(XmlStrings.DataServices.Elements.Root, XmlStrings.DataServices.NamespaceUri))
{
return MetadataType.Edmx;
}
else
{
return MetadataType.Xml;
}
}
catch (XmlException)
{
// This must mean that the document isn't an XML Document so we continue trying other things...
return MetadataType.Unknown;
}
}
/// <summary>
/// return the default extension
/// </summary>
/// <return></return>
/// <remarks></remarks>
public string GetDefaultExtension()
{
switch (m_MetadataType)
{
case MetadataType.Disco:
return "disco";
case MetadataType.Wsdl:
return "wsdl";
case MetadataType.Schema:
return "xsd";
case MetadataType.Xml:
return "xml";
case MetadataType.Policy:
return "xml";
case MetadataType.Edmx:
return "edmx";
default:
return "data";
}
}
/// <summary>
/// return the default filename without extension
/// </summary>
/// <return></return>
/// <remarks></remarks>
public string GetDefaultFileName()
{
if (!String.IsNullOrEmpty(TargetNamespace))
{
string ns = TargetNamespace;
if (!ns.EndsWith("/", StringComparison.Ordinal))
{
int i = ns.LastIndexOfAny(Path.GetInvalidFileNameChars());
if (i >= 0)
{
ns = ns.Substring(i + 1);
}
string defaultExtension = "." + GetDefaultExtension();
if (ns.Length > defaultExtension.Length && ns.EndsWith(defaultExtension, StringComparison.OrdinalIgnoreCase))
{
ns = ns.Substring(0, ns.Length - defaultExtension.Length);
}
if (ns.Length > 0)
{
return ns;
}
}
}
return DEFAULT_FILE_NAME;
}
/// <summary>
/// Load the content of a Metadata item into the object model
/// </summary>
/// <param name="byteContent"></param>
/// <remarks></remarks>
internal void LoadContent(byte[] byteContent)
{
m_BinaryContent = byteContent;
LoadContentFromTextReader(new StreamReader(new MemoryStream(byteContent)));
}
/// <summary>
/// Load the content of a Metadata item into the object model
/// </summary>
/// <param name="content"></param>
/// <remarks></remarks>
internal void LoadContent(string content)
{
MemoryStream memStream = new MemoryStream();
StreamWriter contentWriter = new StreamWriter(memStream);
contentWriter.Write(content);
contentWriter.Flush();
m_BinaryContent = memStream.ToArray();
LoadContentFromTextReader(new StringReader(content));
}
/// <summary>
/// Load the content of a Metadata item into the object model
/// </summary>
/// <param name="contentReader"></param>
/// <remarks></remarks>
private void LoadContentFromTextReader(TextReader contentReader)
{
if (contentReader == null)
{
throw new ArgumentNullException("contentReader");
}
// reset...
ErrorInLoading = null;
m_CachedMetadata = null;
using (XmlTextReader xmlReader = new XmlTextReader(contentReader))
{
if (m_MetadataType == MetadataType.Unknown)
{
// If we don't know the metedata type, we try to sniff it...
MetadataType fileType = DetermineFileType(xmlReader);
// try
m_CachedMetadata = LoadMetadataContent(fileType, xmlReader);
if (m_CachedMetadata.MetadataFormatError == null)
{
m_MetadataType = fileType;
}
}
}
}
/// <summary>
/// the function is called when the metadata is removed, and we need clean up the content
/// </summary>
/// <remarks></remarks>
internal void CleanUpContent()
{
ErrorInLoading = null;
m_BinaryContent = new byte[] { };
m_CachedMetadata = null;
}
/// <summary>
/// Load schema/wsdl model from binary content. -- Parse the metadata content
/// </summary>
/// <return></return>
/// <remarks></remarks>
private MetadataContent LoadMetadataContent(MetadataType fileType)
{
if (ErrorInLoading != null)
{
return new MetadataContent(ErrorInLoading);
}
using (XmlTextReader xmlReader = new XmlTextReader(new StreamReader(new MemoryStream(m_BinaryContent))))
{
return LoadMetadataContent(fileType, xmlReader);
}
}
/// <summary>
/// Load schema/wsdl model from text reader. -- it will parse the metadata content.
/// </summary>
/// <return></return>
/// <remarks></remarks>
private MetadataContent LoadMetadataContent(MetadataType fileType, XmlTextReader xmlReader)
{
MetadataContent cachedMetadata = new MetadataContent();
try
{
switch (fileType)
{
case MetadataType.Disco:
cachedMetadata = new MetadataContent(Discovery.DiscoveryDocument.Read(xmlReader));
break;
case MetadataType.Wsdl:
cachedMetadata = new MetadataContent(Description.ServiceDescription.Read(xmlReader));
cachedMetadata.MetadataServiceDescription.RetrievalUrl = GetMetadataSourceUrl();
break;
case MetadataType.Schema:
cachedMetadata = new MetadataContent(XmlSchema.Read(xmlReader, null));
cachedMetadata.MetadataXmlSchema.SourceUri = GetMetadataSourceUrl();
break;
case MetadataType.Unknown:
// For unknown types, we don't do nothing...
break;
default:
Debug.Assert(fileType == MetadataType.Xml || fileType == MetadataType.Policy || fileType == MetadataType.Edmx);
XmlDocument tempDoc = new XmlDocument();
tempDoc.Load(xmlReader);
cachedMetadata = new MetadataContent(tempDoc);
break;
}
}
catch (Exception ex)
{
cachedMetadata = new MetadataContent(ex);
}
return cachedMetadata;
}
/// <summary>
/// convert metadata file to MetadataSection (to feed code/proxy generator)
/// We don't reuse the buffered object model, because the generator could modify & corrupt them.
/// </summary>
/// <remarks></remarks>
internal MetadataSection CreateMetadataSection()
{
MetadataContent metadata = LoadMetadataContent(m_MetadataType);
if (metadata.MetadataFormatError != null)
{
throw metadata.MetadataFormatError;
}
MetadataSection metadataSection = null;
switch (FileType)
{
case MetadataType.Unknown:
break;
case MetadataType.Disco:
if (metadata.MetadataServiceDescription != null)
{
metadataSection = MetadataSection.CreateFromServiceDescription(metadata.MetadataServiceDescription);
}
break;
case MetadataType.Wsdl:
// We need to make a copy of the WSDL object model since the act of importing it actuall
// modifies it, and we don't want the cached instance to be polluted...
System.Web.Services.Description.ServiceDescription description = metadata.MetadataServiceDescription;
if (description != null)
{
metadataSection = MetadataSection.CreateFromServiceDescription(description);
}
break;
case MetadataType.Schema:
if (metadata.MetadataXmlSchema != null)
{
metadataSection = MetadataSection.CreateFromSchema(metadata.MetadataXmlSchema);
}
break;
case MetadataFile.MetadataType.Policy:
if (metadata.MetadataXmlDocument != null)
{
metadataSection = MetadataSection.CreateFromPolicy(metadata.MetadataXmlDocument.DocumentElement, null);
}
break;
case MetadataFile.MetadataType.Xml:
case MetadataFile.MetadataType.Edmx:
if (metadata.MetadataXmlDocument != null)
{
metadataSection = new MetadataSection(null, null, metadata.MetadataXmlDocument.DocumentElement);
}
break;
default:
System.Diagnostics.Debug.Fail("Unknown Type?");
break;
}
return metadataSection;
}
/// <summary>
/// Metadata source Url is used in error messages
/// </summary>
/// <remarks></remarks>
internal string GetMetadataSourceUrl()
{
if (String.IsNullOrEmpty(SourceUrl))
{
return FileName;
}
else
{
return SourceUrl;
}
}
/// <summary>
/// Metadata File Type Enum
/// </summary>
/// <remarks></remarks>
public enum MetadataType
{
[XmlSerialization.XmlEnum(Name = "Unknown")]
Unknown = 0,
[XmlSerialization.XmlEnum(Name = "Disco")]
Disco = 1,
[XmlSerialization.XmlEnum(Name = "Wsdl")]
Wsdl = 2,
[XmlSerialization.XmlEnum(Name = "Schema")]
Schema = 3,
[XmlSerialization.XmlEnum(Name = "Policy")]
Policy = 4,
[XmlSerialization.XmlEnum(Name = "Xml")]
Xml = 5,
[XmlSerialization.XmlEnum(Name = "Edmx")]
Edmx = 6,
}
/// <summary>
/// Metadata contained inside the file. Only one of field is valid, which depends on the MetadataType
/// </summary>
/// <remarks></remarks>
private class MetadataContent
{
private Discovery.DiscoveryDocument m_MetadataDiscoveryDocument;
private Description.ServiceDescription m_MetadataServiceDescription;
private XmlSchema m_MetadataXmlSchema;
private XmlDocument m_MetadataXmlDocument;
private Exception m_MetadataFormatError;
private string m_TargetNamespace;
internal MetadataContent()
{
m_TargetNamespace = String.Empty;
}
internal MetadataContent(Discovery.DiscoveryDocument discoveryDocument)
{
m_MetadataDiscoveryDocument = discoveryDocument;
m_TargetNamespace = String.Empty;
}
internal MetadataContent(Description.ServiceDescription serviceDescription)
{
m_MetadataServiceDescription = serviceDescription;
m_TargetNamespace = serviceDescription.TargetNamespace;
}
internal MetadataContent(XmlSchema schema)
{
m_MetadataXmlSchema = schema;
m_TargetNamespace = schema.TargetNamespace;
}
internal MetadataContent(XmlDocument document)
{
m_MetadataXmlDocument = document;
m_TargetNamespace = String.Empty;
}
internal MetadataContent(Exception metadataFormatError)
{
m_MetadataFormatError = metadataFormatError;
}
/// <summary>
/// Retrieves the content of a discovery file
/// </summary>
/// <value></value>
/// <remarks></remarks>
public Discovery.DiscoveryDocument MetadataDiscoveryDocument
{
get
{
return m_MetadataDiscoveryDocument;
}
}
/// <summary>
/// Error message if
/// </summary>
/// <value></value>
/// <remarks></remarks>
public Exception MetadataFormatError
{
get
{
return m_MetadataFormatError;
}
}
/// <summary>
/// Retrieves the content of a WSDL file
/// </summary>
/// <value></value>
/// <remarks></remarks>
public Description.ServiceDescription MetadataServiceDescription
{
get
{
return m_MetadataServiceDescription;
}
}
/// <summary>
/// Retrieves the content of a schema file
/// </summary>
/// <value></value>
/// <remarks></remarks>
public XmlSchema MetadataXmlSchema
{
get
{
return m_MetadataXmlSchema;
}
}
/// <summary>
/// Retrieves the content of an Xml file
/// </summary>
/// <value></value>
/// <remarks></remarks>
public XmlDocument MetadataXmlDocument
{
get
{
return m_MetadataXmlDocument;
}
}
/// <summary>
/// Retrieves the TargetNamespace when it is a schema item or a WSDL item
/// </summary>
/// <value></value>
/// <remarks></remarks>
public string TargetNamespace
{
get
{
return m_TargetNamespace;
}
}
}
}
}