/// <summary>
/// Initialize assemblies setup.
/// </summary>
/// <param name="logger"><see cref="ILogger"/> to use for logging.</param>
/// <param name="entryAssembly"><see cref="Assembly"/> to use as entry assembly - null indicates it will get it from the <see cref="Assembly.GetEntryAssembly()"/> method.</param>
/// <param name="defaultAssemblyProvider">The default <see cref="ICanProvideAssemblies"/> - null inidicates it will use the default implementation.</param>
/// <param name="excludeAllCallback">A callback to build on the exclude all specification.</param>
/// <returns>Discovered <see cref="IAssemblies"/>.</returns>
public static IAssemblies Start(
ILogger logger,
Assembly entryAssembly = null,
ICanProvideAssemblies defaultAssemblyProvider = null,
Action <ExcludeAll> excludeAllCallback = null)
{
var assembliesConfigurationBuilder = new AssembliesConfigurationBuilder();
var assembliesSpecification = assembliesConfigurationBuilder
.ExcludeAll()
.ExceptProjectLibraries()
.ExceptDolittleLibraries();
excludeAllCallback?.Invoke(assembliesSpecification);
if (entryAssembly == null)
{
entryAssembly = Assembly.GetEntryAssembly();
}
var assembliesConfiguration = new AssembliesConfiguration(assembliesConfigurationBuilder.RuleBuilder);
var assemblyFilters = new AssemblyFilters(assembliesConfiguration);
var assemblyProvider = new AssemblyProvider(
new ICanProvideAssemblies[] { defaultAssemblyProvider ?? new DefaultAssemblyProvider(logger, entryAssembly) },
assemblyFilters,
new AssemblyUtility(),
logger);
var assemblies = new Assemblies(entryAssembly, assemblyProvider);
return(assemblies);
}
bool ShouldRunAssembly(TestAssemblyInfo assemblyInfo)
{
if (assemblyInfo == null)
{
return(false);
}
if (AssemblyFilters == null || AssemblyFilters.Count == 0)
{
return(true);
}
bool include;
if (AssemblyFilters.TryGetValue(assemblyInfo.FullPath, out include))
{
return(ReportFilteredAssembly(assemblyInfo, include));
}
string fileName = Path.GetFileName(assemblyInfo.FullPath);
if (AssemblyFilters.TryGetValue(fileName, out include))
{
return(ReportFilteredAssembly(assemblyInfo, include));
}
fileName = Path.GetFileNameWithoutExtension(assemblyInfo.FullPath);
if (AssemblyFilters.TryGetValue(fileName, out include))
{
return(ReportFilteredAssembly(assemblyInfo, include));
}
return(runAssemblyByDefault);
}
public static IServiceCollection Add_doLittle(this IServiceCollection services)
{
var logAppenders = LoggingConfigurator.DiscoverAndConfigure(Internals.LoggerFactory);
doLittle.Logging.ILogger logger = new Logger(logAppenders);
var assembliesConfigurationBuilder = new AssembliesConfigurationBuilder();
assembliesConfigurationBuilder.IncludeAll();
var contractToImplementorsMap = new ContractToImplementorsMap();
var executingAssembly = typeof(doLittleModule).GetTypeInfo().Assembly;
contractToImplementorsMap.Feed(executingAssembly.GetTypes());
var assemblySpecifiers = new AssemblySpecifiers(assembliesConfigurationBuilder.RuleBuilder, logger);
assemblySpecifiers.SpecifyUsingSpecifiersFrom(executingAssembly);
var assembliesConfiguration = new AssembliesConfiguration(assembliesConfigurationBuilder.RuleBuilder);
var assemblyFilters = new AssemblyFilters(assembliesConfiguration);
var assemblyProvider = new AssemblyProvider(
new ICanProvideAssemblies[] { new DefaultAssemblyProvider(logger) },
assemblyFilters,
new AssemblyUtility(),
assemblySpecifiers);
Internals.AllAssemblies = assemblyProvider.GetAll();
Internals.AssemblyFilters = assemblyFilters;
Internals.AssembliesConfiguration = assembliesConfiguration;
Internals.AssemblyProvider = assemblyProvider;
Internals.Assemblies = new Assemblies(assemblyProvider);
return(services);
}
/// <inheritdoc/>
public void Perform()
{
var assembliesConfigurationBuilder = new AssembliesConfigurationBuilder();
assembliesConfigurationBuilder
.ExcludeAll()
.ExceptProjectLibraries()
.ExceptDolittleLibraries();
var entryAssembly = _buildTarget.Assembly;
var assembliesConfiguration = new AssembliesConfiguration(assembliesConfigurationBuilder.RuleBuilder);
var assemblyFilters = new AssemblyFilters(assembliesConfiguration);
var assemblyProvider = new Dolittle.Assemblies.AssemblyProvider(
new ICanProvideAssemblies[] { new DefaultAssemblyProvider(_logger, entryAssembly) },
assemblyFilters,
new AssemblyUtility(),
_logger
);
var assemblies = new Dolittle.Assemblies.Assemblies(entryAssembly, assemblyProvider);
var contractToImplementorsMap = new ContractToImplementorsMap(new AsyncScheduler());
Parallel.ForEach(assemblies.GetAll(), _ =>
{
try
{
var types = _.GetTypes();
contractToImplementorsMap.Feed(types);
}
catch {}
});
var contractsToImplementors = contractToImplementorsMap.ContractsAndImplementors;
var serializedMap = _serializer.SerializeMap(contractsToImplementors);
_modifiers.AddModifier(new EmbedResource(CachedContractToImplementorsMap.MapResourceName, Encoding.UTF8.GetBytes(serializedMap)));
var serializedTypes = _serializer.SerializeTypes(contractToImplementorsMap.All);
_modifiers.AddModifier(new EmbedResource(CachedContractToImplementorsMap.TypesResourceName, Encoding.UTF8.GetBytes(serializedTypes)));
var implementors = contractsToImplementors.Values.Sum(_ => _.Count());
_buildMessages.Information($"Embedded a map with {contractsToImplementors.Keys.Count} contracts to {implementors} implementors");
}
public IEnumerable <Type> GetMatchingTypes()
{
return
(CandidateAssemblies
.Where(x => AssemblyFilters.All(p => p(x)))
.SelectMany(x =>
{
try
{
return x.GetTypes();
}
catch
{
return new Type[] {};
}
})
.Where(x => !TypeFilters.Any(p => p(x))));
}
public override IEnumerable <Type> AllTypes()
{
AssemblyFilters?.Invoke(Assemblies);
return(Assemblies.SelectMany(a => a.GetAvailableTypesOrdered(NonPublicTypes)));
}
/// <summary>
/// When overridden in a derived class, executes the task.
/// </summary>
/// <returns>
/// true if the task successfully executed; otherwise, false.
/// </returns>
public override bool Execute()
{
var reportFilePatterns = Array.Empty <string>();
var targetDirectory = TargetDirectory;
var sourceDirectories = Array.Empty <string>();
string historyDirectory = HistoryDirectory;
var reportTypes = Array.Empty <string>();
var plugins = Array.Empty <string>();
var assemblyFilters = Array.Empty <string>();
var classFilters = Array.Empty <string>();
var fileFilters = Array.Empty <string>();
string verbosityLevel = VerbosityLevel;
string tag = Tag;
var config = Config.Build(ProjectDirectory).GetSection(SectionName);
string value = null;
if (ReportFiles.Length > 0)
{
reportFilePatterns = ReportFiles.Select(r => r.ItemSpec).ToArray();
}
else if (config.TryGetString("reports", out value))
{
reportFilePatterns = value.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
}
else
{
reportFilePatterns = config
.GetAll("report")
.Select(x => x.RawValue)
.Where(x => !string.IsNullOrEmpty(x))
.ToArray();
}
if (reportFilePatterns.Length == 0)
{
Log.LogError($"{nameof(ReportFiles)} is required.");
return(false);
}
if (string.IsNullOrEmpty(targetDirectory) &&
config.TryGetString("targetdir", out value))
{
targetDirectory = value;
}
if (string.IsNullOrEmpty(targetDirectory))
{
Log.LogError($"{nameof(TargetDirectory)} is required.");
return(false);
}
if (SourceDirectories.Length > 0)
{
sourceDirectories = SourceDirectories.Select(r => r.ItemSpec).ToArray();
}
else if (config.TryGetString("sourcedirs", out value))
{
sourceDirectories = value.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
}
else
{
sourceDirectories = config
.GetAll("sourcedir")
.Select(x => x.RawValue)
.Where(x => !string.IsNullOrEmpty(x))
.ToArray();
}
if (string.IsNullOrEmpty(HistoryDirectory) &&
config.TryGetString("historydir", out value))
{
historyDirectory = value;
}
if (ReportTypes.Length > 0)
{
reportTypes = ReportTypes.Select(r => r.ItemSpec).ToArray();
}
else if (config.TryGetString("reporttypes", out value))
{
reportTypes = value.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
}
else
{
reportTypes = config
.GetAll("reporttype")
.Select(x => x.RawValue)
.Where(x => !string.IsNullOrEmpty(x))
.ToArray();
}
if (Plugins.Length > 0)
{
plugins = Plugins.Select(r => r.ItemSpec).ToArray();
}
else if (config.TryGetString("plugins", out value))
{
plugins = value.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
}
else
{
plugins = config
.GetAll("plugin")
.Select(x => x.RawValue)
.Where(x => !string.IsNullOrEmpty(x))
.ToArray();
}
if (AssemblyFilters.Length > 0)
{
assemblyFilters = AssemblyFilters.Select(r => r.ItemSpec).ToArray();
}
else if (Filters.Length > 0)
{
assemblyFilters = Filters.Select(r => r.ItemSpec).ToArray();
}
else if (config.TryGetString("assemblyfilters", out value))
{
assemblyFilters = value.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
}
else
{
assemblyFilters = config
.GetAll("assemblyfilter")
.Select(x => x.RawValue)
.Where(x => !string.IsNullOrEmpty(x))
.ToArray();
}
if (ClassFilters.Length > 0)
{
classFilters = ClassFilters.Select(r => r.ItemSpec).ToArray();
}
else if (config.TryGetString("classfilters", out value))
{
classFilters = value.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
}
else
{
classFilters = config
.GetAll("classfilter")
.Select(x => x.RawValue)
.Where(x => !string.IsNullOrEmpty(x))
.ToArray();
}
if (FileFilters.Length > 0)
{
fileFilters = FileFilters.Select(r => r.ItemSpec).ToArray();
}
else if (config.TryGetString("filefilters", out value))
{
fileFilters = value.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
}
else
{
fileFilters = config
.GetAll("filefilter")
.Select(x => x.RawValue)
.Where(x => !string.IsNullOrEmpty(x))
.ToArray();
}
if (string.IsNullOrEmpty(verbosityLevel) &&
config.TryGetString("verbosity", out value))
{
verbosityLevel = value;
}
if (string.IsNullOrEmpty(tag) &&
config.TryGetString("tag", out value))
{
tag = value;
}
var configuration = new ReportConfiguration(
reportFilePatterns,
targetDirectory,
sourceDirectories,
historyDirectory,
reportTypes,
plugins,
assemblyFilters,
classFilters,
fileFilters,
verbosityLevel,
tag);
return(new Generator().GenerateReport(configuration));
}
public IEnumerable <Assembly> GetAssemblies()
{
EnsureLoaded();
return(loadedAssemblies.Where(a => AssemblyFilters.All(func => func(a))));
}
