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

   1 //---------------------------------------------------------------------
   2 // <copyright file="StoreItemCollection.Loader.cs" company="Microsoft">
   3 //      Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 //
   6 // @owner       Microsoft
   7 // @backupOwner Microsoft
   8 //---------------------------------------------------------------------
   9 namespace System.Data.Metadata.Edm
  10 {
  11     using System.Collections.Generic;
  12     using System.Data.Common;
  13     using System.Data.Common.Utils;
  14     using System.Data.Entity;
  15     using System.Data.EntityModel.SchemaObjectModel;
  16     using System.Diagnostics;
  17     using System.Text;
  18     using System.Xml;
  19
  20     public sealed partial class StoreItemCollection
  21     {
  22         private class Loader
  23         {
  24             private string _provider = null;
  25             private string _providerManifestToken = null;
  26             private DbProviderManifest _providerManifest;
  27             private DbProviderFactory _providerFactory;
  28             IList<EdmSchemaError> _errors;
  29             IList<Schema> _schemas;
  30             bool _throwOnError;
  31
  32             public Loader(IEnumerable<XmlReader> xmlReaders, IEnumerable<string> sourceFilePaths, bool throwOnError)
  33             {
  34                 _throwOnError = throwOnError;
  35                 LoadItems(xmlReaders, sourceFilePaths);
  36             }
  37
  38
  39
  40             public IList<EdmSchemaError> Errors
  41             {
  42                 get { return _errors; }
  43             }
  44
  45             public IList<Schema> Schemas
  46             {
  47                 get { return _schemas; }
  48             }
  49
  50             public DbProviderManifest ProviderManifest
  51             {
  52                 get { return _providerManifest; }
  53             }
  54
  55             public DbProviderFactory ProviderFactory
  56             {
  57                 get { return _providerFactory; }
  58             }
  59
  60             public string ProviderManifestToken
  61             {
  62                 get { return _providerManifestToken; }
  63             }
  64
  65             public bool HasNonWarningErrors
  66             {
  67                 get
  68                 {
  69                     return !MetadataHelper.CheckIfAllErrorsAreWarnings(_errors);
  70                 }
  71             }
  72
  73             private void LoadItems(IEnumerable<XmlReader> xmlReaders, IEnumerable<string> sourceFilePaths)
  74             {
  75
  76                 Debug.Assert(_errors == null, "we are expecting this to be the location that sets _errors for the first time");
  77                 _errors = SchemaManager.ParseAndValidate(xmlReaders,
  78                                                         sourceFilePaths,
  79                                                         SchemaDataModelOption.ProviderDataModel,
  80                                                         OnProviderNotification,
  81                                                         OnProviderManifestTokenNotification,
  82                                                         OnProviderManifestNeeded,
  83                                                         out _schemas
  84                                                         );
  85                 if (_throwOnError)
  86                 {
  87                     ThrowOnNonWarningErrors();
  88                 }
  89             }
  90
  91             internal void ThrowOnNonWarningErrors()
  92             {
  93                 if (!MetadataHelper.CheckIfAllErrorsAreWarnings(_errors))
  94                 {
  95                     //Future Enhancement: if there is an error, we throw exception with error and warnings.
  96                     //Otherwise the user has no clue to know about warnings.
  97                     throw EntityUtil.InvalidSchemaEncountered(Helper.CombineErrorMessage(_errors));
  98                 }
  99             }
 100
 101             private void OnProviderNotification(string provider, Action<string, ErrorCode, EdmSchemaErrorSeverity> addError)
 102             {
 103                 string expected = _provider;
 104                 if (_provider == null)
 105                 {
 106                     // Even if the Provider is only now being discovered from the first SSDL file,
 107                     // it must still match the 'implicit' provider that is implied by the DbConnection
 108                     // or DbProviderFactory that was used to construct this StoreItemCollection.
 109                     _provider = provider;
 110                     InitializeProviderManifest(addError);
 111                     return;
 112                 }
 113                 else
 114                 {
 115                     // The provider was previously discovered from a preceeding SSDL file; it is an error
 116                     // if the 'Provider' attributes in all SSDL files are not identical.
 117                     if (_provider == provider)
 118                     {
 119                         return;
 120                     }
 121                 }
 122
 123                 Debug.Assert(expected != null, "Expected provider name not initialized from _provider or _providerFactory?");
 124
 125                 addError(Strings.AllArtifactsMustTargetSameProvider_InvariantName(expected, _provider),
 126                                                ErrorCode.InconsistentProvider,
 127                                                EdmSchemaErrorSeverity.Error);
 128             }
 129
 130             private void InitializeProviderManifest(Action<string, ErrorCode, EdmSchemaErrorSeverity> addError)
 131             {
 132
 133                 if (_providerManifest == null && (_providerManifestToken != null && _provider != null))
 134                 {
 135                     DbProviderFactory factory = null;
 136                     try
 137                     {
 138                         factory = DbProviderServices.GetProviderFactory(_provider);
 139                     }
 140                     catch (ArgumentException e)
 141                     {
 142                         addError(e.Message, ErrorCode.InvalidProvider, EdmSchemaErrorSeverity.Error);
 143                         return;
 144                     }
 145
 146                     try
 147                     {
 148                         DbProviderServices services = DbProviderServices.GetProviderServices(factory);
 149                         _providerManifest = services.GetProviderManifest(_providerManifestToken);
 150                         _providerFactory = factory;
 151                         if (_providerManifest is EdmProviderManifest)
 152                         {
 153                             if (_throwOnError)
 154                             {
 155                                 throw EntityUtil.NotSupported(Strings.OnlyStoreConnectionsSupported);
 156                             }
 157                             else
 158                             {
 159                                 addError(Strings.OnlyStoreConnectionsSupported, ErrorCode.InvalidProvider, EdmSchemaErrorSeverity.Error);
 160                             }
 161                             return;
 162                         }
 163                     }
 164                     catch (ProviderIncompatibleException e)
 165                     {
 166                         if (_throwOnError)
 167                         {
 168                             // we want to surface these as ProviderIncompatibleExceptions if we are "allowed" to.
 169                             throw;
 170                         }
 171
 172                         AddProviderIncompatibleError(e, addError);
 173                     }
 174                 }
 175             }
 176
 177             private void OnProviderManifestTokenNotification(string token, Action<string, ErrorCode, EdmSchemaErrorSeverity> addError)
 178             {
 179                 if (_providerManifestToken == null)
 180                 {
 181                     _providerManifestToken = token;
 182                     InitializeProviderManifest(addError);
 183                     return;
 184                 }
 185
 186                 if (_providerManifestToken != token)
 187                 {
 188                     addError(Strings.AllArtifactsMustTargetSameProvider_ManifestToken(token, _providerManifestToken),
 189                                                    ErrorCode.ProviderManifestTokenMismatch,
 190                                                    EdmSchemaErrorSeverity.Error);
 191                 }
 192             }
 193
 194             private DbProviderManifest OnProviderManifestNeeded(Action<string, ErrorCode, EdmSchemaErrorSeverity> addError)
 195             {
 196                 if (_providerManifest == null)
 197                 {
 198                     addError(Strings.ProviderManifestTokenNotFound,
 199                                        ErrorCode.ProviderManifestTokenNotFound,
 200                                        EdmSchemaErrorSeverity.Error);
 201                 }
 202                 return _providerManifest;
 203             }
 204
 205             private void AddProviderIncompatibleError(ProviderIncompatibleException provEx, Action<string, ErrorCode, EdmSchemaErrorSeverity> addError)
 206             {
 207                 Debug.Assert(provEx != null);
 208                 Debug.Assert(addError != null);
 209
 210                 StringBuilder message = new StringBuilder(provEx.Message);
 211                 if (provEx.InnerException != null && !string.IsNullOrEmpty(provEx.InnerException.Message))
 212                 {
 213                     message.AppendFormat(" {0}", provEx.InnerException.Message);
 214                 }
 215
 216                 addError(message.ToString(),
 217                                    ErrorCode.FailedToRetrieveProviderManifest,
 218                                    EdmSchemaErrorSeverity.Error);
 219             }
 220         }
 221     }
 222 }