private AggregateCatalog CreateAggregateCatalog(IEnumerable <string> paths)
{
var catalog = new AggregateCatalog();
foreach (var path in paths)
{
_logger.DebugFormat("Found assembly: {0}", path);
try
{
if (_assemblyUtility.IsManagedAssembly(path))
{
_logger.DebugFormat("Adding Assembly: {0} to catalog", path);
var name = _assemblyUtility.GetAssemblyName(path);
var assembly = _assemblyUtility.Load(name);
_addToCatalog(assembly, catalog);
}
else
{
_logger.DebugFormat("Skipping Adding Native Assembly {0} to catalog", path);
}
}
catch (Exception exception)
{
_logger.DebugFormat("Module Loader exception: {0}", exception.Message);
}
}
return(catalog);
}
private void GetAssemblyNames(
string packageDir,
IEnumerable <IPackageReference> packageReferences,
ICollection <string> names,
bool strictLoad)
{
foreach (var packageReference in packageReferences)
{
var packageObject = _packageContainer.FindPackage(packageDir, packageReference);
if (packageObject == null)
{
_logger.WarnFormat(
CultureInfo.InvariantCulture,
"Cannot find: {0} {1}",
packageReference.PackageId,
packageReference.Version);
continue;
}
var compatibleDlls = packageObject.GetCompatibleDlls(packageReference.FrameworkName);
if (compatibleDlls == null)
{
_logger.WarnFormat(
CultureInfo.InvariantCulture,
"Cannot find compatible binaries for {0} in: {1} {2}",
packageReference.FrameworkName,
packageReference.PackageId,
packageReference.Version);
continue;
}
foreach (var name in compatibleDlls
.Select(packageFile => Path.Combine(packageDir, packageObject.FullName, packageFile))
.Where(path => _assemblyUtility.IsManagedAssembly(path))
.Concat(packageObject.FrameworkAssemblies)
.Where(name => !names.Contains(name)))
{
names.Add(name);
_logger.Debug("Found: " + name);
}
if (packageObject.Dependencies == null || !packageObject.Dependencies.Any() || !strictLoad)
{
continue;
}
var dependencyReferences = packageObject.Dependencies
.Where(dependency =>
_topLevelPackages.All(topLevelPackage => topLevelPackage.PackageId != dependency.Id))
.Select(dependency =>
new PackageReference(dependency.Id, dependency.FrameworkName, dependency.Version));
GetAssemblyNames(packageDir, dependencyReferences, names, true);
}
}
public IEnumerable <string> GetBinAssemblyPaths(string path)
{
var binFolder = Path.Combine(path, _fileSystem.BinFolder);
if (!_fileSystem.DirectoryExists(binFolder))
{
return(Enumerable.Empty <string>());
}
var assemblies = _fileSystem.EnumerateBinaries(binFolder, SearchOption.TopDirectoryOnly)
.Where(f => _assemblyUtility.IsManagedAssembly(f))
.ToList();
foreach (var assembly in assemblies)
{
_logger.DebugFormat("Found assembly in bin folder: {0}", Path.GetFileName(assembly));
}
return(assemblies);
}
private IEnumerable <string> GetBinAssemblyPaths(string path)
{
var binFolder = Path.Combine(path, _fileSystem.BinFolder);
if (!_fileSystem.DirectoryExists(binFolder))
{
yield break;
}
foreach (var assembly in _fileSystem.EnumerateBinaries(binFolder, SearchOption.TopDirectoryOnly)
.Where(f => _assemblyUtility.IsManagedAssembly(f)))
{
_logger.DebugFormat("Found assembly in bin folder: {0}", Path.GetFileName(assembly));
yield return(assembly);
}
}
public virtual void AddAssemblyPaths(IEnumerable <string> assemblyPaths)
{
Guard.AgainstNullArgument("assemblyPaths", assemblyPaths);
foreach (var assemblyPath in assemblyPaths)
{
if (_assemblyUtility.IsManagedAssembly(assemblyPath))
{
var info = new AssemblyInfo {
Path = assemblyPath
};
var name = _assemblyUtility.GetAssemblyName(assemblyPath);
info.Version = name.Version;
AssemblyInfo foundInfo;
var found = _assemblyInfoMap.TryGetValue(name.Name, out foundInfo);
if (!found || foundInfo.Version.CompareTo(info.Version) < 0)
{
// if the assembly being passed is a higher version
// and an assembly with it's name has already been resolved
if (found && foundInfo.Assembly != null)
{
_logger.WarnFormat(
"Conflict: Assembly {0} with version {1} cannot be added as it has already been resolved",
assemblyPath,
info.Version);
continue;
}
_logger.DebugFormat("Mapping Assembly {0} to version:{1}", name.Name, name.Version);
_assemblyInfoMap[name.Name] = info;
}
}
else
{
_logger.DebugFormat("Skipping Mapping Native Assembly {0}", assemblyPath);
}
}
}
private IEnumerable <string> GetBinAssemblies(string path)
{
var binFolder = Path.Combine(path, Constants.BinFolder);
if (!_fileSystem.DirectoryExists(binFolder))
{
return(Enumerable.Empty <string>());
}
var assemblies = _fileSystem.EnumerateFiles(binFolder, "*.dll")
.Union(_fileSystem.EnumerateFiles(binFolder, "*.exe"))
.Where(f => _assemblyUtility.IsManagedAssembly(f))
.ToList();
foreach (var assembly in assemblies)
{
_logger.DebugFormat("Found assembly in bin folder: {0}", Path.GetFileName(assembly));
}
return(assemblies);
}
private IEnumerable <string> GetBinAssemblies(string path, string scriptName)
{
var binFolder = Path.Combine(path, Constants.BinFolder);
if (!_fileSystem.DirectoryExists(binFolder))
{
return(Enumerable.Empty <string>());
}
var dllName = string.IsNullOrEmpty(scriptName) ? string.Empty : scriptName.Replace(Path.GetExtension(scriptName), ".dll");
var assemblies = _fileSystem.EnumerateFiles(binFolder, "*.dll")
.Union(_fileSystem.EnumerateFiles(binFolder, "*.exe"))
.Where(f => _assemblyUtility.IsManagedAssembly(f) && !dllName.Equals(Path.GetFileName(f)))
.ToList();
foreach (var assembly in assemblies)
{
_logger.DebugFormat("Found assembly in bin folder: {0}", Path.GetFileName(assembly));
}
return(assemblies);
}
// HACK: Filter out assemblies in the GAC by checking if full path is specified.
private static bool ShouldLoadAssembly(IFileSystem fileSystem, IAssemblyUtility assemblyUtility, string assembly)
{
return(fileSystem.IsPathRooted(assembly) && assemblyUtility.IsManagedAssembly(assembly));
}
// HACK: Filter out assemblies in the GAC by checking if full path is specified.
private static bool ShouldLoadAssembly(IFileSystem fileSystem, IAssemblyUtility assemblyUtility, string assembly)
{
return fileSystem.IsPathRooted(assembly) && assemblyUtility.IsManagedAssembly(assembly);
}
public void ShouldReturnFalseWhenThePathDoesNotPointToAManagedAssembly()
{
_assemblyUtility.IsManagedAssembly("ScriptCs.Core.Tests.dll.config").ShouldBeFalse();
}
public void ShouldReturnTrueWhenThePathIsNotRootedAndDoesNotHaveADllOrExeExtension()
{
_assemblyUtility.IsManagedAssembly("System.Data").ShouldBeTrue();
}
