protected virtual void Initialize()
{
List <Assembly> assemblies = new List <Assembly>();
#if COREFX
if (RunnerContext.TargetAssemblies != null)
{
assemblies.AddRange(RunnerContext.TargetAssemblies);
}
foreach (var target in RunnerContext.Targets ?? new string[0])
#else
foreach (var target in RunnerContext.Targets)
#endif
{
var assembly = AssemblyLoaderFactory.GetAssemblyLoader(target).Load();
if (!assemblies.Contains(assembly))
{
assemblies.Add(assembly);
}
}
var assemblyCollection = new AssemblyCollection(assemblies);
var processor = RunnerContext.NoConnection? InitializeConnectionlessProcessor():
#if COREFX
InitializeProcessor(assemblyCollection, ConnectionString);
#else
InitializeProcessor(assemblyCollection);
#endif
Runner = new MigrationRunner(assemblyCollection, RunnerContext, processor);
}
public void GetLoaderForAssembly_NonexistingAssembly_ReturnsNull()
{
var subject = new AssemblyLoaderFactory(Path.GetTempPath(), _assemblyRewriterMock.Object);
var result = subject.GetLoaderForAssembly(new AssemblyName(Guid.NewGuid().ToString()));
Assert.IsNull(result);
}
public void Dispose_DisposesAssemblyRewriter()
{
var subject = new AssemblyLoaderFactory(Path.GetTempPath(), _assemblyRewriterMock.Object);
subject.Dispose();
_assemblyRewriterMock.Verify(rewriter => rewriter.Dispose(), Times.Once);
}
protected virtual void Initialize()
{
var assembly = AssemblyLoaderFactory.GetAssemblyLoader(RunnerContext.Target).Load();
var processor = InitializeProcessor(assembly.Location);
Runner = new MigrationRunner(assembly, RunnerContext, processor);
}
public TaskExecutor(
[NotNull] IRunnerContext runnerContext,
[CanBeNull] IConnectionStringProvider connectionStringProvider,
[NotNull] AssemblyLoaderFactory assemblyLoaderFactory,
// ReSharper disable once UnusedParameter.Local
MigrationProcessorFactoryProvider factoryProvider)
: this(
runnerContext,
assemblyLoaderFactory,
connectionStringProvider)
{
}
protected virtual IEnumerable <Assembly> GetTargetAssemblies()
{
var assemblies = new HashSet <Assembly>();
foreach (var target in RunnerContext.Targets)
{
var assembly = AssemblyLoaderFactory.GetAssemblyLoader(target).Load();
if (assemblies.Add(assembly))
{
yield return(assembly);
}
}
}
public TaskExecutor(IRunnerContext runnerContext, AssemblyLoaderFactory assemblyLoaderFactory, MigrationProcessorFactoryProvider processorFactoryProvider)
{
if (runnerContext == null)
{
throw new ArgumentNullException("runnerContext");
}
if (assemblyLoaderFactory == null)
{
throw new ArgumentNullException("assemblyLoaderFactory");
}
RunnerContext = runnerContext;
AssemblyLoaderFactory = assemblyLoaderFactory;
ProcessorFactoryProvider = processorFactoryProvider;
}
/// <summary>
/// Get all assemblies for the given assembly names
/// </summary>
/// <param name="loaderFactory">The factory to create an <see cref="IAssemblyLoader"/> for a given assembly (file) name</param>
/// <param name="assemblyNames">The assembly (file) names</param>
/// <returns>The collection of assemblies that could be loaded</returns>
public static IEnumerable <Assembly> GetTargetAssemblies(
this AssemblyLoaderFactory loaderFactory,
IEnumerable <string> assemblyNames)
{
var assemblies = new HashSet <Assembly>();
foreach (var target in assemblyNames)
{
var assembly = loaderFactory.GetAssemblyLoader(target).Load();
if (assemblies.Add(assembly))
{
yield return(assembly);
}
}
}
public void TestLoaders()
{
string filename = GetType().Assembly.Location;
string assemblyName = GetType().Assembly.GetName().Name;
IAssemblyLoader assemblyLoaderFromFile = AssemblyLoaderFactory.GetAssemblyLoader(filename);
Assert.IsInstanceOfType(typeof(AssemblyLoaderFromFile), assemblyLoaderFromFile);
Assembly assemblyFromFile = assemblyLoaderFromFile.Load();
IAssemblyLoader assemblyLoaderFromName = AssemblyLoaderFactory.GetAssemblyLoader(assemblyName);
Assert.IsInstanceOfType(typeof(AssemblyLoaderFromName), assemblyLoaderFromName);
Assembly assemblyFromName = assemblyLoaderFromName.Load();
Assert.AreEqual(assemblyFromFile.FullName, assemblyFromName.FullName);
}
public TaskExecutor([NotNull] IRunnerContext runnerContext)
{
var runnerCtxt = runnerContext ?? throw new ArgumentNullException(nameof(runnerContext));
_logger = new AnnouncerFluentMigratorLogger(runnerCtxt.Announcer);
_runnerOptions = new RunnerOptions(runnerCtxt);
var asmLoaderFactory = new AssemblyLoaderFactory();
_assemblySource = new AssemblySource(() => new AssemblyCollection(asmLoaderFactory.GetTargetAssemblies(runnerCtxt.Targets)));
ConnectionStringProvider = new DefaultConnectionStringProvider();
_lazyServiceProvider = new Lazy <IServiceProvider>(
() => runnerContext
.CreateServices(
ConnectionStringProvider,
asmLoaderFactory)
.BuildServiceProvider(validateScopes: true));
}
public void GetLoaderForAssembly_ExistingAssembly_ReturnsRewriterResult()
{
string location = Assembly.GetExecutingAssembly().Location;
var loader = new AssemblyLoader(location);
_assemblyRewriterMock
.Setup(rewriter => rewriter.Rewrite(location))
.Returns(loader);
var subject = new AssemblyLoaderFactory(Path.GetDirectoryName(location), _assemblyRewriterMock.Object);
// Act
var result = subject.GetLoaderForAssembly(Assembly.GetExecutingAssembly().GetName());
// Assert
Assert.AreEqual(loader, result);
_assemblyRewriterMock.Verify();
}
internal static IServiceCollection CreateServices(
[NotNull] this IRunnerContext runnerContext,
[CanBeNull] IConnectionStringProvider connectionStringProvider,
[CanBeNull] AssemblyLoaderFactory defaultAssemblyLoaderFactory = null)
{
var services = new ServiceCollection();
var assemblyLoaderFactory = defaultAssemblyLoaderFactory ?? new AssemblyLoaderFactory();
if (!runnerContext.NoConnection && connectionStringProvider == null)
{
runnerContext.NoConnection = true;
}
// Configure the migration runner
services
.AddLogging(lb => lb.AddProvider(new LegacyFluentMigratorLoggerProvider(runnerContext.Announcer)))
.AddFluentMigratorCore()
.AddAllDatabases()
.Configure <SelectingProcessorAccessorOptions>(opt => opt.ProcessorId = runnerContext.Database)
.AddSingleton(assemblyLoaderFactory)
.Configure <TypeFilterOptions>(
opt =>
{
opt.Namespace = runnerContext.Namespace;
opt.NestedNamespaces = runnerContext.NestedNamespaces;
})
.Configure <AssemblySourceOptions>(opt => opt.AssemblyNames = runnerContext.Targets)
.Configure <RunnerOptions>(
opt => { opt.SetValuesFrom(runnerContext); })
.Configure <ProcessorOptions>(opt => { opt.SetValuesFrom(runnerContext); })
.Configure <AppConfigConnectionStringAccessorOptions>(
opt => opt.ConnectionStringConfigPath = runnerContext.ConnectionStringConfigPath);
// Configure the processor
if (runnerContext.NoConnection)
{
// Always return the connectionless processor
services
.AddScoped <IProcessorAccessor, ConnectionlessProcessorAccessor>();
}
return(services);
}
protected virtual void Initialize()
{
List <Assembly> assemblies = new List <Assembly>();
foreach (var target in RunnerContext.Targets)
{
var assembly = AssemblyLoaderFactory.GetAssemblyLoader(target).Load();
if (!assemblies.Contains(assembly))
{
assemblies.Add(assembly);
}
}
var assemblyCollection = new AssemblyCollection(assemblies);
var processor = RunnerContext.NoConnection? InitializeConnectionlessProcessor():InitializeProcessor(assemblyCollection);
Runner = new MigrationRunner(assemblyCollection, RunnerContext, processor);
}
public void RegisterAssembly_GetLoaderForAssemblyLoadsFromSuppliedPath()
{
string assemblyName = Guid.NewGuid().ToString();
string path = Path.Combine(@"c:\temp", assemblyName + ".dll");
var subject = new AssemblyLoaderFactory(Path.GetTempPath(), _assemblyRewriterMock.Object);
subject.RegisterAssembly(assemblyName, path);
var loader = new AssemblyLoader(path);
_assemblyRewriterMock
.Setup(rewriter => rewriter.Rewrite(path))
.Returns(loader)
.Verifiable();
// Act
var result = subject.GetLoaderForAssembly(new AssemblyName(assemblyName));
// Assert
Assert.AreEqual(loader, result);
_assemblyRewriterMock.Verify();
}
static async Task <int> RunCompare(
string assembly1,
string assembly2,
List <DirectoryInfo> a1deps,
List <DirectoryInfo> a2deps,
List <DirectoryInfo> deps,
DirectoryInfo outputApi,
SemverChangeType?expectedChangeType,
bool useDependencyChanges)
{
var platformDelimiter = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ';' : ':';
var frameworkAssemblies = (AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES") as string).Split(platformDelimiter);
var commonDeps = deps?.Select(d => d?.FullName).ToList() ?? new List <string>();
var assembly1Loader = AssemblyLoaderFactory.ResolveLoader(assembly1);
var assembly1Options = await assembly1Loader.LoadAssembly(new AssemblyLoaderOptions
{
AssemblyName = assembly1,
AssemblyDependencyPaths = commonDeps.Concat(a1deps?.Select(d => d?.FullName) ?? new List <string>()).ToArray(),
FrameworkAssemblies = frameworkAssemblies
});
if (string.IsNullOrWhiteSpace(assembly2))
{
return(SemverComparer.WritePublicApi(assembly1Options, outputApi?.FullName ?? ""));
}
var assembly2Loader = AssemblyLoaderFactory.ResolveLoader(assembly2);
var assembly2Options = await assembly2Loader.LoadAssembly(new AssemblyLoaderOptions
{
AssemblyName = assembly2,
AssemblyDependencyPaths = commonDeps.Concat(a2deps?.Select(d => d?.FullName) ?? new List <string>()).ToArray(),
FrameworkAssemblies = frameworkAssemblies
});
return(SemverComparer.Compare(assembly1Options, assembly2Options, outputApi?.FullName, expectedChangeType, useDependencyChanges));
}
public CustomTaskExecutor(IRunnerContext runnerContext, AssemblyLoaderFactory assemblyLoaderFactory, MigrationProcessorFactoryProvider processorFactoryProvider) : base(runnerContext, assemblyLoaderFactory, processorFactoryProvider)
{
}
private static void LoadAllDLLAssembliesFromProjectBinFolderToAppDomain()
{
AssemblyLoaderFactory
.CreateAssemblyLoader(null, null, Console.WriteLine)
.LoadAllDLLAssembliesFromProjectBinFolderToAppDomain();
}
public void Setup()
{
_assemblyLoaderFactory = new AssemblyLoaderFactory();
}
