public MigrationContext(IMigrationConventions conventions, IQuerySchema querySchema, IAssemblyCollection migrationAssemblies)
{
Conventions = conventions;
Expressions = new List <IMigrationExpression>();
QuerySchema = querySchema;
MigrationAssemblies = migrationAssemblies;
}
public MigrationRunner(IAssemblyCollection assemblies, IRunnerContext runnerContext, IMigrationProcessor processor)
{
_migrationAssemblies = assemblies;
_announcer = runnerContext.Announcer;
Processor = processor;
_stopWatch = runnerContext.StopWatch;
ApplicationContext = runnerContext.ApplicationContext;
TransactionPerSession = runnerContext.TransactionPerSession;
SilentlyFail = false;
CaughtExceptions = null;
Conventions = new MigrationConventions();
if (!string.IsNullOrEmpty(runnerContext.WorkingDirectory))
{
Conventions.GetWorkingDirectory = () => runnerContext.WorkingDirectory;
}
_migrationScopeHandler = new MigrationScopeHandler(Processor);
_migrationValidator = new MigrationValidator(_announcer, Conventions);
MigrationLoader = new DefaultMigrationInformationLoader(Conventions, _migrationAssemblies, runnerContext.Namespace, runnerContext.NestedNamespaces, runnerContext.Tags);
ProfileLoader = new ProfileLoader(runnerContext, this, Conventions);
MaintenanceLoader = new MaintenanceLoader(_migrationAssemblies, runnerContext.Tags, Conventions);
if (runnerContext.NoConnection)
{
VersionLoader = new ConnectionlessVersionLoader(this, _migrationAssemblies, Conventions, runnerContext.StartVersion, runnerContext.Version);
}
else
{
VersionLoader = new VersionLoader(this, _migrationAssemblies, Conventions);
}
}
protected override IUnitsModel GetModel()
{
IAssemblyCollection collection = ProfilingViewModel.Application.ServiceContainer.Resolve <IAssemblyCollection>();
AssembliesModel model = new AssembliesModel(collection);
return(model);
}
public MigrationRunner(
[NotNull] IAssemblyCollection assemblies, [NotNull] IRunnerContext runnerContext,
[NotNull] IMigrationProcessor processor, IVersionTableMetaData versionTableMetaData = null,
[CanBeNull] IMigrationRunnerConventions migrationRunnerConventions = null)
: this(assemblies, runnerContext, processor, versionTableMetaData, migrationRunnerConventions, conventionSet : null, migrationScopeHandler : null)
{
}
protected override void Initialize()
{
base.Initialize();
IAssemblyCollection unitCollection = Session.Daemon.Container.Resolve <IAssemblyCollection>();
Model = new UnitCollectionModel <AssemblyInfo>(unitCollection);
}
// ReSharper disable once UnusedMember.Local
public ExecuteEmbeddedAutoSqlScriptExpression(IAssemblyCollection assemblyCollection, Type migrationType, IList <string> databaseNames, MigrationDirection direction)
{
_embeddedResourceProvider = new DefaultEmbeddedResourceProvider(assemblyCollection);
MigrationType = migrationType;
DatabaseNames = databaseNames;
Direction = direction;
}
internal FxVersionLoader(IMigrationRunner runner, IAssemblyCollection assemblies,
IConventionSet conventionSet,
IMigrationRunnerConventions conventions,
IRunnerContext runnerContext,
IVersionTableMetaData versionTableMetaData = null,
string resource = "")
{
_conventionSet = conventionSet;
_processor = runner.Processor;
Runner = runner;
Assemblies = assemblies;
Conventions = conventions;
VersionTableMetaData = versionTableMetaData ?? CreateVersionTableMetaData(runnerContext);
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
VersionResourceMigration = new VersionResourceMigration(VersionTableMetaData);
VersionTableMetaData.ApplicationContext = runnerContext.ApplicationContext;
Resource = resource;
LoadVersionInfo();
}
private void PerstListButton_Click(object sender, EventArgs e)
{
IAssemblyCollection assemblyCollection = this.assemblyManager.Assemblies;
List <IAssembly> assemblies = new List <IAssembly>(assemblyCollection.Count);
foreach (IAssembly assembly in assemblyCollection)
{
assemblies.Add(assembly);
}
messages = new StringBuilder();
ITranslator translator = this.translatorManager.CreateDisassembler(null, null);
foreach (IAssembly assembly in assemblies)
{
if (!assembly.Location.StartsWith("%SystemRoot%") &&
!assembly.Location.StartsWith("%ProgramFiles%"))
{
foreach (IModule module in assembly.Modules)
{
foreach (ITypeDeclaration type in module.Types)
{
if (!type.Namespace.StartsWith("Perst"))
{
processType(type);
}
}
}
}
}
message(messages.Length != 0 ? messages.ToString() : "No bugs detected");
}
public MigrationRunner(
IAssemblyCollection assemblies, IRunnerContext runnerContext,
IMigrationProcessor processor, IVersionTableMetaData versionTableMetaData = null,
IMigrationRunnerConventions migrationRunnerConventions = null)
: this(assemblies, runnerContext, processor, versionTableMetaData, migrationRunnerConventions, conventionSet : null)
{
}
public void Invoke(IPackagesCollection packages, IAssemblyCollection assemblies, IFileSystem fileSystem)
{
var scriptType = Assembly.GetExportedTypes().First(t => t.Name == "SetupScript");
MethodInfo runMethod = scriptType.GetMethod("Run", BindingFlags.Public | BindingFlags.Static);
runMethod.Invoke(null, new object[] { packages, assemblies, fileSystem });
}
public MigrationRunner(IAssemblyCollection assemblies, IRunnerContext runnerContext, IMigrationProcessor processor)
{
_migrationAssemblies = assemblies;
_announcer = runnerContext.Announcer;
Processor = processor;
_stopWatch = runnerContext.StopWatch;
RunnerContext = runnerContext;
SilentlyFail = false;
CaughtExceptions = null;
Conventions = new MigrationConventions();
if (!string.IsNullOrEmpty(runnerContext.WorkingDirectory))
Conventions.GetWorkingDirectory = () => runnerContext.WorkingDirectory;
_migrationScopeHandler = new MigrationScopeHandler(Processor);
_migrationValidator = new MigrationValidator(_announcer, Conventions);
MigrationLoader = new DefaultMigrationInformationLoader(Conventions, _migrationAssemblies, runnerContext.Namespace, runnerContext.NestedNamespaces, runnerContext.Tags);
ProfileLoader = new ProfileLoader(runnerContext, this, Conventions);
MaintenanceLoader = new MaintenanceLoader(_migrationAssemblies, runnerContext.Tags, Conventions);
if (runnerContext.NoConnection){
VersionLoader = new ConnectionlessVersionLoader(this, _migrationAssemblies, Conventions, runnerContext.StartVersion, runnerContext.Version);
}
else{
VersionLoader = new VersionLoader(this, _migrationAssemblies, Conventions);
}
}
internal ConnectionlessVersionLoader(
IMigrationRunner runner,
IAssemblyCollection assemblies,
IConventionSet conventionSet,
IMigrationRunnerConventions conventions,
IRunnerContext runnerContext,
IVersionTableMetaData versionTableMetaData = null)
{
_migrationInformationLoader = runner.MigrationLoader;
_processor = runner.Processor;
Runner = runner;
Assemblies = assemblies;
Conventions = conventions;
StartVersion = runnerContext.StartVersion;
TargetVersion = runnerContext.Version;
VersionInfo = new VersionInfo();
VersionTableMetaData = versionTableMetaData ??
(IVersionTableMetaData)Activator.CreateInstance(assemblies.Assemblies.GetVersionTableMetaDataType(
Conventions, runnerContext));
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
if (VersionTableMetaData is DefaultVersionTableMetaData defaultMetaData)
{
conventionSet.SchemaConvention?.Apply(defaultMetaData);
}
LoadVersionInfo();
}
private IMigrationProcessor InitializeProcessor(IAssemblyCollection assemblyCollection)
#endif
{
if (RunnerContext.Timeout == 0)
{
RunnerContext.Timeout = 30; // Set default timeout for command
}
#if !COREFX
var connectionString = LoadConnectionString(assemblyCollection);
#endif
var processorFactory = ProcessorFactoryProvider.GetFactory(RunnerContext.Database);
if (processorFactory == null)
{
throw new ProcessorFactoryNotFoundException(string.Format("The provider or dbtype parameter is incorrect. Available choices are {0}: ", ProcessorFactoryProvider.ListAvailableProcessorTypes()));
}
var processor = processorFactory.Create(connectionString, RunnerContext.Announcer, new ProcessorOptions
{
PreviewOnly = RunnerContext.PreviewOnly,
Timeout = RunnerContext.Timeout,
ProviderSwitches = RunnerContext.ProviderSwitches
});
return(processor);
}
public MigrationContext(IQuerySchema querySchema, IAssemblyCollection migrationAssemblies, object context, string connection)
{
Expressions = new List <IMigrationExpression>();
QuerySchema = querySchema;
MigrationAssemblies = migrationAssemblies;
this.ApplicationContext = context;
this.Connection = connection;
}
public void SetDependencies(IAssemblyCollection assemblies)
{
_assemblies = assemblies;
foreach (ModuleInfo unit in this)
{
unit.SetDependencies(_assemblies);
}
}
public ExecuteEmbeddedSqlScriptExpression([NotNull] IAssemblyCollection assemblyCollection)
{
MigrationAssemblies = assemblyCollection;
_embeddedResourceProviders = new IEmbeddedResourceProvider[]
{
new DefaultEmbeddedResourceProvider(assemblyCollection),
};
}
public MigrationContext(IMigrationConventions conventions, IQuerySchema querySchema, IAssemblyCollection migrationAssemblies, object context, string connection)
{
Conventions = conventions;
Expressions = new List<IMigrationExpression>();
QuerySchema = querySchema;
MigrationAssemblies = migrationAssemblies;
this.ApplicationContext = context;
this.Connection = connection;
}
public DefaultMigrationInformationLoader(IMigrationConventions conventions, IAssemblyCollection assemblies, string @namespace,
bool loadNestedNamespaces, IEnumerable <string> tagsToMatch)
{
Conventions = conventions;
Assemblies = assemblies;
Namespace = @namespace;
LoadNestedNamespaces = loadNestedNamespaces;
TagsToMatch = tagsToMatch ?? new string[] {};
}
public DefaultMigrationInformationLoader(IMigrationConventions conventions, IAssemblyCollection assemblies, string @namespace,
bool loadNestedNamespaces, IEnumerable<string> tagsToMatch)
{
Conventions = conventions;
Assemblies = assemblies;
Namespace = @namespace;
LoadNestedNamespaces = loadNestedNamespaces;
TagsToMatch = tagsToMatch ?? new string[] {};
}
public AssembliesModel(IAssemblyCollection units)
{
Units = units;
Columns = new List <GridViewDynamicColumn>
{
new GridViewDynamicColumn("Name", "Name", FilterByName),
new GridViewDynamicColumn("AppDomain", "AppDomain.Name", FilterByAppDomain)
};
}
public DefaultMigrationInformationLoader(IMigrationRunnerConventions conventions, IAssemblyCollection assemblies, string @namespace,
bool loadNestedNamespaces, IEnumerable <string> tagsToMatch)
{
Conventions = conventions;
Assemblies = assemblies;
Namespace = @namespace;
LoadNestedNamespaces = loadNestedNamespaces;
_tagsToMatch = tagsToMatch as IReadOnlyCollection <string> ?? tagsToMatch?.ToArray() ?? Array.Empty <string>();
_source = new MigrationSource(new AssemblySource(() => assemblies), conventions);
}
public IEnumerable<IMigration> FindProfilesIn(IAssemblyCollection assemblies, string profile)
{
IEnumerable<Type> matchedTypes = assemblies.GetExportedTypes()
.Where(t => Conventions.TypeIsProfile(t) && t.GetOneAttribute<ProfileAttribute>().ProfileName.ToLower() == profile.ToLower())
.OrderBy(x => x.Name);
foreach (Type type in matchedTypes)
{
yield return type.Assembly.CreateInstance(type.FullName) as IMigration;
}
}
public IEnumerable <IMigration> FindProfilesIn(IAssemblyCollection assemblies, string profile)
{
IEnumerable <Type> matchedTypes = assemblies.GetExportedTypes()
.Where(t => Conventions.TypeIsProfile(t) && t.GetOneAttribute <ProfileAttribute>().ProfileName.ToLower() == profile.ToLower())
.OrderBy(x => x.Name);
foreach (Type type in matchedTypes)
{
yield return(type.Assembly.CreateInstance(type.FullName) as IMigration);
}
}
private string LoadConnectionString(IAssemblyCollection assemblyCollection)
{
var singleAssembly = (assemblyCollection != null && assemblyCollection.Assemblies != null && assemblyCollection.Assemblies.Length == 1) ? assemblyCollection.Assemblies[0] : null;
var singleAssemblyLocation = singleAssembly != null ? singleAssembly.Location : string.Empty;
var manager = new ConnectionStringManager(new NetConfigManager(), RunnerContext.Announcer, RunnerContext.Connection,
RunnerContext.ConnectionStringConfigPath, singleAssemblyLocation,
RunnerContext.Database);
manager.LoadConnectionString();
return(manager.ConnectionString);
}
private string LoadConnectionString(IAssemblyCollection assemblyCollection)
{
var singleAssembly = (assemblyCollection != null && assemblyCollection.Assemblies != null && assemblyCollection.Assemblies.Length == 1) ? assemblyCollection.Assemblies[0] : null;
var singleAssemblyLocation = singleAssembly != null ? singleAssembly.Location : string.Empty;
var connectionString = ConnectionStringProvider.GetConnectionString(
RunnerContext.Announcer,
RunnerContext.Connection,
RunnerContext.ConnectionStringConfigPath,
singleAssemblyLocation,
RunnerContext.Database);
return(connectionString);
}
internal AssemblyLoader(ConfigCompilation compilation, IReadOnlyFileSystem fileSystem, IAssemblyCollection assemblies, INamespacesCollection namespaces)
{
_compilation = compilation;
_fileSystem = fileSystem;
_assemblies = assemblies;
_namespaces = namespaces;
// Add the Core modules
_moduleAssemblies.Add(Assembly.GetAssembly(typeof(Engine)));
// Manually resolve included assemblies
AppDomain.CurrentDomain.AssemblyResolve += OnAssemblyResolve;
AppDomain.CurrentDomain.SetupInformation.PrivateBinPathProbe = string.Empty; // non-null means exclude application base path
}
public VersionLoader(IMigrationRunner runner, IAssemblyCollection assemblies, IMigrationConventions conventions)
{
Runner = runner;
Processor = runner.Processor;
Assemblies = assemblies;
Conventions = conventions;
VersionTableMetaData = GetVersionTableMetaData();
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
LoadVersionInfo();
}
public MigrationContext([NotNull] IQuerySchema querySchema, [NotNull] IAssemblyCollection migrationAssemblies, object context, string connection)
{
// ReSharper disable VirtualMemberCallInConstructor
QuerySchema = querySchema;
MigrationAssemblies = migrationAssemblies;
ApplicationContext = context;
// ReSharper restore VirtualMemberCallInConstructor
Connection = connection;
var services = new ServiceCollection();
services
.AddScoped(sp => migrationAssemblies)
.AddScoped <IEmbeddedResourceProvider, DefaultEmbeddedResourceProvider>();
ServiceProvider = services.BuildServiceProvider();
}
public VersionLoader(IMigrationRunner runner, IAssemblyCollection assemblies, IMigrationConventions conventions)
{
Runner = runner;
Processor = runner.Processor;
Assemblies = assemblies;
Conventions = conventions;
VersionTableMetaData = GetVersionTableMetaData();
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
LoadVersionInfo();
}
public MaintenanceLoader(IAssemblyCollection assemblyCollection, IEnumerable <string> tags, IMigrationConventions conventions)
{
tags = tags ?? new string[] {};
_maintenance = (
from a in assemblyCollection.Assemblies
from type in a.GetExportedTypes()
let stage = conventions.GetMaintenanceStage(type)
where stage != null
where conventions.TypeHasMatchingTags(type, tags)
let migration = (IMigration)Activator.CreateInstance(type)
group migration by stage
).ToDictionary(
g => g.Key.Value,
g => (IList <IMigration>)g.OrderBy(m => m.GetType().Name).ToArray()
);
}
public MaintenanceLoader(IAssemblyCollection assemblyCollection, IEnumerable<string> tags, IMigrationConventions conventions)
{
tags = tags ?? new string[] {};
_maintenance = (
from a in assemblyCollection.Assemblies
from type in a.GetExportedTypes()
let stage = conventions.GetMaintenanceStage(type)
where stage != null
where conventions.TypeHasMatchingTags(type, tags)
let migration = (IMigration)Activator.CreateInstance(type)
group migration by stage
).ToDictionary(
g => g.Key.Value,
g => (IList<IMigration>)g.OrderBy(m => m.GetType().Name).ToArray()
);
}
internal AssemblyLoader(IReadOnlyFileSystem fileSystem, IAssemblyCollection assemblyCollection, AssemblyResolver assemblyResolver)
{
_fileSystem = fileSystem;
_assemblyCollection = assemblyCollection;
_assemblyResolver = assemblyResolver;
// Get the location of the entry assembly
string entryAssemblyLocation = Assembly.GetEntryAssembly()?.Location;
DirectoryPath entryAssemblyPath = entryAssemblyLocation == null
? new DirectoryPath(Environment.CurrentDirectory)
: new FilePath(entryAssemblyLocation).Directory;
_entryAssemblyDirectory = _fileSystem.GetDirectory(entryAssemblyPath);
// Add the Core modules
DirectAssemblies.Add(Assembly.GetAssembly(typeof(Engine)));
}
public MigrationRunner(
[NotNull] IAssemblyCollection assemblies, [NotNull] IRunnerContext runnerContext,
[NotNull] IMigrationProcessor processor, [CanBeNull] IVersionTableMetaData versionTableMetaData,
[CanBeNull] IMigrationRunnerConventions migrationRunnerConventions, [CanBeNull] IConventionSet conventionSet,
[CanBeNull] IMigrationScopeManager migrationScopeHandler = null)
{
_migrationAssemblies = assemblies;
_logger = new AnnouncerFluentMigratorLogger(runnerContext.Announcer);
_stopWatch = runnerContext.StopWatch;
_processorOptions = new ProcessorOptions(runnerContext);
Processor = processor;
RunnerContext = runnerContext;
var migrationRunnerConventionsAccessor = new AssemblySourceMigrationRunnerConventionsAccessor(
serviceProvider: null,
new AssemblySource(() => assemblies));
Conventions = migrationRunnerConventions ?? migrationRunnerConventionsAccessor.MigrationRunnerConventions;
var convSet = conventionSet ?? new DefaultConventionSet(runnerContext);
_migrationScopeManager = migrationScopeHandler ?? new MigrationScopeHandler(Processor);
_migrationValidator = new MigrationValidator(_logger, convSet);
MigrationLoader = new DefaultMigrationInformationLoader(Conventions, _migrationAssemblies,
runnerContext.Namespace,
runnerContext.NestedNamespaces, runnerContext.Tags);
ProfileLoader = new ProfileLoader(runnerContext, this, Conventions);
MaintenanceLoader = new MaintenanceLoader(_migrationAssemblies, runnerContext.Tags, Conventions);
if (runnerContext.NoConnection)
{
_versionLoader = new Lazy <IVersionLoader>(
() => new ConnectionlessVersionLoader(
this,
_migrationAssemblies,
convSet,
Conventions,
runnerContext,
versionTableMetaData));
}
else
{
_versionLoader = new Lazy <IVersionLoader>(
() => new VersionLoader(this, _migrationAssemblies, convSet, Conventions, runnerContext, versionTableMetaData));
}
}
public MaintenanceLoader(IAssemblyCollection assemblyCollection, IEnumerable <string> tags, IMigrationRunnerConventions conventions)
{
var tagsList = tags?.ToArray() ?? new string[0];
_maintenance = (
from a in assemblyCollection.Assemblies
from type in a.GetExportedTypes()
let stage = conventions.GetMaintenanceStage(type)
where stage != null
where conventions.HasRequestedTags(type, tagsList, false)
let migration = (IMigration)Activator.CreateInstance(type)
group migration by stage.GetValueOrDefault()
).ToDictionary(
g => g.Key,
g => (IList <IMigration>)g.OrderBy(m => m.GetType().Name).ToArray()
);
}
internal AssemblyLoader(IReadOnlyFileSystem fileSystem, IAssemblyCollection assemblyCollection, AssemblyResolver assemblyResolver)
{
_fileSystem = fileSystem;
_assemblyCollection = assemblyCollection;
_assemblyResolver = assemblyResolver;
// Get the location of the entry assembly
string entryAssemblyLocation = Assembly.GetEntryAssembly()?.Location;
DirectoryPath entryAssemblyPath = entryAssemblyLocation == null
? new DirectoryPath(Environment.CurrentDirectory)
: new FilePath(entryAssemblyLocation).Directory;
_entryAssemblyDirectory = _fileSystem.GetDirectory(entryAssemblyPath);
// Add the Core modules
DirectAssemblies.Add(Assembly.GetAssembly(typeof(Engine)));
}
public VersionLoader(IMigrationRunner runner, IAssemblyCollection assemblies,
IConventionSet conventionSet,
IMigrationRunnerConventions conventions,
IVersionTableMetaData versionTableMetaData = null)
{
_conventionSet = conventionSet;
Runner = runner;
Processor = runner.Processor;
Assemblies = assemblies;
Conventions = conventions;
VersionTableMetaData = versionTableMetaData ?? GetVersionTableMetaData();
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
LoadVersionInfo();
}
public ConnectionlessVersionLoader(IMigrationRunner runner, IAssemblyCollection assemblies, IMigrationConventions conventions, long startVersion, long targetVersion)
{
Runner = runner;
Assemblies = assemblies;
Conventions = conventions;
StartVersion = startVersion;
TargetVersion = targetVersion;
Processor = Runner.Processor;
VersionInfo = new VersionInfo();
VersionTableMetaData = GetVersionTableMetaData();
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
LoadVersionInfo();
}
public ConnectionlessVersionLoader(IMigrationRunner runner, IAssemblyCollection assemblies, IMigrationConventions conventions, long startVersion, long targetVersion)
{
Runner = runner;
Assemblies = assemblies;
Conventions = conventions;
StartVersion = startVersion;
TargetVersion = targetVersion;
Processor = Runner.Processor;
VersionInfo = new VersionInfo();
VersionTableMetaData = GetVersionTableMetaData();
VersionMigration = new VersionMigration(VersionTableMetaData);
VersionSchemaMigration = new VersionSchemaMigration(VersionTableMetaData);
VersionUniqueMigration = new VersionUniqueMigration(VersionTableMetaData);
VersionDescriptionMigration = new VersionDescriptionMigration(VersionTableMetaData);
LoadVersionInfo();
}
private IMigrationProcessor InitializeProcessor(IAssemblyCollection assemblyCollection)
{
if (RunnerContext.Timeout == 0)
{
RunnerContext.Timeout = 30; // Set default timeout for command
}
var connectionString = LoadConnectionString(assemblyCollection);
var processorFactory = ProcessorFactoryProvider.GetFactory(RunnerContext.Database);
if (processorFactory == null)
throw new ProcessorFactoryNotFoundException(string.Format("The provider or dbtype parameter is incorrect. Available choices are {0}: ", ProcessorFactoryProvider.ListAvailableProcessorTypes()));
var processor = processorFactory.Create(connectionString, RunnerContext.Announcer, new ProcessorOptions
{
PreviewOnly = RunnerContext.PreviewOnly,
Timeout = RunnerContext.Timeout,
ProviderSwitches = RunnerContext.ProviderSwitches
});
return processor;
}
internal SetupGlobals(Engine engine, IPackagesCollection packages, IAssemblyCollection assemblies)
{
_engine = engine;
_packages = packages;
_assemblies = assemblies;
}
public void Invoke(IPackagesCollection packages, IAssemblyCollection assemblies, IConfigurableFileSystem fileSystem)
{
var scriptType = Assembly.GetExportedTypes().First(t => t.Name == "SetupScript");
MethodInfo runMethod = scriptType.GetMethod("Run", BindingFlags.Public | BindingFlags.Static);
runMethod.Invoke(null, new object[] { packages, assemblies, fileSystem });
}
public static bool Compare(this IAssemblyCollection source, IAssemblyCollection n)
{
return Compare<IAssembly>(source,n);
}
public static bool Compare(this IAssemblyCollection source, IAssemblyCollection n, Func<IAssembly, IAssembly, bool> checkitem)
{
return Compare<IAssembly>(source,n,checkitem);
}
public DefaultMigrationInformationLoader(IMigrationConventions conventions, IAssemblyCollection assemblies, string @namespace,
IEnumerable<string> tagsToMatch)
: this(conventions, assemblies, @namespace, false, tagsToMatch)
{
}
private string LoadConnectionString(IAssemblyCollection assemblyCollection)
{
var singleAssembly = (assemblyCollection != null && assemblyCollection.Assemblies != null && assemblyCollection.Assemblies.Length == 1) ? assemblyCollection.Assemblies[0] : null;
var singleAssemblyLocation = singleAssembly != null ? singleAssembly.Location : string.Empty;
var manager = new ConnectionStringManager(new NetConfigManager(), RunnerContext.Announcer, RunnerContext.Connection,
RunnerContext.ConnectionStringConfigPath, singleAssemblyLocation,
RunnerContext.Database);
manager.LoadConnectionString();
return manager.ConnectionString;
}
public static bool Compare(this IAssemblyCollection source, IAssemblyCollection n, Func<IAssembly, IAssembly, Action<string, string>, bool> checkitem, Action<string, string> errAct)
{
return Compare<IAssembly>(source,n,checkitem,errAct);
}
