Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Data.Entity/System/Data/Metadata/StoreItemCollection.Loader.cs

@@ -0,0 +1,222 @@
+//---------------------------------------------------------------------
+// <copyright file="StoreItemCollection.Loader.cs" company="Microsoft">
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//
+// @owner       [....]
+// @backupOwner [....]
+//---------------------------------------------------------------------
+namespace System.Data.Metadata.Edm
+{
+    using System.Collections.Generic;
+    using System.Data.Common;
+    using System.Data.Common.Utils;
+    using System.Data.Entity;
+    using System.Data.EntityModel.SchemaObjectModel;
+    using System.Diagnostics;
+    using System.Text;
+    using System.Xml;
+
+    public sealed partial class StoreItemCollection
+    {
+        private class Loader
+        {
+            private string _provider = null;
+            private string _providerManifestToken = null;
+            private DbProviderManifest _providerManifest;
+            private DbProviderFactory _providerFactory;
+            IList<EdmSchemaError> _errors;
+            IList<Schema> _schemas;
+            bool _throwOnError;
+
+            public Loader(IEnumerable<XmlReader> xmlReaders, IEnumerable<string> sourceFilePaths, bool throwOnError)
+            {
+                _throwOnError = throwOnError;
+                LoadItems(xmlReaders, sourceFilePaths);
+            }
+
+
+
+            public IList<EdmSchemaError> Errors
+            {
+                get { return _errors; }
+            }
+
+            public IList<Schema> Schemas
+            {
+                get { return _schemas; }
+            }
+
+            public DbProviderManifest ProviderManifest
+            {
+                get { return _providerManifest; }
+            }
+            
+            public DbProviderFactory ProviderFactory
+            {
+                get { return _providerFactory; }
+            }
+
+            public string ProviderManifestToken
+            {
+                get { return _providerManifestToken; }
+            }
+
+            public bool HasNonWarningErrors
+            {
+                get
+                {
+                    return !MetadataHelper.CheckIfAllErrorsAreWarnings(_errors);
+                }
+            }
+            
+            private void LoadItems(IEnumerable<XmlReader> xmlReaders, IEnumerable<string> sourceFilePaths)
+            {
+
+                Debug.Assert(_errors == null, "we are expecting this to be the location that sets _errors for the first time");
+                _errors = SchemaManager.ParseAndValidate(xmlReaders,
+                                                        sourceFilePaths,
+                                                        SchemaDataModelOption.ProviderDataModel,
+                                                        OnProviderNotification,
+                                                        OnProviderManifestTokenNotification,
+                                                        OnProviderManifestNeeded,
+                                                        out _schemas
+                                                        );
+                if (_throwOnError)
+                {
+                    ThrowOnNonWarningErrors();
+                }
+            }
+
+            internal void ThrowOnNonWarningErrors()
+            {
+                if (!MetadataHelper.CheckIfAllErrorsAreWarnings(_errors))
+                {
+                    //Future Enhancement: if there is an error, we throw exception with error and warnings.
+                    //Otherwise the user has no clue to know about warnings.
+                    throw EntityUtil.InvalidSchemaEncountered(Helper.CombineErrorMessage(_errors));
+                }
+            }
+
+            private void OnProviderNotification(string provider, Action<string, ErrorCode, EdmSchemaErrorSeverity> addError)
+            {
+                string expected = _provider;
+                if (_provider == null)
+                {
+                    // Even if the Provider is only now being discovered from the first SSDL file,
+                    // it must still match the 'implicit' provider that is implied by the DbConnection
+                    // or DbProviderFactory that was used to construct this StoreItemCollection.
+                    _provider = provider;
+                    InitializeProviderManifest(addError);
+                    return;
+                }
+                else
+                {
+                    // The provider was previously discovered from a preceeding SSDL file; it is an error
+                    // if the 'Provider' attributes in all SSDL files are not identical.
+                    if (_provider == provider)
+                    {
+                        return;
+                    }
+                }
+
+                Debug.Assert(expected != null, "Expected provider name not initialized from _provider or _providerFactory?");
+
+                addError(Strings.AllArtifactsMustTargetSameProvider_InvariantName(expected, _provider),
+                                               ErrorCode.InconsistentProvider,
+                                               EdmSchemaErrorSeverity.Error);
+            }
+
+            private void InitializeProviderManifest(Action<string, ErrorCode, EdmSchemaErrorSeverity> addError)
+            {
+
+                if (_providerManifest == null && (_providerManifestToken != null && _provider != null))
+                {
+                    DbProviderFactory factory = null;
+                    try
+                    {
+                        factory = DbProviderServices.GetProviderFactory(_provider);
+                    }
+                    catch (ArgumentException e)
+                    {
+                        addError(e.Message, ErrorCode.InvalidProvider, EdmSchemaErrorSeverity.Error);
+                        return;
+                    }
+
+                    try
+                    {
+                        DbProviderServices services = DbProviderServices.GetProviderServices(factory);
+                        _providerManifest = services.GetProviderManifest(_providerManifestToken);
+                        _providerFactory = factory;
+                        if (_providerManifest is EdmProviderManifest)
+                        {
+                            if (_throwOnError)
+                            {
+                                throw EntityUtil.NotSupported(Strings.OnlyStoreConnectionsSupported);
+                            }
+                            else
+                            {
+                                addError(Strings.OnlyStoreConnectionsSupported, ErrorCode.InvalidProvider, EdmSchemaErrorSeverity.Error);
+                            }
+                            return;
+                        }
+                    }
+                    catch (ProviderIncompatibleException e)
+                    {
+                        if (_throwOnError)
+                        {
+                            // we want to surface these as ProviderIncompatibleExceptions if we are "allowed" to.
+                            throw;
+                        }
+
+                        AddProviderIncompatibleError(e, addError);
+                    }
+                }
+            }
+
+            private void OnProviderManifestTokenNotification(string token, Action<string, ErrorCode, EdmSchemaErrorSeverity> addError)
+            {
+                if (_providerManifestToken == null)
+                {
+                    _providerManifestToken = token;
+                    InitializeProviderManifest(addError);
+                    return;
+                }
+
+                if (_providerManifestToken != token)
+                {
+                    addError(Strings.AllArtifactsMustTargetSameProvider_ManifestToken(token, _providerManifestToken),
+                                                   ErrorCode.ProviderManifestTokenMismatch,
+                                                   EdmSchemaErrorSeverity.Error);
+                }
+            }
+
+            private DbProviderManifest OnProviderManifestNeeded(Action<string, ErrorCode, EdmSchemaErrorSeverity> addError)
+            {
+                if (_providerManifest == null)
+                {
+                    addError(Strings.ProviderManifestTokenNotFound,
+                                       ErrorCode.ProviderManifestTokenNotFound,
+                                       EdmSchemaErrorSeverity.Error);
+                }
+                return _providerManifest;
+            }
+
+            private void AddProviderIncompatibleError(ProviderIncompatibleException provEx, Action<string, ErrorCode, EdmSchemaErrorSeverity> addError)
+            {
+                Debug.Assert(provEx != null);
+                Debug.Assert(addError != null);
+
+                StringBuilder message = new StringBuilder(provEx.Message);
+                if (provEx.InnerException != null && !string.IsNullOrEmpty(provEx.InnerException.Message))
+                {
+                    message.AppendFormat(" {0}", provEx.InnerException.Message);
+                }
+
+                addError(message.ToString(),
+                                   ErrorCode.FailedToRetrieveProviderManifest,
+                                   EdmSchemaErrorSeverity.Error);
+            }
+        }
+    }
+}