private void CreateAccessor()
{
var nodeConfiguration = new NodeConfiguration();
var configuration = DomainConfigurationFactory.Create();
var descriptor = ProviderDescriptor.Get(configuration.ConnectionInfo.Provider);
var driverFactory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory);
var storageDriver = StorageDriver.Create(driverFactory, configuration);
var nameBuilder = new NameBuilder(configuration, storageDriver.ProviderInfo);
var handlerFactory = (HandlerFactory)Activator.CreateInstance(descriptor.HandlerFactory);
var accessor = new UpgradeServiceAccessor {
Configuration = configuration,
StorageDriver = storageDriver,
NameBuilder = nameBuilder,
HandlerFactory = handlerFactory
};
configuration.Lock();
var connection = storageDriver.CreateConnection(null);
connection.Open();
accessor.MappingResolver = MappingResolver.Create(configuration, nodeConfiguration, storageDriver.GetDefaultSchema(connection));
if (storageDriver.ProviderInfo.Supports(ProviderFeatures.SingleConnection))
{
accessor.RegisterTemporaryResource(connection);
}
else
{
accessor.RegisterResource(connection);
}
accessor.Connection = connection;
accessor.Connection.Extensions.AddOne(new TypeDelegator(typeof(IProviderExecutor)));
this.accessor = accessor;
}
internal NodeExtractedModelBuilder(UpgradeServiceAccessor services, StorageNode defaultNode, NodeConfiguration buildingNodeConfiguration, bool defaultNodeIsUnreadable)
{
ArgumentValidator.EnsureArgumentNotNull(services, "services");
ArgumentValidator.EnsureArgumentNotNull(defaultNode, "defaultNode");
ArgumentValidator.EnsureArgumentNotNull(buildingNodeConfiguration, "buildingNodeConfiguration");
mappingResolver = services.MappingResolver;
this.buildingNodeConfiguration = buildingNodeConfiguration;
defaultStorageNode = defaultNode;
buildAsCopy = !defaultNodeIsUnreadable;
}
private static void BuildUpgradeHandlers(UpgradeServiceAccessor serviceAccessor, IServiceContainer serviceContainer)
{
// Getting user handlers
var userHandlers =
from handler in serviceContainer.GetAll <IUpgradeHandler>()
let assembly = handler.Assembly ?? handler.GetType().Assembly
where handler.IsEnabled
group handler by assembly;
// Adding user handlers
var handlers = new Dictionary <Assembly, IUpgradeHandler>();
foreach (var group in userHandlers)
{
var candidates = group.ToList();
if (candidates.Count > 1)
{
throw new DomainBuilderException(
string.Format(Strings.ExMoreThanOneEnabledXIsProvidedForAssemblyY, typeof(IUpgradeHandler).GetShortName(), @group.Key));
}
handlers.Add(group.Key, candidates[0]);
}
// Adding default handlers
var assembliesWithUserHandlers = handlers.Select(pair => pair.Key);
var assembliesWithoutUserHandler =
serviceAccessor.Configuration.Types.PersistentTypes
.Select(type => type.Assembly)
.Distinct()
.Except(assembliesWithUserHandlers);
foreach (var assembly in assembliesWithoutUserHandler)
{
var handler = new UpgradeHandler(assembly);
handlers.Add(assembly, handler);
}
// Building a list of handlers sorted by dependencies of their assemblies
var dependencies = handlers.Keys.ToDictionary(
assembly => assembly,
assembly => new HashSet <string>(assembly.GetReferencedAssemblies().Select(assemblyName => assemblyName.ToString())));
var sortedHandlers = handlers
.SortTopologically((a0, a1) => dependencies[a1.Key].Contains(a0.Key.GetName().ToString()))
.Select(pair => pair.Value);
// Storing the result
serviceAccessor.UpgradeHandlers =
new ReadOnlyDictionary <Assembly, IUpgradeHandler>(handlers);
serviceAccessor.OrderedUpgradeHandlers =
new ReadOnlyList <IUpgradeHandler>(sortedHandlers.ToList());
}
internal DomainExtractedModelBuilder(UpgradeServiceAccessor services, StorageModel model, bool makeSharedFinally)
{
ArgumentValidator.EnsureArgumentNotNull(services, "services");
ArgumentValidator.EnsureArgumentNotNull(model, "model");
this.model = model;
this.mappingResolver = services.MappingResolver;
this.provider = services.ProviderInfo;
this.driver = services.StorageDriver;
this.makeSharedFinally = makeSharedFinally;
this.targetResult = new SchemaExtractionResult();
if (provider.Supports(ProviderFeatures.Collations))
{
var collation = services.Configuration.Collation;
if (!string.IsNullOrEmpty(collation))
{
collationName = collation;
}
}
}
private void BuildExternalServices(UpgradeServiceAccessor serviceAccessor, UpgradeContext context)
{
var configuration = context.Configuration;
var standardRegistrations = new[] {
new ServiceRegistration(typeof(DomainConfiguration), context.Configuration),
new ServiceRegistration(typeof(UpgradeContext), context)
};
var modules = configuration.Types.Modules
.Select(type => new ServiceRegistration(typeof(IModule), type, false));
var handlers = configuration.Types.UpgradeHandlers
.Select(type => new ServiceRegistration(typeof(IUpgradeHandler), type, false));
var registrations = standardRegistrations.Concat(modules).Concat(handlers);
var serviceContainer = new ServiceContainer(registrations);
serviceAccessor.RegisterResource(serviceContainer);
BuildModules(serviceAccessor, serviceContainer);
BuildUpgradeHandlers(serviceAccessor, serviceContainer);
}
private static void BuildModules(UpgradeServiceAccessor serviceAccessor, IServiceContainer serviceContainer) => serviceAccessor.Modules = new ReadOnlyList <IModule>(serviceContainer.GetAll <IModule>().ToList());
